Struct ReductionGraph 

pub struct ReductionGraph { /* private fields */ }

Runtime graph of all registered reductions.

Uses variant-level nodes: each node is a unique (problem_name, variant) pair. All edges come from inventory::iter::<ReductionEntry> registrations.

The graph supports:

• Auto-discovery of reductions from inventory::iter::<ReductionEntry>
• Path finding by problem type or by name

Implementations

impl ReductionGraph

pub fn new() -> Self

Create a new reduction graph with all registered reductions from inventory.

pub fn variant_to_map(variant: &[(&str, &str)]) -> BTreeMap<String, String>

Convert a variant slice to a BTreeMap. Normalizes empty “graph” values to “SimpleGraph” for consistency.

pub fn find_all_paths( &self, source: &str, source_variant: &BTreeMap<String, String>, target: &str, target_variant: &BTreeMap<String, String>, ) -> Vec<ReductionPath>

Find all simple paths between two specific problem variants.

Uses all_simple_paths on the variant-level graph from the exact source variant node to the exact target variant node.

pub fn find_all_paths_mode( &self, source: &str, source_variant: &BTreeMap<String, String>, target: &str, target_variant: &BTreeMap<String, String>, mode: ReductionMode, ) -> Vec<ReductionPath>

Find all simple paths between two specific problem variants while requiring a specific edge capability.

pub fn find_paths_up_to( &self, source: &str, source_variant: &BTreeMap<String, String>, target: &str, target_variant: &BTreeMap<String, String>, limit: usize, ) -> Vec<ReductionPath>

Find up to limit simple paths between two specific problem variants.

Returns witness-capable paths in deterministic order: fewest edges first, then canonical problem name and variant order. Enumeration stops after collecting limit paths.

pub fn find_paths_up_to_mode( &self, source: &str, source_variant: &BTreeMap<String, String>, target: &str, target_variant: &BTreeMap<String, String>, mode: ReductionMode, limit: usize, ) -> Vec<ReductionPath>

Returns paths whose edges support mode, ordered by fewest edges first and canonical problem name and variant order, stopping after limit paths.

pub fn find_paths_up_to_mode_bounded( &self, source: &str, source_variant: &BTreeMap<String, String>, target: &str, target_variant: &BTreeMap<String, String>, mode: ReductionMode, limit: usize, max_intermediate_nodes: Option<usize>, ) -> Vec<ReductionPath>

Like find_paths_up_to_mode, with at most max_intermediate_nodes nodes strictly between the source and target.

pub fn has_direct_reduction<S: Problem, T: Problem>(&self) -> bool

Check if a direct reduction exists from S to T.

pub fn has_direct_reduction_by_name(&self, src: &str, dst: &str) -> bool

Check if a direct reduction exists by name.

pub fn has_direct_reduction_by_name_mode( &self, src: &str, dst: &str, mode: ReductionMode, ) -> bool

Check if a direct reduction exists by name in a specific mode.

pub fn has_direct_reduction_mode<S: Problem, T: Problem>( &self, mode: ReductionMode, ) -> bool

Check if a direct reduction exists from S to T in a specific mode.

pub fn problem_types(&self) -> Vec<&'static str>

Get all registered problem type names (base names).

pub fn num_types(&self) -> usize

Get the number of registered problem types (unique base names).

pub fn num_reductions(&self) -> usize

Get the number of registered reductions (edges).

pub fn num_variant_nodes(&self) -> usize

Get the number of variant-level nodes.

pub fn path_parameter_transforms( &self, path: &ReductionPath, ) -> Result<Vec<ParameterTransform>, PathParameterError>

Return the symbolic parameter transform for every edge of a path.

pub fn compose_path_parameter_transform( &self, path: &ReductionPath, ) -> Result<Option<ParameterTransform>, PathParameterError>

Compose symbolic parameter transforms along a path.

pub fn variants_for(&self, name: &str) -> Vec<BTreeMap<String, String>>

Get all variant maps registered for a problem name.

Returns the declared default first, followed by the remaining variants in lexicographic order.

