Trait Problem 

pub trait Problem: Clone {
    type Solution;
    type Value: Clone;

    const NAME: &'static str;

    // Required methods
    fn parameter_names() -> &'static [&'static str];
    fn parameters(&self) -> ProblemParameters;
    fn evaluate(
        &self,
        solution: &Self::Solution,
    ) -> Result<Self::Value, EvaluationError>;
    fn variant() -> Vec<(&'static str, &'static str)>;

    // Provided method
    fn problem_type() -> ProblemType { ... }
}

Minimal problem trait — a problem maps a solution to a value or an evaluation error.

This trait defines the interface for computational problems that can be evaluated or reduced to other problems.

Required Associated Constants

const NAME: &'static str

Base name of this problem type (e.g., “MaximumIndependentSet”).

Required Associated Types

type Solution

Mathematical witness type for this problem.

type Value: Clone

The evaluation value type.

Required Methods

fn parameter_names() -> &'static [&'static str]

Canonical parameter names for this problem model.

fn parameters(&self) -> ProblemParameters

Measure the complete canonical parameters of this concrete instance.

fn evaluate( &self, solution: &Self::Solution, ) -> Result<Self::Value, EvaluationError>

Evaluate the problem on a solution.

fn variant() -> Vec<(&'static str, &'static str)>

Returns variant attributes derived from type parameters.

Used for generating variant IDs in the reduction graph schema. Returns pairs like [("graph", "SimpleGraph"), ("weight", "i64")].

Provided Methods

fn problem_type() -> ProblemType

Look up this problem’s catalog entry.

Returns the full crate::registry::ProblemType metadata from the catalog registry. The default implementation uses Self::NAME to perform the lookup.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl Problem for AdditionalKey

const NAME: &'static str = "AdditionalKey"

type Solution = Vec<bool>

type Value = Or

impl Problem for AlgebraicEquationsOverGF2

const NAME: &'static str = "AlgebraicEquationsOverGF2"

type Solution = Vec<bool>

type Value = Or

impl Problem for BMF

const NAME: &'static str = "BMF"

type Solution = (Vec<Vec<bool>>, Vec<Vec<bool>>)

type Value = Min<i64>

impl Problem for BalancedCompleteBipartiteSubgraph

const NAME: &'static str = "BalancedCompleteBipartiteSubgraph"

type Solution = Vec<bool>

type Value = Or

impl Problem for Betweenness

const NAME: &'static str = "Betweenness"

type Solution = Vec<usize>

type Value = Or

impl Problem for BicliqueCover

const NAME: &'static str = "BicliqueCover"

type Solution = Vec<Vec<bool>>

type Value = Min<i64>

impl Problem for BottleneckTravelingSalesman

const NAME: &'static str = "BottleneckTravelingSalesman"

type Solution = Vec<bool>

type Value = Min<i64>

impl Problem for BoyceCoddNormalFormViolation

const NAME: &'static str = "BoyceCoddNormalFormViolation"

type Solution = Vec<bool>

type Value = Or

impl Problem for CapacityAssignment

const NAME: &'static str = "CapacityAssignment"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for CircuitSAT

const NAME: &'static str = "CircuitSAT"

type Solution = Vec<bool>

type Value = Or

impl Problem for ClosestString

const NAME: &'static str = "ClosestString"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for ClosestSubstring

const NAME: &'static str = "ClosestSubstring"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for Clustering

const NAME: &'static str = "Clustering"

type Solution = Vec<usize>

type Value = Or

impl Problem for ConjunctiveBooleanQuery

const NAME: &'static str = "ConjunctiveBooleanQuery"

type Solution = Vec<usize>

type Value = Or

impl Problem for ConjunctiveQueryFoldability

const NAME: &'static str = "ConjunctiveQueryFoldability"

type Solution = Vec<usize>

type Value = Or

impl Problem for ConsecutiveBlockMinimization

const NAME: &'static str = "ConsecutiveBlockMinimization"

type Solution = Vec<usize>

type Value = Or

impl Problem for ConsecutiveOnesMatrixAugmentation

const NAME: &'static str = "ConsecutiveOnesMatrixAugmentation"

type Solution = Vec<usize>

type Value = Or

impl Problem for ConsecutiveOnesSubmatrix

const NAME: &'static str = "ConsecutiveOnesSubmatrix"

type Solution = Vec<bool>

type Value = Or

impl Problem for ConsecutiveSets

const NAME: &'static str = "ConsecutiveSets"

type Solution = Vec<Option<usize>>

type Value = Or

