quantrs2_device/algorithm_marketplace/
discovery.rs

1//! Algorithm Discovery Engine
2//!
3//! This module provides intelligent algorithm discovery capabilities including
4//! semantic search, recommendation systems, and personalized algorithm suggestions.
5
6use super::*;
7
8/// Algorithm discovery engine
9pub struct AlgorithmDiscoveryEngine {
10    config: DiscoveryConfig,
11    search_engine: Arc<RwLock<SemanticSearchEngine>>,
12    recommendation_engine: Arc<RwLock<RecommendationEngine>>,
13    ranking_system: Arc<RwLock<RankingSystem>>,
14    personalization_engine: Arc<RwLock<PersonalizationEngine>>,
15    cache: Arc<RwLock<DiscoveryCache>>,
16}
17
18/// Discovery criteria for searching algorithms
19#[derive(Debug, Clone, Serialize, Deserialize)]
20pub struct DiscoveryCriteria {
21    pub query: Option<String>,
22    pub category: Option<AlgorithmCategory>,
23    pub tags: Vec<String>,
24    pub author: Option<String>,
25    pub min_rating: Option<f64>,
26    pub hardware_constraints: Option<HardwareConstraints>,
27    pub performance_requirements: Option<PerformanceRequirements>,
28    pub complexity_filter: Option<ComplexityFilter>,
29    pub license_filter: Option<Vec<LicenseType>>,
30    pub sort_by: SortBy,
31    pub limit: usize,
32    pub offset: usize,
33    pub include_experimental: bool,
34    pub user_context: Option<UserContext>,
35}
36
37/// Hardware constraints for discovery
38#[derive(Debug, Clone, Serialize, Deserialize)]
39pub struct HardwareConstraints {
40    pub max_qubits: Option<usize>,
41    pub min_qubits: Option<usize>,
42    pub required_gates: Vec<String>,
43    pub forbidden_gates: Vec<String>,
44    pub topology_constraints: Vec<TopologyType>,
45    pub platform_compatibility: Vec<String>,
46    pub fidelity_threshold: Option<f64>,
47}
48
49/// Performance requirements for discovery
50#[derive(Debug, Clone, Serialize, Deserialize)]
51pub struct PerformanceRequirements {
52    pub max_execution_time: Option<Duration>,
53    pub min_success_probability: Option<f64>,
54    pub max_error_rate: Option<f64>,
55    pub min_quantum_advantage: Option<f64>,
56    pub resource_efficiency: Option<f64>,
57}
58
59/// Complexity filter for algorithms
60#[derive(Debug, Clone, Serialize, Deserialize)]
61pub struct ComplexityFilter {
62    pub max_time_complexity: Option<String>,
63    pub max_space_complexity: Option<String>,
64    pub max_circuit_depth: Option<usize>,
65    pub max_gate_count: Option<usize>,
66}
67
68/// Sorting options for discovery results
69#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
70pub enum SortBy {
71    Relevance,
72    Popularity,
73    Rating,
74    RecentlyUpdated,
75    Performance,
76    Alphabetical,
77    QuantumAdvantage,
78    ResourceEfficiency,
79    Custom(String),
80}
81
82/// User context for personalized discovery
83#[derive(Debug, Clone, Serialize, Deserialize)]
84pub struct UserContext {
85    pub user_id: String,
86    pub experience_level: ExperienceLevel,
87    pub research_areas: Vec<String>,
88    pub preferred_platforms: Vec<String>,
89    pub usage_history: Vec<String>,
90    pub collaboration_preferences: Vec<String>,
91}
92
93/// Experience levels
94#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
95pub enum ExperienceLevel {
96    Beginner,
97    Intermediate,
98    Advanced,
99    Expert,
100    Researcher,
101}
102
103/// Algorithm information for discovery results
104#[derive(Debug, Clone, Serialize, Deserialize)]
105pub struct AlgorithmInfo {
106    pub algorithm_id: String,
107    pub name: String,
108    pub version: String,
109    pub description: String,
110    pub author: String,
111    pub category: AlgorithmCategory,
112    pub tags: Vec<String>,
113    pub rating: f64,
114    pub downloads: u64,
115    pub last_updated: SystemTime,
116    pub quantum_advantage: QuantumAdvantage,
117    pub hardware_requirements: HardwareRequirements,
118    pub complexity_info: ComplexityInfo,
119    pub discovery_score: f64,
120    pub personalization_score: Option<f64>,
121}
122
123/// Complexity information summary
124#[derive(Debug, Clone, Serialize, Deserialize)]
125pub struct ComplexityInfo {
126    pub time_complexity: String,
127    pub space_complexity: String,
128    pub circuit_depth: usize,
129    pub gate_count: usize,
130    pub qubit_count: usize,
131}
132
133/// Semantic search engine
134pub struct SemanticSearchEngine {
135    word_embeddings: HashMap<String, Vec<f64>>,
136    algorithm_embeddings: HashMap<String, Vec<f64>>,
137    similarity_cache: HashMap<String, Vec<(String, f64)>>,
138    search_index: InvertedIndex,
139}
140
141/// Inverted search index
142#[derive(Debug, Clone)]
143pub struct InvertedIndex {
144    term_to_algorithms: HashMap<String, Vec<String>>,
145    algorithm_to_terms: HashMap<String, Vec<String>>,
146    term_frequencies: HashMap<String, HashMap<String, f64>>,
147    document_frequencies: HashMap<String, usize>,
148}
149
150/// Recommendation engine
151pub struct RecommendationEngine {
152    user_profiles: HashMap<String, UserProfile>,
153    algorithm_similarities: HashMap<String, Vec<(String, f64)>>,
154    collaborative_filters: Vec<Box<dyn CollaborativeFilter + Send + Sync>>,
155    content_filters: Vec<Box<dyn ContentFilter + Send + Sync>>,
156    hybrid_weights: HybridWeights,
157}
158
159/// User profile for recommendations
160#[derive(Debug, Clone)]
161pub struct UserProfile {
162    pub user_id: String,
163    pub interests: Vec<String>,
164    pub expertise_areas: Vec<String>,
165    pub interaction_history: Vec<UserInteraction>,
166    pub preference_vector: Vec<f64>,
167    pub temporal_patterns: TemporalPatterns,
168}
169
170/// User interaction data
171#[derive(Debug, Clone)]
172pub struct UserInteraction {
173    pub algorithm_id: String,
174    pub interaction_type: InteractionType,
175    pub timestamp: SystemTime,
176    pub duration: Option<Duration>,
177    pub rating: Option<f64>,
178    pub feedback: Option<String>,
179}
180
181/// Interaction types
182#[derive(Debug, Clone, PartialEq, Eq)]
183pub enum InteractionType {
184    View,
185    Download,
186    Deploy,
187    Rate,
188    Review,
189    Share,
190    Bookmark,
191    Fork,
192    Contribute,
193}
194
195/// Temporal patterns in user behavior
196#[derive(Debug, Clone)]
197pub struct TemporalPatterns {
198    pub activity_by_hour: Vec<f64>,
199    pub activity_by_day: Vec<f64>,
200    pub seasonal_patterns: Vec<f64>,
201    pub burst_periods: Vec<(SystemTime, Duration)>,
202}
203
204/// Collaborative filtering trait
205pub trait CollaborativeFilter {
206    fn recommend(&self, user_id: &str, candidates: &[String]) -> DeviceResult<Vec<(String, f64)>>;
207    fn update_model(&mut self, interactions: &[UserInteraction]) -> DeviceResult<()>;
208}
209
210/// Content-based filtering trait
211pub trait ContentFilter {
212    fn recommend(
213        &self,
214        user_profile: &UserProfile,
215        candidates: &[String],
216    ) -> DeviceResult<Vec<(String, f64)>>;
217    fn extract_features(&self, algorithm_id: &str) -> DeviceResult<Vec<f64>>;
218}
219
220/// Hybrid recommendation weights
221#[derive(Debug, Clone)]
222pub struct HybridWeights {
223    pub collaborative_weight: f64,
224    pub content_weight: f64,
225    pub popularity_weight: f64,
226    pub temporal_weight: f64,
227    pub semantic_weight: f64,
228}
229
230/// Ranking system for algorithm discovery
231pub struct RankingSystem {
232    ranking_algorithms: Vec<Box<dyn RankingAlgorithm + Send + Sync>>,
233    feature_extractors: Vec<Box<dyn FeatureExtractor + Send + Sync>>,
234    learning_to_rank_model: Option<LearningToRankModel>,
235    ranking_cache: HashMap<String, Vec<RankedResult>>,
236}
237
238/// Ranking algorithm trait
239pub trait RankingAlgorithm {
240    fn rank(
241        &self,
242        candidates: &[AlgorithmInfo],
243        criteria: &DiscoveryCriteria,
244    ) -> DeviceResult<Vec<RankedResult>>;
245    fn get_algorithm_name(&self) -> String;
246}
247
248/// Feature extractor trait
249pub trait FeatureExtractor {
250    fn extract_features(
251        &self,
252        algorithm: &AlgorithmInfo,
253        context: &DiscoveryCriteria,
254    ) -> DeviceResult<Vec<f64>>;
255    fn get_feature_names(&self) -> Vec<String>;
256}
257
258/// Ranked result with score
259#[derive(Debug, Clone)]
260pub struct RankedResult {
261    pub algorithm_id: String,
262    pub rank: usize,
263    pub score: f64,
264    pub feature_scores: HashMap<String, f64>,
265    pub explanation: RankingExplanation,
266}
267
268/// Ranking explanation
269#[derive(Debug, Clone)]
270pub struct RankingExplanation {
271    pub primary_factors: Vec<String>,
272    pub relevance_score: f64,
273    pub popularity_score: f64,
274    pub quality_score: f64,
275    pub personalization_boost: f64,
276    pub detailed_explanation: String,
277}
278
279/// Learning-to-rank model
280#[derive(Debug, Clone)]
281pub struct LearningToRankModel {
282    pub model_type: String,
283    pub feature_weights: Vec<f64>,
284    pub training_data: Vec<TrainingExample>,
285    pub model_performance: ModelPerformance,
286}
287
288/// Training example for learning-to-rank
289#[derive(Debug, Clone)]
290pub struct TrainingExample {
291    pub query_id: String,
292    pub algorithm_id: String,
293    pub features: Vec<f64>,
294    pub relevance_score: f64,
295    pub user_action: Option<InteractionType>,
296}
297
298/// Model performance metrics
299#[derive(Debug, Clone)]
300pub struct ModelPerformance {
301    pub ndcg_at_10: f64,
302    pub map_score: f64,
303    pub precision_at_k: Vec<f64>,
304    pub recall_at_k: Vec<f64>,
305    pub click_through_rate: f64,
306}
307
308/// Personalization engine
309pub struct PersonalizationEngine {
310    personalization_models: HashMap<String, PersonalizationModel>,
311    context_analyzers: Vec<Box<dyn ContextAnalyzer + Send + Sync>>,
312    adaptation_strategies: Vec<Box<dyn AdaptationStrategy + Send + Sync>>,
313    privacy_preserving: bool,
314}
315
316/// Personalization model
317#[derive(Debug, Clone)]
318pub struct PersonalizationModel {
319    pub user_id: String,
320    pub model_parameters: Vec<f64>,
321    pub context_features: Vec<f64>,
322    pub adaptation_history: Vec<AdaptationEvent>,
323    pub model_confidence: f64,
324}
325
326/// Context analyzer trait
327pub trait ContextAnalyzer {
328    fn analyze_context(&self, user_context: &UserContext) -> DeviceResult<Vec<f64>>;
329    fn get_context_dimensions(&self) -> Vec<String>;
330}
331
332/// Adaptation strategy trait
333pub trait AdaptationStrategy {
334    fn adapt_recommendations(
335        &self,
336        base_recommendations: Vec<(String, f64)>,
337        user_context: &UserContext,
338    ) -> DeviceResult<Vec<(String, f64)>>;
339    fn update_strategy(&mut self, feedback: &[UserInteraction]) -> DeviceResult<()>;
340}
341
342/// Adaptation event
343#[derive(Debug, Clone)]
344pub struct AdaptationEvent {
345    pub timestamp: SystemTime,
346    pub adaptation_type: AdaptationType,
347    pub parameters_changed: Vec<String>,
348    pub performance_impact: f64,
349}
350
351/// Adaptation types
352#[derive(Debug, Clone, PartialEq, Eq)]
353pub enum AdaptationType {
354    UserFeedback,
355    PerformanceOptimization,
356    ConceptDrift,
357    ContextChange,
358    ColdStart,
359}
360
361/// Discovery cache
362#[derive(Debug, Clone)]
363pub struct DiscoveryCache {
364    query_cache: HashMap<String, CachedResult>,
365    recommendation_cache: HashMap<String, CachedRecommendations>,
366    similarity_cache: HashMap<String, HashMap<String, f64>>,
367    cache_stats: CacheStatistics,
368}
369
370/// Cached search result
371#[derive(Debug, Clone)]
372pub struct CachedResult {
373    pub results: Vec<AlgorithmInfo>,
374    pub cached_at: SystemTime,
375    pub expires_at: SystemTime,
376    pub hit_count: usize,
377}
378
379/// Cached recommendations
380#[derive(Debug, Clone)]
381pub struct CachedRecommendations {
382    pub user_id: String,
383    pub recommendations: Vec<(String, f64)>,
384    pub cached_at: SystemTime,
385    pub context_hash: String,
386}
387
388/// Cache statistics
389#[derive(Debug, Clone, Default)]
390pub struct CacheStatistics {
391    pub total_requests: u64,
392    pub cache_hits: u64,
393    pub cache_misses: u64,
394    pub evictions: u64,
395    pub memory_usage: usize,
396}
397
398impl AlgorithmDiscoveryEngine {
399    /// Create a new discovery engine
400    pub fn new(config: &DiscoveryConfig) -> DeviceResult<Self> {
401        let search_engine = Arc::new(RwLock::new(SemanticSearchEngine::new()?));
402        let recommendation_engine = Arc::new(RwLock::new(RecommendationEngine::new()?));
403        let ranking_system = Arc::new(RwLock::new(RankingSystem::new()?));
404        let personalization_engine = Arc::new(RwLock::new(PersonalizationEngine::new()?));
405        let cache = Arc::new(RwLock::new(DiscoveryCache::new()));
406
407        Ok(Self {
408            config: config.clone(),
409            search_engine,
410            recommendation_engine,
411            ranking_system,
412            personalization_engine,
413            cache,
414        })
415    }
416
417    /// Initialize the discovery engine
418    pub async fn initialize(&self) -> DeviceResult<()> {
419        // Initialize all components
420        Ok(())
421    }
422
423    /// Search for algorithms based on criteria
424    pub async fn search_algorithms(
425        &self,
426        criteria: DiscoveryCriteria,
427    ) -> DeviceResult<Vec<AlgorithmInfo>> {
428        // Check cache first
429        let cache_key = self.generate_cache_key(&criteria);
430        if let Some(cached_result) = self.check_cache(&cache_key).await? {
431            return Ok(cached_result);
432        }
433
434        // Perform search
435        let mut results = self.perform_search(&criteria).await?;
436
437        // Apply ranking
438        results = self.apply_ranking(results, &criteria).await?;
439
440        // Apply personalization if user context is provided
441        if let Some(user_context) = &criteria.user_context {
442            results = self.apply_personalization(results, user_context).await?;
443        }
444
445        // Cache results
446        self.cache_results(&cache_key, &results).await?;
447
448        Ok(results)
449    }
450
451    /// Get recommendations for a user
452    pub async fn get_recommendations(
453        &self,
454        user_id: &str,
455        count: usize,
456    ) -> DeviceResult<Vec<AlgorithmInfo>> {
457        let recommendation_engine = self
458            .recommendation_engine
459            .read()
460            .unwrap_or_else(|e| e.into_inner());
461
462        // Get base recommendations
463        let recommendations = recommendation_engine.get_recommendations(user_id, count)?;
464
465        // Convert to AlgorithmInfo (simplified)
466        let mut results = Vec::new();
467        for (algorithm_id, score) in recommendations {
468            let info = AlgorithmInfo {
469                algorithm_id: algorithm_id.clone(),
470                name: format!("Algorithm {algorithm_id}"),
471                version: "1.0.0".to_string(),
472                description: "Recommended algorithm".to_string(),
473                author: "Unknown".to_string(),
474                category: AlgorithmCategory::Optimization,
475                tags: vec![],
476                rating: 4.5,
477                downloads: 1000,
478                last_updated: SystemTime::now(),
479                quantum_advantage: QuantumAdvantage {
480                    advantage_type: AdvantageType::Quadratic,
481                    speedup_factor: Some(2.0),
482                    problem_size_threshold: Some(100),
483                    verification_method: "Theoretical".to_string(),
484                    theoretical_basis: "Grover's algorithm".to_string(),
485                    experimental_validation: false,
486                },
487                hardware_requirements: HardwareRequirements {
488                    min_qubits: 1,
489                    recommended_qubits: 10,
490                    max_circuit_depth: 100,
491                    required_gates: vec!["H".to_string(), "CNOT".to_string()],
492                    connectivity_requirements: ConnectivityRequirements {
493                        topology_type: TopologyType::AllToAll,
494                        connectivity_degree: None,
495                        all_to_all_required: false,
496                        specific_connections: vec![],
497                    },
498                    fidelity_requirements: FidelityRequirements {
499                        min_gate_fidelity: 0.99,
500                        min_readout_fidelity: 0.95,
501                        min_state_preparation_fidelity: 0.98,
502                        coherence_time_requirement: Duration::from_micros(100),
503                        error_budget: 0.01,
504                    },
505                    supported_platforms: vec!["IBM".to_string()],
506                    special_hardware: vec![],
507                },
508                complexity_info: ComplexityInfo {
509                    time_complexity: "O(sqrt(N))".to_string(),
510                    space_complexity: "O(log N)".to_string(),
511                    circuit_depth: 50,
512                    gate_count: 100,
513                    qubit_count: 10,
514                },
515                discovery_score: score,
516                personalization_score: Some(score),
517            };
518            results.push(info);
519        }
520
521        Ok(results)
522    }
523
524    // Helper methods
525    async fn perform_search(
526        &self,
527        criteria: &DiscoveryCriteria,
528    ) -> DeviceResult<Vec<AlgorithmInfo>> {
529        // Implement actual search logic
530        Ok(vec![])
531    }
532
533    async fn apply_ranking(
534        &self,
535        mut results: Vec<AlgorithmInfo>,
536        criteria: &DiscoveryCriteria,
537    ) -> DeviceResult<Vec<AlgorithmInfo>> {
538        let ranking_system = self
539            .ranking_system
540            .read()
541            .unwrap_or_else(|e| e.into_inner());
542        let ranked_results = ranking_system.rank_algorithms(&results, criteria)?;
543
544        // Sort by rank
545        results.sort_by(|a, b| {
546            let rank_a = ranked_results
547                .iter()
548                .find(|r| r.algorithm_id == a.algorithm_id)
549                .map_or(usize::MAX, |r| r.rank);
550            let rank_b = ranked_results
551                .iter()
552                .find(|r| r.algorithm_id == b.algorithm_id)
553                .map_or(usize::MAX, |r| r.rank);
554            rank_a.cmp(&rank_b)
555        });
556
557        Ok(results)
558    }
559
560    async fn apply_personalization(
561        &self,
562        mut results: Vec<AlgorithmInfo>,
563        user_context: &UserContext,
564    ) -> DeviceResult<Vec<AlgorithmInfo>> {
565        let personalization_engine = self
566            .personalization_engine
567            .read()
568            .unwrap_or_else(|e| e.into_inner());
569        let personalized_scores =
570            personalization_engine.personalize_results(&results, user_context)?;
571
572        // Update personalization scores
573        for (i, score) in personalized_scores.iter().enumerate() {
574            if i < results.len() {
575                results[i].personalization_score = Some(*score);
576            }
577        }
578
579        Ok(results)
580    }
581
582    fn generate_cache_key(&self, criteria: &DiscoveryCriteria) -> String {
583        // Generate a unique cache key based on criteria
584        format!("search:{criteria:?}")
585    }
586
587    async fn check_cache(&self, cache_key: &str) -> DeviceResult<Option<Vec<AlgorithmInfo>>> {
588        let cache = self.cache.read().unwrap_or_else(|e| e.into_inner());
589        if let Some(cached_result) = cache.query_cache.get(cache_key) {
590            if cached_result.expires_at > SystemTime::now() {
591                return Ok(Some(cached_result.results.clone()));
592            }
593        }
594        Ok(None)
595    }
596
597    async fn cache_results(&self, cache_key: &str, results: &[AlgorithmInfo]) -> DeviceResult<()> {
598        let mut cache = self.cache.write().unwrap_or_else(|e| e.into_inner());
599        let cached_result = CachedResult {
600            results: results.to_vec(),
601            cached_at: SystemTime::now(),
602            expires_at: SystemTime::now() + self.config.cache_ttl,
603            hit_count: 0,
604        };
605        cache
606            .query_cache
607            .insert(cache_key.to_string(), cached_result);
608        Ok(())
609    }
610}
611
612// Implementation stubs for sub-components
613impl SemanticSearchEngine {
614    fn new() -> DeviceResult<Self> {
615        Ok(Self {
616            word_embeddings: HashMap::new(),
617            algorithm_embeddings: HashMap::new(),
618            similarity_cache: HashMap::new(),
619            search_index: InvertedIndex::new(),
620        })
621    }
622}
623
624impl InvertedIndex {
625    fn new() -> Self {
626        Self {
627            term_to_algorithms: HashMap::new(),
628            algorithm_to_terms: HashMap::new(),
629            term_frequencies: HashMap::new(),
630            document_frequencies: HashMap::new(),
631        }
632    }
633}
634
635impl RecommendationEngine {
636    fn new() -> DeviceResult<Self> {
637        Ok(Self {
638            user_profiles: HashMap::new(),
639            algorithm_similarities: HashMap::new(),
640            collaborative_filters: vec![],
641            content_filters: vec![],
642            hybrid_weights: HybridWeights {
643                collaborative_weight: 0.4,
644                content_weight: 0.3,
645                popularity_weight: 0.15,
646                temporal_weight: 0.1,
647                semantic_weight: 0.05,
648            },
649        })
650    }
651
652    fn get_recommendations(
653        &self,
654        _user_id: &str,
655        count: usize,
656    ) -> DeviceResult<Vec<(String, f64)>> {
657        // Simplified recommendation logic
658        let mut recommendations = Vec::new();
659        for i in 0..count {
660            recommendations.push((format!("algorithm_{i}"), (i as f64).mul_add(-0.1, 0.8)));
661        }
662        Ok(recommendations)
663    }
664}
665
666impl RankingSystem {
667    fn new() -> DeviceResult<Self> {
668        Ok(Self {
669            ranking_algorithms: vec![],
670            feature_extractors: vec![],
671            learning_to_rank_model: None,
672            ranking_cache: HashMap::new(),
673        })
674    }
675
676    fn rank_algorithms(
677        &self,
678        algorithms: &[AlgorithmInfo],
679        _criteria: &DiscoveryCriteria,
680    ) -> DeviceResult<Vec<RankedResult>> {
681        let mut results = Vec::new();
682        for (i, algorithm) in algorithms.iter().enumerate() {
683            results.push(RankedResult {
684                algorithm_id: algorithm.algorithm_id.clone(),
685                rank: i,
686                score: (i as f64).mul_add(-0.1, 1.0),
687                feature_scores: HashMap::new(),
688                explanation: RankingExplanation {
689                    primary_factors: vec!["relevance".to_string()],
690                    relevance_score: 0.9,
691                    popularity_score: 0.8,
692                    quality_score: 0.85,
693                    personalization_boost: 0.1,
694                    detailed_explanation: "High relevance to query".to_string(),
695                },
696            });
697        }
698        Ok(results)
699    }
700}
701
702impl PersonalizationEngine {
703    fn new() -> DeviceResult<Self> {
704        Ok(Self {
705            personalization_models: HashMap::new(),
706            context_analyzers: vec![],
707            adaptation_strategies: vec![],
708            privacy_preserving: true,
709        })
710    }
711
712    fn personalize_results(
713        &self,
714        results: &[AlgorithmInfo],
715        _user_context: &UserContext,
716    ) -> DeviceResult<Vec<f64>> {
717        // Simplified personalization
718        Ok(results
719            .iter()
720            .enumerate()
721            .map(|(i, _)| (i as f64).mul_add(-0.1, 0.9))
722            .collect())
723    }
724}
725
726impl DiscoveryCache {
727    fn new() -> Self {
728        Self {
729            query_cache: HashMap::new(),
730            recommendation_cache: HashMap::new(),
731            similarity_cache: HashMap::new(),
732            cache_stats: CacheStatistics::default(),
733        }
734    }
735}
quantrs2_device/algorithm_marketplace/discovery.rs

quantrs2_device/algorithm_marketplace/
discovery.rs