pub fn default_variant_for( &self, name: &str, ) -> Option<BTreeMap<String, String>>

Get the declared default variant for a problem type.

Returns the variant that was marked default in declare_variants!. If no entry was explicitly marked default, the first registered variant for the problem is used as the implicit default. Returns None if the problem type is not registered.

pub fn variant_complexity( &self, name: &str, variant: &BTreeMap<String, String>, ) -> Option<&'static str>

Get the complexity expression for a specific variant.

pub fn outgoing_reductions(&self, name: &str) -> Vec<ReductionEdgeInfo>

Get all outgoing reductions from a problem (across all its variants).

pub fn outgoing_reductions_from( &self, name: &str, variant: &BTreeMap<String, String>, mode: ReductionMode, ) -> Vec<ReductionEdgeInfo>

Get executable outgoing reductions from one exact problem variant.

Panics

Panics if name and variant do not identify an exactly registered problem variant.

pub fn parameter_names(&self, name: &str) -> Vec<String>

Get a problem type’s canonical parameter names in declaration order.

pub fn compute_problem_parameters( name: &str, variant: &BTreeMap<String, String>, instance: &dyn Any, ) -> ProblemParameters

Measure the complete problem-owned parameters at this exact variant.

pub fn incoming_reductions(&self, name: &str) -> Vec<ReductionEdgeInfo>

Get all incoming reductions to a problem (across all its variants).

pub fn k_neighbors( &self, name: &str, variant: &BTreeMap<String, String>, max_hops: usize, direction: TraversalFlow, ) -> Vec<NeighborInfo>

Find all problems reachable within max_hops edges from a starting node.

Returns neighbors sorted by (hops, name). The starting node itself is excluded. If a node is reachable at multiple distances, it appears at the shortest distance only.

pub fn k_neighbor_tree( &self, name: &str, variant: &BTreeMap<String, String>, max_hops: usize, direction: TraversalFlow, ) -> Vec<NeighborTree>

Build a tree of neighbors via BFS with parent tracking.

Returns the children of the starting node as a forest of NeighborTree nodes. Each node appears at most once (shortest-path tree). Children are sorted by name.

impl ReductionGraph

pub fn to_json_string(&self) -> Result<String, Error>

Export the reduction graph as a JSON string.

pub fn to_json_value(&self) -> Result<Value, Error>

Export the reduction graph as a JSON value.

pub fn to_json_file(&self, path: &Path) -> Result<()>

Export the reduction graph to a JSON file.

pub fn find_entry( &self, source_name: &str, source_variant: &BTreeMap<String, String>, target_name: &str, target_variant: &BTreeMap<String, String>, ) -> Option<MatchedEntry>

Find the graph edge for exact source and target variants.

No fallback is attempted — callers that need fuzzy matching should resolve variants before calling this method.

impl ReductionGraph

pub fn reduce_along_path( &self, path: &ReductionPath, source: &dyn Any, ) -> Result<Option<ReductionChain>, ReductionError>

Execute a reduction path on a source problem instance.

Looks up each edge’s reduce_fn, chains them, and returns the resulting ReductionChain. The source must be passed as &dyn Any (use &problem as &dyn Any or pass a concrete reference directly).

Example

let Some(chain) = graph.reduce_along_path(&path, &source_problem)? else {
    return Err("path is not witness-executable".into());
};
let target: &QUBO<f64> = chain.target_problem();
let source_solution = chain.extract_solution(&target_solution);

pub fn reduce_aggregate_along_path( &self, path: &ReductionPath, source: &dyn Any, ) -> Result<Option<AggregateReductionChain>, ReductionError>

Execute an aggregate-value reduction path on a source problem instance.

impl ReductionGraph

pub fn execute_paths( &self, paths: &[ReductionPath], source_instance: &dyn Any, ) -> Result<Vec<ExecutedPath>, ExecutePathsError>

Execute a selected batch of witness paths while sharing every common prefix.

Trait Implementations

impl Default for ReductionGraph

fn default() -> Self

Returns the “default value” for a type.