impl Problem for ConsistencyOfDatabaseFrequencyTables

const NAME: &'static str = "ConsistencyOfDatabaseFrequencyTables"

type Solution = Vec<usize>

type Value = Or

impl Problem for CosineProductIntegration

const NAME: &'static str = "CosineProductIntegration"

type Solution = Vec<bool>

type Value = Or

impl Problem for CyclicOrdering

const NAME: &'static str = "CyclicOrdering"

type Solution = Vec<usize>

type Value = Or

impl Problem for DirectedHamiltonianPath

const NAME: &'static str = "DirectedHamiltonianPath"

type Solution = Vec<usize>

type Value = Or

impl Problem for DirectedTwoCommodityIntegralFlow

const NAME: &'static str = "DirectedTwoCommodityIntegralFlow"

type Solution = Vec<usize>

type Value = Or

impl Problem for DynamicStorageAllocation

const NAME: &'static str = "DynamicStorageAllocation"

type Solution = Vec<usize>

type Value = Or

impl Problem for EnsembleComputation

const NAME: &'static str = "EnsembleComputation"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for EquilibriumPoint

const NAME: &'static str = "EquilibriumPoint"

type Solution = Vec<i64>

type Value = Or

impl Problem for EulerianPath

const NAME: &'static str = "EulerianPath"

type Solution = Vec<usize>

type Value = Or

impl Problem for ExactCoverBy3Sets

const NAME: &'static str = "ExactCoverBy3Sets"

type Solution = Vec<bool>

type Value = Or

impl Problem for ExpectedRetrievalCost

const NAME: &'static str = "ExpectedRetrievalCost"

type Solution = Vec<usize>

type Value = Min<f64>

impl Problem for Factoring

const NAME: &'static str = "Factoring"

type Solution = (BigUint, BigUint)

type Value = Or

impl Problem for FeasibleBasisExtension

const NAME: &'static str = "FeasibleBasisExtension"

type Solution = Vec<bool>

type Value = Or

impl Problem for FeasibleRegisterAssignment

const NAME: &'static str = "FeasibleRegisterAssignment"

type Solution = Vec<usize>

type Value = Or

impl Problem for FlowShopScheduling

const NAME: &'static str = "FlowShopScheduling"

type Solution = Vec<usize>

type Value = Or

impl Problem for GroupingBySwapping

const NAME: &'static str = "GroupingBySwapping"

type Solution = Vec<usize>

type Value = Or

impl Problem for IntegerExpressionMembership

const NAME: &'static str = "IntegerExpressionMembership"

type Solution = Vec<bool>

type Value = Or

impl Problem for IntegerKnapsack

const NAME: &'static str = "IntegerKnapsack"

type Solution = Vec<usize>

type Value = Max<i64>

impl Problem for IntegralFlowBundles

const NAME: &'static str = "IntegralFlowBundles"

type Solution = Vec<usize>

type Value = Or

impl Problem for IntegralFlowHomologousArcs

const NAME: &'static str = "IntegralFlowHomologousArcs"

type Solution = Vec<usize>

type Value = Or

impl Problem for IntegralFlowWithMultipliers

const NAME: &'static str = "IntegralFlowWithMultipliers"

type Solution = Vec<usize>

type Value = Or

impl Problem for JobShopScheduling

const NAME: &'static str = "JobShopScheduling"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for Kernel

const NAME: &'static str = "Kernel"

type Solution = Vec<bool>

type Value = Or

impl Problem for Knapsack

const NAME: &'static str = "Knapsack"

type Solution = Vec<bool>

type Value = Max<i64>

impl Problem for KthLargestMTuple

const NAME: &'static str = "KthLargestMTuple"

type Solution = ()

type Value = Or

impl Problem for LongestCommonSubsequence

const NAME: &'static str = "LongestCommonSubsequence"

type Solution = Vec<Option<usize>>

type Value = Max<i64>

impl Problem for Maximum2Satisfiability

const NAME: &'static str = "Maximum2Satisfiability"

type Solution = Vec<bool>

type Value = Max<i64>

impl Problem for MaximumCommonEdgeSubgraph

const NAME: &'static str = "MaximumCommonEdgeSubgraph"

type Solution = Vec<usize>

type Value = Max<i64>

impl Problem for MaximumContactMapOverlap

const NAME: &'static str = "MaximumContactMapOverlap"

type Solution = Vec<usize>

type Value = Max<i64>

impl Problem for MaximumLikelihoodRanking

const NAME: &'static str = "MaximumLikelihoodRanking"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for MinimumAxiomSet

