// Process intelligence algorithm registry — generated from wasm4pm pi ontology.
// Regenerate with: ggen sync
// Source: ggen/ontology/algorithms.ttl (pi:ProcessIntelligenceAlgorithm)
// 60 algorithms in category-then-ID order.
use serde::{Deserialize, Serialize};
use std::fmt;
/// All process intelligence algorithms admitted in wasm4pm.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
pub enum ProcessIntelligenceAlgorithm {
/// Orchestrated multi-step agentic pipeline — chains discovery, conformance, and analytics algorithms in a reasoning loop, selecting next operation based on intermediate results.
AgenticPipeline,
/// Alignment-based conformance checking — synchronously replays each trace on the Petri net, computing optimal alignment cost using A* over the synchronous product automaton.
Alignments,
/// Structural complexity metrics (size, CFC, depth) — computes Control Flow Complexity, model size, connector degree distribution, and depth without replaying the log.
ComplexityMetrics,
/// ETConformance precision — measures how much of the model's behaviour is actually observed in the log using escaping-edges token-based precision.
EtconformancePrecision,
/// Van der Aalst generalization score — measures how well the model generalises beyond the observed log by penalising infrequently visited transitions.
Generalization,
/// A* shortest-path discovery over DFG — finds optimal path through the directly-follows graph using heuristic search, producing a Petri net model.
AStar,
/// Ant Colony Optimisation discovery — stochastic population-based search inspired by ant foraging, producing Petri net models with good fitness/precision balance.
Aco,
/// Alpha++ miner — extends the original Alpha algorithm to handle length-one and length-two loops, producing a Petri net from the directly-follows footprint matrix.
AlphaPlusPlus,
/// Declarative constraint mining using LTL-based temporal logic — discovers existence, response, and precedence constraints rather than a procedural model.
Declare,
/// Directly-Follows Graph — fastest baseline discovery, counting how often one activity directly follows another. Serves as input to most other discovery algorithms.
Dfg,
/// Genetic algorithm process model search — evolves a population of candidate Petri nets using fitness, precision, generalization and simplicity as multi-objective fitness functions.
GeneticAlgorithm,
/// Heuristics Miner — uses dependency measures to filter noise before constructing a causal net. Dependency threshold controls filtering aggressiveness.
HeuristicMiner,
/// Hierarchical DFG — extends the standard DFG with automatic detection and collapsing of recurring sub-process patterns.
HierarchicalDfg,
/// Hill-climbing local search — iteratively improves a candidate model by applying local operators, terminating at a local optimum.
HillClimbing,
/// ILP Miner — solves an integer linear programming problem to find a Petri net fitting the directly-follows relations; produces high-precision sound models.
Ilp,
/// Inductive Miner — recursively discovers a sound, block-structured process tree from the event log by detecting cut types (sequence, parallel, choice, loop).
InductiveMiner,
/// Prefix-tree (trie) representation — inserts all traces into a trie where each path from root to leaf represents a unique trace variant.
LogToTrie,
/// DFG with arc-weight optimisation pass — builds a standard DFG then applies pruning to remove statistically insignificant arcs.
OptimizedDfg,
/// Minimal skeleton DFG — retains only the highest-frequency directly-follows arcs to produce a sparse backbone of the process.
ProcessSkeleton,
/// Particle Swarm Optimisation discovery — maintains a swarm of candidate models whose positions evolve toward the global best according to social and cognitive acceleration.
Pso,
/// SIMD-accelerated streaming DFG — processes the event log in a single pass using SIMD vector intrinsics for maximum throughput on large logs.
SimdStreamingDfg,
/// Simulated Annealing stochastic search — probabilistically accepts worse candidate models according to a cooling schedule to escape local optima.
SimulatedAnnealing,
/// Auto-selects the best algorithm for the input characteristics — inspects log size, variant count, and noise level, then dispatches to the most appropriate discovery algorithm.
SmartEngine,
/// Streaming event log ingestion — processes events in arrival order without materialising the full log in memory; emits running DFG statistics.
StreamingLog,
/// Transition system from event log — constructs a finite-state automaton where states are abstractions of trace history and arcs are activity labels.
TransitionSystem,
/// Measures speedup potential across trace variants — identifies bottleneck activity pairs and quantifies theoretical throughput gain from parallelisation.
AnalyzeProcessSpeedup,
/// Complexity metrics per trace variant — computes length distribution, unique activity count, loop density, and entropy for each distinct variant in the log.
AnalyzeVariantComplexity,
/// Detects batch-execution patterns — identifies when a resource processes multiple cases simultaneously (sequential, concurrent, simultaneous, or interleaved batches).
Batches,
/// Causal dependency graph — applies causal inference to distinguish spurious correlations in the DFG from genuine causal dependencies between activities.
CausalGraph,
/// Activity-to-activity transition probability matrix — computes the n x n matrix of empirical transition probabilities between all activity pairs.
ComputeActivityTransitionMatrix,
/// Pairwise trace similarity matrix — computes edit-distance or Jaccard similarity for all trace pairs; used as input to clustering and variant analysis.
ComputeTraceSimilarityMatrix,
/// Correlation-based dependency miner — discovers dependencies from statistical correlation of activity occurrences without requiring case identifiers.
CorrelationMiner,
/// Social network: handover-of-work between resources — nodes are resources, arcs represent how frequently one resource hands a case to another.
HandoverNetwork,
/// Performance spectrum — segments all arc traversals in the DFG by time, producing a time-sliced frequency matrix for flow rate visualisation.
PerformanceSpectrum,
/// Social network: co-worker collaboration — arcs represent how frequently two resources work on the same case, regardless of handover direction.
WorkingTogetherNetwork,
/// Import BPMN 2.0 XML to process tree — parses a BPMN 2.0 XML document and converts flow elements to a block-structured process tree.
BpmnImport,
/// Import PNML to Petri net — parses a PNML XML document and reconstructs the place-transition structure for use as a conformance reference model.
PnmlImport,
/// Convert POWL model to process tree — translates a Partially Ordered Workflow Language model to a block-structured process tree.
PowlToProcessTree,
/// Export process model to YAWL format — serialises a discovered process model as a YAWL specification for import into YAWL-compatible workflow engines.
YawlExport,
/// AutoML classification — automatically selects and tunes a classifier (decision tree, random forest, gradient boosting) from process feature vectors.
AutomlClassify,
/// AutoML time-series forecasting — automatically selects and tunes a forecasting model for process throughput or case duration prediction.
AutomlForecast,
/// Anomaly detection — applies isolation forest or one-class SVM to process feature vectors to flag statistically anomalous traces or events.
MlAnomaly,
/// Supervised classification — trains a classifier on labeled process feature vectors and predicts labels for unseen cases.
MlClassify,
/// Unsupervised clustering — applies k-means or DBSCAN to process feature vectors to discover natural groupings of cases or traces.
MlCluster,
/// Time-series forecasting — trains a forecasting model on historical process metrics and produces forward projections.
MlForecast,
/// Principal Component Analysis — reduces dimensionality of process feature vectors, revealing principal axes of variation.
MlPca,
/// Regression — fits a regression model to predict a continuous target (e.g., case duration) from process feature vectors.
MlRegress,
/// Object-centric DFG across all object types — flattens the OCEL log into a unified DFG weighted by event frequency regardless of type.
OcelDfg,
/// Separate DFG per object type — produces one DFG for each object type in the OCEL log, enabling per-type flow analysis without cross-type interference.
OcelDfgPerType,
/// Encodes OCEL log to feature matrix — transforms the object-centric log into a numeric feature matrix suitable for downstream ML algorithms.
OcelEncode,
/// Object-centric Declare constraint discovery — mines LTL-based temporal constraints from the OCEL log, relating events across different object types.
OcelOcDeclare,
/// Object-centric log abstraction analytics — computes summary statistics: object interaction counts, event density, and type co-occurrence matrices.
OcelOcla,
/// Per-type flattened Petri nets — applies the Inductive Miner to each object-type-flattened sub-log to produce a sound Petri net per type.
OcelPetriNet,
/// Exponentially weighted moving average on case metrics — applies EWMA smoothing to process KPI time-series for trend-aware monitoring.
ComputeEwma,
/// Concept drift detection — applies statistical change-point tests (ADWIN, Page-Hinkley) to a sliding window to detect when the underlying process has changed.
DetectDrift,
/// Next-activity prediction from trace prefix — encodes the trace prefix as a feature vector and predicts the most likely next activity.
PredictNextActivity,
/// Case outcome prediction — predicts the final outcome of a running case from its prefix using a trained binary or multi-class classifier.
PredictOutcome,
/// Remaining time prediction from trace prefix — estimates time until case completion using a regression model trained on completed cases.
PredictRemainingTime,
/// Monte Carlo simulation from discovered model — samples synthetic traces from empirical transition probability distribution to estimate throughput time distributions.
MonteCarloSimulation,
/// Stochastic playout from Petri net — generates synthetic event logs by firing enabled transitions according to stochastic weights until all tokens reach the final marking.
Playout,
}
impl ProcessIntelligenceAlgorithm {
/// Canonical snake_case algorithm ID matching TypeScript AlgorithmId.
pub fn id(&self) -> &'static str {
match self {
Self::AgenticPipeline => "agentic_pipeline",
Self::Alignments => "alignments",
Self::ComplexityMetrics => "complexity_metrics",
Self::EtconformancePrecision => "etconformance_precision",
Self::Generalization => "generalization",
Self::AStar => "a_star",
Self::Aco => "aco",
Self::AlphaPlusPlus => "alpha_plus_plus",
Self::Declare => "declare",
Self::Dfg => "dfg",
Self::GeneticAlgorithm => "genetic_algorithm",
Self::HeuristicMiner => "heuristic_miner",
Self::HierarchicalDfg => "hierarchical_dfg",
Self::HillClimbing => "hill_climbing",
Self::Ilp => "ilp",
Self::InductiveMiner => "inductive_miner",
Self::LogToTrie => "log_to_trie",
Self::OptimizedDfg => "optimized_dfg",
Self::ProcessSkeleton => "process_skeleton",
Self::Pso => "pso",
Self::SimdStreamingDfg => "simd_streaming_dfg",
Self::SimulatedAnnealing => "simulated_annealing",
Self::SmartEngine => "smart_engine",
Self::StreamingLog => "streaming_log",
Self::TransitionSystem => "transition_system",
Self::AnalyzeProcessSpeedup => "analyze_process_speedup",
Self::AnalyzeVariantComplexity => "analyze_variant_complexity",
Self::Batches => "batches",
Self::CausalGraph => "causal_graph",
Self::ComputeActivityTransitionMatrix => "compute_activity_transition_matrix",
Self::ComputeTraceSimilarityMatrix => "compute_trace_similarity_matrix",
Self::CorrelationMiner => "correlation_miner",
Self::HandoverNetwork => "handover_network",
Self::PerformanceSpectrum => "performance_spectrum",
Self::WorkingTogetherNetwork => "working_together_network",
Self::BpmnImport => "bpmn_import",
Self::PnmlImport => "pnml_import",
Self::PowlToProcessTree => "powl_to_process_tree",
Self::YawlExport => "yawl_export",
Self::AutomlClassify => "automl_classify",
Self::AutomlForecast => "automl_forecast",
Self::MlAnomaly => "ml_anomaly",
Self::MlClassify => "ml_classify",
Self::MlCluster => "ml_cluster",
Self::MlForecast => "ml_forecast",
Self::MlPca => "ml_pca",
Self::MlRegress => "ml_regress",
Self::OcelDfg => "ocel_dfg",
Self::OcelDfgPerType => "ocel_dfg_per_type",
Self::OcelEncode => "ocel_encode",
Self::OcelOcDeclare => "ocel_oc_declare",
Self::OcelOcla => "ocel_ocla",
Self::OcelPetriNet => "ocel_petri_net",
Self::ComputeEwma => "compute_ewma",
Self::DetectDrift => "detect_drift",
Self::PredictNextActivity => "predict_next_activity",
Self::PredictOutcome => "predict_outcome",
Self::PredictRemainingTime => "predict_remaining_time",
Self::MonteCarloSimulation => "monte_carlo_simulation",
Self::Playout => "playout",
}
}
/// WASM export function name.
pub fn wasm_export(&self) -> &'static str {
match self {
Self::AgenticPipeline => "run_agentic_pipeline",
Self::Alignments => "compute_alignments",
Self::ComplexityMetrics => "compute_complexity_metrics",
Self::EtconformancePrecision => "compute_align_etconformance_precision",
Self::Generalization => "generalization",
Self::AStar => "discover_a_star",
Self::Aco => "discover_aco",
Self::AlphaPlusPlus => "discover_alpha_plus_plus",
Self::Declare => "discover_declare",
Self::Dfg => "discover_dfg",
Self::GeneticAlgorithm => "discover_genetic_algorithm",
Self::HeuristicMiner => "discover_heuristic_miner",
Self::HierarchicalDfg => "discover_hierarchical_dfg",
Self::HillClimbing => "discover_hill_climbing",
Self::Ilp => "discover_ilp_petri_net",
Self::InductiveMiner => "discover_inductive_miner",
Self::LogToTrie => "discover_log_to_trie",
Self::OptimizedDfg => "discover_dfg",
Self::ProcessSkeleton => "discover_process_skeleton",
Self::Pso => "discover_pso",
Self::SimdStreamingDfg => "discover_dfg_simd",
Self::SimulatedAnnealing => "discover_simulated_annealing",
Self::SmartEngine => "discover_smart_engine",
Self::StreamingLog => "discover_dfg",
Self::TransitionSystem => "discover_transition_system",
Self::AnalyzeProcessSpeedup => "analyze_process_speedup",
Self::AnalyzeVariantComplexity => "analyze_variant_complexity",
Self::Batches => "analyze_batches",
Self::CausalGraph => "compute_causal_graph",
Self::ComputeActivityTransitionMatrix => "compute_activity_transition_matrix",
Self::ComputeTraceSimilarityMatrix => "compute_trace_similarity_matrix",
Self::CorrelationMiner => "compute_correlation_miner",
Self::HandoverNetwork => "compute_handover_network",
Self::PerformanceSpectrum => "compute_performance_spectrum",
Self::WorkingTogetherNetwork => "compute_working_together_network",
Self::BpmnImport => "read_bpmn",
Self::PnmlImport => "from_pnml_wasm",
Self::PowlToProcessTree => "convert_powl_to_process_tree",
Self::YawlExport => "export_yawl",
Self::AutomlClassify => "automl_classify",
Self::AutomlForecast => "automl_forecast",
Self::MlAnomaly => "ml_anomaly",
Self::MlClassify => "ml_classify",
Self::MlCluster => "ml_cluster",
Self::MlForecast => "ml_forecast",
Self::MlPca => "ml_pca",
Self::MlRegress => "ml_regress",
Self::OcelDfg => "discover_ocel_dfg",
Self::OcelDfgPerType => "discover_ocel_dfg_per_type",
Self::OcelEncode => "encode_ocel",
Self::OcelOcDeclare => "discover_ocel_oc_declare",
Self::OcelOcla => "discover_ocel_ocla",
Self::OcelPetriNet => "discover_ocel_petri_net",
Self::ComputeEwma => "compute_ewma",
Self::DetectDrift => "detect_drift",
Self::PredictNextActivity => "predict_next_activity",
Self::PredictOutcome => "predict_outcome",
Self::PredictRemainingTime => "predict_case_duration",
Self::MonteCarloSimulation => "monte_carlo_simulation",
Self::Playout => "petri_net_playout",
}
}
/// Functional category.
pub fn category(&self) -> &'static str {
match self {
Self::AgenticPipeline => "agentic",
Self::Alignments => "conformance",
Self::ComplexityMetrics => "conformance",
Self::EtconformancePrecision => "conformance",
Self::Generalization => "conformance",
Self::AStar => "discovery",
Self::Aco => "discovery",
Self::AlphaPlusPlus => "discovery",
Self::Declare => "discovery",
Self::Dfg => "discovery",
Self::GeneticAlgorithm => "discovery",
Self::HeuristicMiner => "discovery",
Self::HierarchicalDfg => "discovery",
Self::HillClimbing => "discovery",
Self::Ilp => "discovery",
Self::InductiveMiner => "discovery",
Self::LogToTrie => "discovery",
Self::OptimizedDfg => "discovery",
Self::ProcessSkeleton => "discovery",
Self::Pso => "discovery",
Self::SimdStreamingDfg => "discovery",
Self::SimulatedAnnealing => "discovery",
Self::SmartEngine => "discovery",
Self::StreamingLog => "discovery",
Self::TransitionSystem => "discovery",
Self::AnalyzeProcessSpeedup => "discovery_analytics",
Self::AnalyzeVariantComplexity => "discovery_analytics",
Self::Batches => "discovery_analytics",
Self::CausalGraph => "discovery_analytics",
Self::ComputeActivityTransitionMatrix => "discovery_analytics",
Self::ComputeTraceSimilarityMatrix => "discovery_analytics",
Self::CorrelationMiner => "discovery_analytics",
Self::HandoverNetwork => "discovery_analytics",
Self::PerformanceSpectrum => "discovery_analytics",
Self::WorkingTogetherNetwork => "discovery_analytics",
Self::BpmnImport => "import_export",
Self::PnmlImport => "import_export",
Self::PowlToProcessTree => "import_export",
Self::YawlExport => "import_export",
Self::AutomlClassify => "ml_analytics",
Self::AutomlForecast => "ml_analytics",
Self::MlAnomaly => "ml_analytics",
Self::MlClassify => "ml_analytics",
Self::MlCluster => "ml_analytics",
Self::MlForecast => "ml_analytics",
Self::MlPca => "ml_analytics",
Self::MlRegress => "ml_analytics",
Self::OcelDfg => "object_centric",
Self::OcelDfgPerType => "object_centric",
Self::OcelEncode => "object_centric",
Self::OcelOcDeclare => "object_centric",
Self::OcelOcla => "object_centric",
Self::OcelPetriNet => "object_centric",
Self::ComputeEwma => "prediction",
Self::DetectDrift => "prediction",
Self::PredictNextActivity => "prediction",
Self::PredictOutcome => "prediction",
Self::PredictRemainingTime => "prediction",
Self::MonteCarloSimulation => "simulation",
Self::Playout => "simulation",
}
}
/// Resolve snake_case ID or CLI alias to a variant. Returns None for unknown input.
pub fn from_id(input: &str) -> Option<Self> {
Self::ALL.iter().copied().find(|a| a.id() == input)
}
/// All admitted algorithms in category-then-ID order.
pub const ALL: [ProcessIntelligenceAlgorithm; 60] = [
Self::AgenticPipeline,
Self::Alignments,
Self::ComplexityMetrics,
Self::EtconformancePrecision,
Self::Generalization,
Self::AStar,
Self::Aco,
Self::AlphaPlusPlus,
Self::Declare,
Self::Dfg,
Self::GeneticAlgorithm,
Self::HeuristicMiner,
Self::HierarchicalDfg,
Self::HillClimbing,
Self::Ilp,
Self::InductiveMiner,
Self::LogToTrie,
Self::OptimizedDfg,
Self::ProcessSkeleton,
Self::Pso,
Self::SimdStreamingDfg,
Self::SimulatedAnnealing,
Self::SmartEngine,
Self::StreamingLog,
Self::TransitionSystem,
Self::AnalyzeProcessSpeedup,
Self::AnalyzeVariantComplexity,
Self::Batches,
Self::CausalGraph,
Self::ComputeActivityTransitionMatrix,
Self::ComputeTraceSimilarityMatrix,
Self::CorrelationMiner,
Self::HandoverNetwork,
Self::PerformanceSpectrum,
Self::WorkingTogetherNetwork,
Self::BpmnImport,
Self::PnmlImport,
Self::PowlToProcessTree,
Self::YawlExport,
Self::AutomlClassify,
Self::AutomlForecast,
Self::MlAnomaly,
Self::MlClassify,
Self::MlCluster,
Self::MlForecast,
Self::MlPca,
Self::MlRegress,
Self::OcelDfg,
Self::OcelDfgPerType,
Self::OcelEncode,
Self::OcelOcDeclare,
Self::OcelOcla,
Self::OcelPetriNet,
Self::ComputeEwma,
Self::DetectDrift,
Self::PredictNextActivity,
Self::PredictOutcome,
Self::PredictRemainingTime,
Self::MonteCarloSimulation,
Self::Playout,
];
}
impl fmt::Display for ProcessIntelligenceAlgorithm {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.id())
}
}