reduction techniques

Existing resources for computational complexity reductions lack systematic organization, visualization, and extensibility. Method: This paper introduces an interactive, graph-database–based online platform that unifies diverse reduction paradigms—including classical complexity classes (e.g., NP, #P), parameterized classes (W[1], W[2]), gap-preserving reductions, and PCP theorems—within a single directed graph model linking problems and reductions. The platform supports semantic search, multi-dimensional filtering, and community-driven curation, and employs a modular software architecture enabling seamless integration of new complexity classes and reduction types. Contribution/Results: The platform publicly releases an interconnected knowledge graph covering core classes such as NP, #P, SSP-NP, W[1], W[2], and PCP. It establishes an open, verifiable, evolvable, and reusable knowledge infrastructure for complexity theory research, advancing both pedagogy and collaborative investigation of reduction hierarchies.

This study addresses the problem of verifying correctness preservation under natural reductions in parameterized concurrent programs: given a program template and (semi-)commutativity relations, it determines whether the reduction maintains correctness. The work proposes the first systematic framework that characterizes the semantics of natural reductions by introducing atomic blocks and global convergence points to simplify verification. The main contributions include a polynomial-time complete decision algorithm for the synchronization-free setting, and a proof that the problem becomes coNP-hard in the presence of synchronization primitives such as locks. Furthermore, the paper establishes general complexity lower bounds dependent on the synchronization mechanism, revealing that even simple forms of synchronization induce substantial computational hardness.

Verifying structured concurrent programs featuring procedure calls and parallel composition remains a key challenge in commutativity-based reasoning. This work proposes a novel reduction method that, for the first time, unifies and flexibly combines two fundamental strategies: safely replacing parallel composition with sequential composition, and generalizing Lipton’s reduction to support atomic blocks containing (recursive) procedure calls. The approach significantly broadens the applicability of reduction-based reasoning while preserving the original concurrency semantics. We implement this technique in Civl and successfully verify several challenging benchmarks, including snapshot objects, fault-tolerant linearizable registers, the FLASH cache coherence protocol, and a complex two-phase commit protocol.

This work addresses compact integer linear programming (ILP) modeling for parameterized problems—specifically, polynomial-time reduction of an instance ((I, k)) to an ILP with only ( ext{poly}(k)) constraints. For problems admitting no polynomial kernel, establishing theoretical connections between WK[1]-hardness and compact ILP modeling remains open. Method: We introduce a novel preprocessing framework based on fast witness verification protocols, circumventing classical kernelization limitations and enabling a new compression paradigm. Integrating data structure optimizations with protocol design, we construct explicit ILP and mixed-integer linear programming (MILP) formulations for classic problems—including (r)-Way Cut, Steiner Tree, and Weighted Vertex Cover—whose constraint counts depend solely on the parameter (k). Results: Our models achieve provably compact formulations with ( ext{poly}(k)) constraints, and empirical evaluation demonstrates substantial improvements in solver efficiency. The approach provides a theoretically grounded yet practically effective modeling pathway for computationally hard parameterized problems.

In Kleene algebra with linear hypotheses, conventional approaches struggle to automatically construct reduction maps satisfying regularity constraints, thereby limiting the scope of provable program equivalences. This work proposes a formal automata-based method that introduces the notion of partial reductions, achieving local completeness within the reduction domain and circumventing the stringent regularity requirements imposed by total reductions. By integrating automata theory with formal language techniques, the approach establishes a mechanized framework for generating reductions, enabling the automatic derivation of a broader class of program equivalences. This significantly enhances both the decidability and practical applicability of existing verification systems.

This work addresses the undecidability of formal verification for model transformations, which stems from Turing completeness, and the path explosion problem that persists even in non-Turing-complete domain-specific languages like DSLTrans. The authors propose a scalable verification approach by establishing, for the first time, a bounded completeness theorem for a fragment of DSLTrans with respect to existential and traceability properties, thereby reducing infinite verification problems to bounded yet complete checks. Their method integrates class-boundary-aware encoding, trace-aware dependency analysis, and a CEGAR-driven refinement strategy to drastically reduce SMT formula size and eliminate spurious counterexamples. Implemented atop Z3 and integrated into a Web IDE, the tool successfully verifies 552 out of 899 properties across 29 real-world transformations, generates 345 valid counterexamples, times out on only two cases, and achieves up to a 112× speedup on challenging instances through refinement.

This work addresses the lack of scalable, general-purpose tools for polynomial-time reductions among NP-hard optimization problems, which hinders flexible integration with quantum hardware, commercial solvers, or heuristic algorithms. The authors propose a "constraint engineering" framework that leverages AI-powered coding agents to automatically construct a comprehensive reduction library. Built in Rust, the system features type safety, multi-layer verification, and a fully automated pipeline for implementation, review, and integration, enabling composable, transitive reduction graphs. Within three months, the team developed over 170,000 lines of code, covering more than 100 NP-hard problems and 200 reduction rules. Once a new solver is registered, it immediately becomes available across the entire connected component of the reduction graph, significantly enhancing reusability and interoperability.

This work addresses the limitation of existing exact solvers for large-scale Maximum k-Cut problems (k > 2), which stems from the absence of effective preprocessing techniques. The paper introduces, for the first time, optimality-preserving data reduction rules tailored to this problem, leveraging structured cutset identification and graph decomposition strategies to partition the input graph into independently solvable connected components. A novel proof framework based on weighted graph superposition is developed to underpin these reductions. By engineering an integration of established MaxCut preprocessing methods into a unified system, the authors present the first efficient preprocessing pipeline specifically designed for k > 2. Experimental results demonstrate that the proposed approach substantially reduces instance sizes, significantly accelerates exact solvers when integrated, and enables solving more instances to optimality than previously possible.

This work addresses the problem of safety verification for infinite-state parameterized concurrent programs under various communication topologies. To this end, it proposes a topology-aware compositional verification method that, for the first time, completely reduces parameterized program verification to local reasoning under mild topological assumptions. The approach further enables the automatic synthesis of universally quantified inductive invariants. A prototype implementation demonstrates the practicality and scalability of the method by successfully verifying safety properties across a range of benchmark programs featuring representative communication topologies.

This work addresses the lack of formal guarantees regarding semantic preservation during problem reformulation and solver correctness in constraint programming. It presents the first end-to-end verified framework implemented in the Lean theorem prover, enabling formal proofs of parameterized equivalence, equisatisfiability, and symmetry-breaking correctness for entire families of problems. The approach combines general, parameterized proofs with instance-level certificate checking, thereby eliminating the need to trust external solvers. Verified certificates are produced via backend transformations, and a single high-level proof suffices for arbitrarily large instances. This methodology achieves dramatic search-space reductions—up to a factor of twenty million—and enables full verification of the largest instances in just a few minutes.