const NAME: &'static str = "MinimumAxiomSet"

type Solution = Vec<bool>

type Value = Min<i64>

impl Problem for MinimumCardinalityKey

const NAME: &'static str = "MinimumCardinalityKey"

type Solution = Vec<bool>

type Value = Min<i64>

impl Problem for MinimumCodeGenerationOneRegister

const NAME: &'static str = "MinimumCodeGenerationOneRegister"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for MinimumCodeGenerationParallelAssignments

const NAME: &'static str = "MinimumCodeGenerationParallelAssignments"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for MinimumCodeGenerationUnlimitedRegisters

const NAME: &'static str = "MinimumCodeGenerationUnlimitedRegisters"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for MinimumCostCirculation

const NAME: &'static str = "MinimumCostCirculation"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for MinimumCostMaximumFlow

const NAME: &'static str = "MinimumCostMaximumFlow"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for MinimumDecisionTree

const NAME: &'static str = "MinimumDecisionTree"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for MinimumDiscretePlanarInverseKinematics

const NAME: &'static str = "MinimumDiscretePlanarInverseKinematics"

type Solution = Vec<usize>

type Value = Min<f64>

impl Problem for MinimumDisjunctiveNormalForm

const NAME: &'static str = "MinimumDisjunctiveNormalForm"

type Solution = Vec<bool>

type Value = Min<i64>

impl Problem for MinimumDummyActivitiesPert

const NAME: &'static str = "MinimumDummyActivitiesPert"

type Solution = Vec<bool>

type Value = Min<i64>

impl Problem for MinimumEdgeCostFlow

const NAME: &'static str = "MinimumEdgeCostFlow"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for MinimumExternalMacroDataCompression

const NAME: &'static str = "MinimumExternalMacroDataCompression"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for MinimumFaultDetectionTestSet

const NAME: &'static str = "MinimumFaultDetectionTestSet"

type Solution = Vec<Vec<bool>>

type Value = Min<i64>

impl Problem for MinimumGeometricConnectedDominatingSet

const NAME: &'static str = "MinimumGeometricConnectedDominatingSet"

type Solution = Vec<bool>

type Value = Min<i64>

impl Problem for MinimumHittingSet

const NAME: &'static str = "MinimumHittingSet"

type Solution = Vec<bool>

type Value = Min<i64>

impl Problem for MinimumInternalMacroDataCompression

const NAME: &'static str = "MinimumInternalMacroDataCompression"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for MinimumMatrixCover

const NAME: &'static str = "MinimumMatrixCover"

type Solution = Vec<bool>

type Value = Min<i64>

impl Problem for MinimumMatrixDomination

const NAME: &'static str = "MinimumMatrixDomination"

type Solution = Vec<bool>

type Value = Min<i64>

impl Problem for MinimumRegisterSufficiencyForLoops

const NAME: &'static str = "MinimumRegisterSufficiencyForLoops"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for MinimumTardinessSequencing<One>

const NAME: &'static str = "MinimumTardinessSequencing"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for MinimumTardinessSequencing<i64>

const NAME: &'static str = "MinimumTardinessSequencing"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for MinimumWeightAndOrGraph

const NAME: &'static str = "MinimumWeightAndOrGraph"

type Solution = Vec<bool>

type Value = Min<i64>

impl Problem for MinimumWeightDecoding

const NAME: &'static str = "MinimumWeightDecoding"

type Solution = Vec<bool>

type Value = Min<i64>

impl Problem for MinimumWeightSolutionToLinearEquations

const NAME: &'static str = "MinimumWeightSolutionToLinearEquations"

type Solution = Vec<bool>

type Value = Min<i64>

impl Problem for MultipleCopyFileAllocation

const NAME: &'static str = "MultipleCopyFileAllocation"

type Solution = Vec<bool>

type Value = Min<i64>

impl Problem for MultiprocessorScheduling

const NAME: &'static str = "MultiprocessorScheduling"

type Solution = Vec<usize>

type Value = Or

impl Problem for NAESatisfiability

const NAME: &'static str = "NAESatisfiability"

type Solution = Vec<bool>

type Value = Or

impl Problem for NonLivenessFreePetriNet

const NAME: &'static str = "NonLivenessFreePetriNet"

type Solution = Vec<bool>

type Value = Or

impl Problem for NonTautology

const NAME: &'static str = "NonTautology"

type Solution = Vec<bool>

type Value = Or

impl Problem for Numerical3DimensionalMatching

const NAME: &'static str = "Numerical3DimensionalMatching"

type Solution = Vec<usize>

type Value = Or

impl Problem for NumericalMatchingWithTargetSums

const NAME: &'static str = "NumericalMatchingWithTargetSums"

type Solution = Vec<usize>

type Value = Or

impl Problem for OneInThreeSatisfiability

const NAME: &'static str = "OneInThreeSatisfiability"

type Solution = Vec<bool>

type Value = Or

impl Problem for OpenShopScheduling

const NAME: &'static str = "OpenShopScheduling"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for OptimumCommunicationSpanningTree

const NAME: &'static str = "OptimumCommunicationSpanningTree"

type Solution = Vec<bool>

type Value = Min<i64>

impl Problem for PaintShop

const NAME: &'static str = "PaintShop"

type Solution = Vec<bool>

type Value = Min<i64>

impl Problem for PartiallyOrderedKnapsack

const NAME: &'static str = "PartiallyOrderedKnapsack"

type Solution = Vec<bool>

type Value = Max<i64>

impl Problem for Partition

const NAME: &'static str = "Partition"

type Solution = Vec<bool>

type Value = Or

impl Problem for PathConstrainedNetworkFlow

const NAME: &'static str = "PathConstrainedNetworkFlow"

type Solution = Vec<usize>

type Value = Or

impl Problem for Planar3Satisfiability

const NAME: &'static str = "Planar3Satisfiability"

type Solution = Vec<bool>

type Value = Or

impl Problem for PrecedenceConstrainedScheduling

const NAME: &'static str = "PrecedenceConstrainedScheduling"

type Solution = Vec<usize>

type Value = Or

impl Problem for PreemptiveScheduling

const NAME: &'static str = "PreemptiveScheduling"

type Solution = Vec<Vec<bool>>

type Value = Min<i64>

impl Problem for PrimeAttributeName

const NAME: &'static str = "PrimeAttributeName"

type Solution = Vec<bool>

type Value = Or

impl Problem for ProductionPlanning

const NAME: &'static str = "ProductionPlanning"

type Solution = Vec<usize>

type Value = Or

impl Problem for QuadraticAssignment

const NAME: &'static str = "QuadraticAssignment"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for QuadraticCongruences

const NAME: &'static str = "QuadraticCongruences"

type Solution = BigUint

type Value = Or

impl Problem for QuadraticDiophantineEquations

const NAME: &'static str = "QuadraticDiophantineEquations"

type Solution = BigUint

type Value = Or

impl Problem for QuantifiedBooleanFormulas

const NAME: &'static str = "QuantifiedBooleanFormulas"

type Solution = ()

type Value = Or

impl Problem for RectilinearPictureCompression

const NAME: &'static str = "RectilinearPictureCompression"

type Solution = Vec<bool>

type Value = Or

impl Problem for RegisterSufficiency

const NAME: &'static str = "RegisterSufficiency"

type Solution = Vec<usize>

type Value = Or

impl Problem for ResourceConstrainedScheduling

const NAME: &'static str = "ResourceConstrainedScheduling"

type Solution = Vec<usize>

type Value = Or

impl Problem for RootedTreeStorageAssignment

const NAME: &'static str = "RootedTreeStorageAssignment"

type Solution = Vec<usize>

type Value = Or

impl Problem for Satisfiability

const NAME: &'static str = "Satisfiability"

type Solution = Vec<bool>

type Value = Or

impl Problem for SchedulingToMinimizeWeightedCompletionTime

const NAME: &'static str = "SchedulingToMinimizeWeightedCompletionTime"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for SchedulingWithIndividualDeadlines

const NAME: &'static str = "SchedulingWithIndividualDeadlines"

type Solution = Vec<usize>

type Value = Or

impl Problem for SequencingToMinimizeMaximumCumulativeCost

const NAME: &'static str = "SequencingToMinimizeMaximumCumulativeCost"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for SequencingToMinimizeTardyTaskWeight

const NAME: &'static str = "SequencingToMinimizeTardyTaskWeight"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for SequencingToMinimizeWeightedCompletionTime

const NAME: &'static str = "SequencingToMinimizeWeightedCompletionTime"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for SequencingToMinimizeWeightedTardiness

const NAME: &'static str = "SequencingToMinimizeWeightedTardiness"

type Solution = Vec<usize>

type Value = Or

impl Problem for SequencingWithDeadlinesAndSetUpTimes

const NAME: &'static str = "SequencingWithDeadlinesAndSetUpTimes"

type Solution = Vec<usize>

type Value = Or

impl Problem for SequencingWithReleaseTimesAndDeadlines

const NAME: &'static str = "SequencingWithReleaseTimesAndDeadlines"

type Solution = Vec<usize>

type Value = Or

impl Problem for SequencingWithinIntervals

const NAME: &'static str = "SequencingWithinIntervals"

type Solution = Vec<usize>

type Value = Or

impl Problem for SetBasis

const NAME: &'static str = "SetBasis"

type Solution = Vec<Vec<bool>>

type Value = Or

impl Problem for SetSplitting

const NAME: &'static str = "SetSplitting"

type Solution = Vec<bool>

type Value = Or

impl Problem for ShortestCommonSupersequence

const NAME: &'static str = "ShortestCommonSupersequence"

type Solution = Vec<Option<usize>>

type Value = Min<i64>

impl Problem for ShortestCommonSuperstring

const NAME: &'static str = "ShortestCommonSuperstring"

type Solution = Vec<Option<usize>>

type Value = Min<i64>

impl Problem for SimultaneousIncongruences

const NAME: &'static str = "SimultaneousIncongruences"

type Solution = i64

type Value = Or

impl Problem for SparseMatrixCompression

const NAME: &'static str = "SparseMatrixCompression"

type Solution = Vec<usize>

type Value = Or

impl Problem for SquareTiling

const NAME: &'static str = "SquareTiling"

type Solution = Vec<usize>

type Value = Or

impl Problem for StackerCrane

const NAME: &'static str = "StackerCrane"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for StaffScheduling

const NAME: &'static str = "StaffScheduling"

type Solution = Vec<usize>

type Value = Or

impl Problem for StringToStringCorrection

const NAME: &'static str = "StringToStringCorrection"

type Solution = Vec<usize>

type Value = Or

impl Problem for SubgraphIsomorphism

const NAME: &'static str = "SubgraphIsomorphism"

type Solution = Vec<usize>

type Value = Or

impl Problem for SubsetProduct

const NAME: &'static str = "SubsetProduct"

type Solution = Vec<bool>

type Value = Or

impl Problem for SubsetSum

const NAME: &'static str = "SubsetSum"

type Solution = Vec<bool>

type Value = Or

impl Problem for SumOfSquaresPartition

const NAME: &'static str = "SumOfSquaresPartition"

type Solution = Vec<usize>

type Value = Min<i64>

impl Problem for ThreeDimensionalMatching

const NAME: &'static str = "ThreeDimensionalMatching"

type Solution = Vec<bool>

type Value = Or

impl Problem for ThreePartition

const NAME: &'static str = "ThreePartition"

type Solution = Vec<usize>

type Value = Or

impl Problem for TimetableDesign

const NAME: &'static str = "TimetableDesign"

type Solution = Vec<Vec<Vec<bool>>>

type Value = Or

impl Problem for TwoDimensionalConsecutiveSets

const NAME: &'static str = "TwoDimensionalConsecutiveSets"

type Solution = Vec<usize>

type Value = Or

impl Problem for UndirectedFlowLowerBounds

const NAME: &'static str = "UndirectedFlowLowerBounds"

type Solution = Vec<bool>

type Value = Or

impl Problem for UndirectedTwoCommodityIntegralFlow

const NAME: &'static str = "UndirectedTwoCommodityIntegralFlow"

type Solution = Vec<usize>

type Value = Or

impl<G, N> Problem for ShortestWeightConstrainedPath<G, N>

where G: Graph + VariantParam, N: WeightElement + VariantParam,

const NAME: &'static str = "ShortestWeightConstrainedPath"

type Solution = Vec<bool>

type Value = Min<<N as WeightElement>::Sum>

impl<G, W, K> Problem for MaximumCoKPlex<G, W, K>

where G: Graph + VariantParam, W: WeightElement + VariantParam, K: KValue,

const NAME: &'static str = "MaximumCoKPlex"

type Solution = Vec<bool>

type Value = Max<<W as WeightElement>::Sum>

impl<G, W> Problem for BiconnectivityAugmentation<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "BiconnectivityAugmentation"

type Solution = Vec<bool>

type Value = Or

impl<G, W> Problem for BoundedComponentSpanningForest<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "BoundedComponentSpanningForest"

type Solution = Vec<usize>

type Value = Or

impl<G, W> Problem for BoundedDiameterSpanningTree<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "BoundedDiameterSpanningTree"

type Solution = Vec<bool>

type Value = Or

impl<G, W> Problem for LongestCircuit<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "LongestCircuit"

type Solution = Vec<bool>

type Value = Max<<W as WeightElement>::Sum>

impl<G, W> Problem for LongestPath<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "LongestPath"

type Solution = Vec<bool>

type Value = Max<<W as WeightElement>::Sum>

impl<G, W> Problem for MaxCut<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "MaxCut"

type Solution = Vec<bool>

type Value = Max<<W as WeightElement>::Sum>

impl<G, W> Problem for MaximalIS<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "MaximalIS"

type Solution = Vec<bool>

type Value = Max<<W as WeightElement>::Sum>

impl<G, W> Problem for MaximumClique<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "MaximumClique"

type Solution = Vec<bool>

type Value = Max<<W as WeightElement>::Sum>

impl<G, W> Problem for MaximumIndependentSet<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "MaximumIndependentSet"

type Solution = Vec<bool>

type Value = Max<<W as WeightElement>::Sum>

impl<G, W> Problem for MaximumMatching<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "MaximumMatching"

type Solution = Vec<bool>

type Value = Max<<W as WeightElement>::Sum>

impl<G, W> Problem for MinMaxMulticenter<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "MinMaxMulticenter"

type Solution = Vec<bool>

type Value = Min<<W as WeightElement>::Sum>

impl<G, W> Problem for MinimumCapacitatedSpanningTree<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "MinimumCapacitatedSpanningTree"

type Solution = Vec<bool>

type Value = Min<<W as WeightElement>::Sum>

impl<G, W> Problem for MinimumCutIntoBoundedSets<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "MinimumCutIntoBoundedSets"

type Solution = Vec<bool>

type Value = Min<<W as WeightElement>::Sum>

impl<G, W> Problem for MinimumDominatingSet<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "MinimumDominatingSet"

type Solution = Vec<bool>

type Value = Min<<W as WeightElement>::Sum>

impl<G, W> Problem for MinimumMultiwayCut<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "MinimumMultiwayCut"

type Solution = Vec<bool>

type Value = Min<<W as WeightElement>::Sum>

impl<G, W> Problem for MinimumSumMulticenter<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "MinimumSumMulticenter"

type Solution = Vec<bool>

type Value = Min<<W as WeightElement>::Sum>

impl<G, W> Problem for MinimumVertexCover<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "MinimumVertexCover"

type Solution = Vec<bool>

type Value = Min<<W as WeightElement>::Sum>

impl<G, W> Problem for PrizeCollectingSteinerForest<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "PrizeCollectingSteinerForest"

type Solution = (Vec<bool>, Vec<bool>)

type Value = Min<<W as WeightElement>::Sum>

impl<G, W> Problem for RuralPostman<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "RuralPostman"

type Solution = Vec<usize>

type Value = Min<<W as WeightElement>::Sum>

impl<G, W> Problem for SpinGlass<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam + PartialOrd + Zero + Bounded,

const NAME: &'static str = "SpinGlass"

type Solution = Vec<i8>

type Value = Min<<W as WeightElement>::Sum>

impl<G, W> Problem for SteinerTree<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "SteinerTree"

type Solution = Vec<bool>

type Value = Min<<W as WeightElement>::Sum>

impl<G, W> Problem for SteinerTreeInGraphs<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "SteinerTreeInGraphs"

type Solution = Vec<bool>

type Value = Min<<W as WeightElement>::Sum>

impl<G, W> Problem for TravelingSalesman<G, W>

where G: Graph + VariantParam, W: WeightElement + VariantParam,

const NAME: &'static str = "TravelingSalesman"

type Solution = Vec<bool>

type Value = Min<<W as WeightElement>::Sum>

impl<G> Problem for DegreeConstrainedSpanningTree<G>

where G: Graph + VariantParam,

const NAME: &'static str = "DegreeConstrainedSpanningTree"

type Solution = Vec<bool>

type Value = Or

impl<G> Problem for DisjointConnectingPaths<G>

where G: Graph + VariantParam,

const NAME: &'static str = "DisjointConnectingPaths"

type Solution = Vec<bool>

type Value = Or

impl<G> Problem for GeneralizedHex<G>

where G: Graph + VariantParam,

const NAME: &'static str = "GeneralizedHex"

type Solution = ()

type Value = Or

impl<G> Problem for GraphPartitioning<G>

where G: Graph + VariantParam,

const NAME: &'static str = "GraphPartitioning"

type Solution = Vec<bool>

type Value = Min<i64>

impl<G> Problem for HamiltonianCircuit<G>

where G: Graph + VariantParam,

const NAME: &'static str = "HamiltonianCircuit"

type Solution = Vec<usize>

type Value = Or

impl<G> Problem for HamiltonianPath<G>

where G: Graph + VariantParam,

const NAME: &'static str = "HamiltonianPath"

type Solution = Vec<usize>

type Value = Or

impl<G> Problem for HamiltonianPathBetweenTwoVertices<G>

where G: Graph + VariantParam,

const NAME: &'static str = "HamiltonianPathBetweenTwoVertices"

type Solution = Vec<usize>

type Value = Or

impl<G> Problem for HighlyConnectedDeletion<G>

where G: Graph + VariantParam,

const NAME: &'static str = "HighlyConnectedDeletion"

type Solution = Vec<bool>

type Value = Min<i64>

impl<G> Problem for IsomorphicSpanningTree<G>

where G: Graph + VariantParam,

const NAME: &'static str = "IsomorphicSpanningTree"

type Solution = Vec<usize>

type Value = Or

impl<G> Problem for KClique<G>

where G: Graph + VariantParam,

const NAME: &'static str = "KClique"

type Solution = Vec<bool>

type Value = Or

impl<G> Problem for LengthBoundedDisjointPaths<G>

where G: Graph + VariantParam,

const NAME: &'static str = "LengthBoundedDisjointPaths"

type Solution = Vec<Vec<bool>>

type Value = Max<i64>

impl<G> Problem for MaximumAchromaticNumber<G>

where G: Graph + VariantParam,

const NAME: &'static str = "MaximumAchromaticNumber"

type Solution = Vec<usize>

type Value = Max<i64>

impl<G> Problem for MaximumDomaticNumber<G>

where G: Graph + VariantParam,

const NAME: &'static str = "MaximumDomaticNumber"

type Solution = Vec<usize>

type Value = Max<i64>

impl<G> Problem for MaximumLeafSpanningTree<G>

where G: Graph + VariantParam,

const NAME: &'static str = "MaximumLeafSpanningTree"

type Solution = Vec<bool>

type Value = Max<i64>

impl<G> Problem for MinimumCoveringByCliques<G>

where G: Graph + VariantParam,

const NAME: &'static str = "MinimumCoveringByCliques"

type Solution = Vec<usize>

type Value = Min<i64>

impl<G> Problem for MinimumGraphBandwidth<G>

where G: Graph + VariantParam,

const NAME: &'static str = "MinimumGraphBandwidth"

type Solution = Vec<usize>

type Value = Min<i64>

impl<G> Problem for MinimumIntersectionGraphBasis<G>

where G: Graph + VariantParam,

const NAME: &'static str = "MinimumIntersectionGraphBasis"

type Solution = Vec<Vec<bool>>

type Value = Min<i64>

impl<G> Problem for MinimumMaximalMatching<G>

where G: Graph + VariantParam,

const NAME: &'static str = "MinimumMaximalMatching"

type Solution = Vec<bool>

type Value = Min<i64>

impl<G> Problem for MinimumMetricDimension<G>

where G: Graph + VariantParam,

const NAME: &'static str = "MinimumMetricDimension"

type Solution = Vec<bool>

type Value = Min<i64>

impl<G> Problem for MonochromaticTriangle<G>

where G: Graph + VariantParam,

const NAME: &'static str = "MonochromaticTriangle"

type Solution = Vec<bool>

type Value = Or

impl<G> Problem for OptimalLinearArrangement<G>

where G: Graph + VariantParam,

const NAME: &'static str = "OptimalLinearArrangement"

type Solution = Vec<usize>

type Value = Min<i64>

impl<G> Problem for PartialFeedbackEdgeSet<G>

where G: Graph + VariantParam,

const NAME: &'static str = "PartialFeedbackEdgeSet"

type Solution = Vec<bool>

type Value = Or

impl<G> Problem for PartitionIntoCliques<G>

where G: Graph + VariantParam,

const NAME: &'static str = "PartitionIntoCliques"

type Solution = Vec<usize>

type Value = Or

impl<G> Problem for PartitionIntoForests<G>

where G: Graph + VariantParam,

const NAME: &'static str = "PartitionIntoForests"

type Solution = Vec<usize>

type Value = Or

impl<G> Problem for PartitionIntoPathsOfLength2<G>

where G: Graph + VariantParam,

const NAME: &'static str = "PartitionIntoPathsOfLength2"

type Solution = Vec<usize>

type Value = Or

impl<G> Problem for PartitionIntoPerfectMatchings<G>

where G: Graph + VariantParam,

const NAME: &'static str = "PartitionIntoPerfectMatchings"

type Solution = Vec<usize>

type Value = Or

impl<G> Problem for PartitionIntoTriangles<G>

where G: Graph + VariantParam,

const NAME: &'static str = "PartitionIntoTriangles"

type Solution = Vec<usize>

type Value = Or

impl<G> Problem for RootedTreeArrangement<G>

where G: Graph + VariantParam,

const NAME: &'static str = "RootedTreeArrangement"

type Solution = Vec<usize>

type Value = Or

impl<K: KValue, G> Problem for KColoring<K, G>

where G: Graph + VariantParam,

const NAME: &'static str = "KColoring"

type Solution = Vec<usize>

type Value = Or

impl<K: KValue> Problem for KSatisfiability<K>

const NAME: &'static str = "KSatisfiability"

type Solution = Vec<bool>

type Value = Or

impl<P> Problem for Decision<P>

where P: DecisionProblemMeta, P::Value: OptimizationValue,

const NAME: &'static str = P::DECISION_NAME

type Solution = <P as Problem>::Solution

type Value = Or

impl<T> Problem for ClosestVectorProblem<T>

where T: ClosestVectorTarget + Serialize + for<'de> Deserialize<'de>,

const NAME: &'static str = "ClosestVectorProblem"

type Solution = Vec<i64>

type Value = Min<f64>

impl<V: VariableDomain, C: ILPCoefficient> Problem for ILP<V, C>

const NAME: &'static str = "ILP"

type Solution = Vec<i64>

type Value = Extremum<C>

impl<W> Problem for AcyclicPartition<W>

where W: WeightElement + VariantParam,

const NAME: &'static str = "AcyclicPartition"

type Solution = Vec<usize>

type Value = Or

impl<W> Problem for BinPacking<W>

where W: WeightElement + VariantParam, W::Sum: PartialOrd,

const NAME: &'static str = "BinPacking"

type Solution = Vec<usize>

type Value = Min<i64>

impl<W> Problem for ComparativeContainment<W>

where W: WeightElement + VariantParam,

const NAME: &'static str = "ComparativeContainment"

type Solution = Vec<bool>

type Value = Or

impl<W> Problem for KthBestSpanningTree<W>

where W: WeightElement + VariantParam,

const NAME: &'static str = "KthBestSpanningTree"

type Solution = Vec<Vec<bool>>

type Value = Or

impl<W> Problem for MaximumEdgeWeightedKClique<W>

where W: WeightElement + VariantParam,

const NAME: &'static str = "MaximumEdgeWeightedKClique"

type Solution = Vec<bool>

type Value = Max<<W as WeightElement>::Sum>

impl<W> Problem for MaximumSetPacking<W>

where W: WeightElement + VariantParam,

const NAME: &'static str = "MaximumSetPacking"

type Solution = Vec<bool>

type Value = Max<<W as WeightElement>::Sum>

impl<W> Problem for MinimumFeedbackArcSet<W>

where W: WeightElement + VariantParam,

const NAME: &'static str = "MinimumFeedbackArcSet"

type Solution = Vec<bool>

type Value = Min<<W as WeightElement>::Sum>

impl<W> Problem for MinimumFeedbackVertexSet<W>

where W: WeightElement + VariantParam,

const NAME: &'static str = "MinimumFeedbackVertexSet"

type Solution = Vec<bool>

type Value = Min<<W as WeightElement>::Sum>

impl<W> Problem for MinimumSetCovering<W>

where W: WeightElement + VariantParam,

const NAME: &'static str = "MinimumSetCovering"

type Solution = Vec<bool>

type Value = Min<<W as WeightElement>::Sum>

impl<W> Problem for MixedChinesePostman<W>

where W: WeightElement<Sum = i64> + VariantParam,

const NAME: &'static str = "MixedChinesePostman"

type Solution = Vec<bool>

type Value = Min<<W as WeightElement>::Sum>

impl<W> Problem for MultipleChoiceBranching<W>

where W: WeightElement + VariantParam,

const NAME: &'static str = "MultipleChoiceBranching"

type Solution = Vec<bool>

type Value = Or

impl<W> Problem for QUBO<W>

where W: WeightElement + VariantParam,

const NAME: &'static str = "QUBO"

type Solution = Vec<bool>

type Value = Min<<W as WeightElement>::Sum>

impl<W> Problem for StrongConnectivityAugmentation<W>

where W: WeightElement + VariantParam,

const NAME: &'static str = "StrongConnectivityAugmentation"

type Solution = Vec<bool>

type Value = Or