1. Introduction
The P vs NP question asks whether every language whose YES-certificates can be verified in polynomial time also admits polynomial-time decision procedures. This work develops a symmetry- and type-theoretic lens, Orbit-Collapse Complexity (OCC), that (i) proves sufficiency criteria for polynomial-time decidability, (ii) quantifies the structured mass of tractable subfamilies, and (iii) provides reduction policies that target hardness outside those subfamilies. Our contributions are:
Collapse ⇒ P (Theorem 1): If instances canonically compress to polynomially many types with polytime canonicalization and per-type solvers, the language is in P.
Metrics for structure: orbit coverage, type-growth exponents, and orbit-compressibility index make “how much collapses” a measurable notion.
Distance-to-core algorithms: XP and FPT meta-theorems for instances at bounded edit distance from a P-core.
Layer-Respecting Reductions (LRR): reductions that preserve or raise layer depth, supporting hardness beyond cores.
Sudoku case study: exact separable class law, bi-affine degree-4 certificates, and Pólya formulas for piecewise families.
2. Model and Symmetries
We consider finite-domain CSP families; the discussion covers SAT, Graph Coloring, Sudoku/Latin, Integer Programming encodings, TSP with discrete symmetries, etc.
Definition 1 (CSP family). A CSP family has instances of size n over a finite domain D. Each instance specifies constraints of bounded arity on variables with . The language is the decision problem: “Does I admit a solution?”
Definition 2 (Symmetry group). For each n, let be a finite group that acts on instances and solutions. The orbit of X is and the stabilizer is .
Definition 3 (Orbit-compressibility). For a solution S, define Small κ indicates large stabilizer (high structure).
3. Constructors, Layers, and P-Cores
Definition 4 (Constructor, Layer). Aconstructor is a uniform polytime recognizer that defines a syntactic subfamily . A list defines layers . A fixed layer order assigns each solution to the first matching layer; layers become disjoint by fiat.
Definition 5 (P-core). A P-core is a constructor family with polytime membership (and, when needed, polytime canonicalization within its symmetry). Trivial finite sets are excluded.
Proposition 1. If membership in is decidable in time , then deciding L restricted to K is in P.
4. Orbit-Collapse ⇒ P
Definition 6 (Types and canonicalization). Fix an equivalence ∼ (e.g., the -action or a coarser invariant). Let be the set of canonical representatives. A canonicalizer is a polytime map with .
Theorem 1 (Orbit-Collapse ⇒ P). Let . Suppose for all n: (i) ; (ii) is computable in ; (iii) there is a predicate A on with . Then .
Proof. On input I, compute and return . Correctness is by (iii). Runtime is polynomial by (ii)–(iii). The bound (i) ensures that the analysis of types is polynomially bounded and realizable. □
5. Quantifying Collapse
Let be solution orbits in under ; for a core K. We use:
Orbit coverage ;
Type-growth exponent ;
Core ratio inside a layer for .
6. Algorithms by Distance-to-Core
Definition 7 (Edit distance). Fix a finite set Δ of local edit templates. For instance I, let be the minimum number of Δ-edits sending I into K.
Lemma 1 (XP by bounded edits). For bounded-arity CSPs and any P-core K, satisfiability is decidable in time , where .
Proof. Branch over candidate edit sets of size d, test membership in K in polynomial time, and verify consistency. □
Theorem 2 (FPT under bounded boundary width). Assume: (i) constraints have bounded arity; (ii) any set of d edits induces a defect substructure of treewidth ; (iii) the core K is MSO-definable on bounded-treewidth hosts. Then satisfiability is decidable in time .
Proof sketch. Enumerate the interface between the edited region and K; apply DP/Courcelle on a tree decomposition of width to glue feasible assignments consistent with K. All combinatorics depend on d only. □
7. Layer-Respecting Reductions (LRR)
Definition 8 (Layer depth). Given layers , define .
Definition 9 (LRR at depth t). A reduction is layer-respecting at depth t if for all I.
Proposition 2 (Closure). If is LRR at depth and at depth , then is LRR at depth .
Proof. Immediate from the definition. □
Conjecture 1 (Layered ETH (L-ETH)).
For each fixed t, there exists such that deciding instances with requires time(under ETH/SETH-style assumptions), witnessed by LRRs from 3-SAT that pushℓabove t.
8. Layered Orbit Sums (Accounting)
Let be all solutions at size n, with layer-ordered assignment (each solution taken by the first matching layer). Then:
Theorem 3 (Layered Orbit Sum). with an extra factor if symbol relabeling is counted, where .
Proof. Orbit–stabilizer plus disjointness of layer assignment. □
9. Proof-Complexity Calibration inside Layers
Proposition 3 (Bi-affine ⇒ low-degree certificates). In bi-affine layers (e.g. Sudoku ), feasibility/infeasibility has polynomial-size polynomial-calculus and degree-4 sum-of-squares certificates after standard symmetry breaking.
Proof sketch. Encode row/column/box bijectivity by quadratic equations over indicators; the bi-affine placement map linearizes under a fixed normal form so constraints reduce to degree identities. SOS/PC derives these with degree . □
10. Sudoku Case Study: Formulas and Laws
Let k be the box order; grid size ; position symmetry with canonical digit relabeling.
Separable layer
Two orbit sizes arise: large and small. Let , the 2-adic valuation, and the number of distinct odd primes dividing k.
Theorem 4 (Separable class law). with Moreover #small classes and #large .
Proof outline. Parameterize separable constructors by producing type pairs . The group together with internal permutations on acts on this parameter space. By the Chinese Remainder Theorem, and each factor contributes fixed points corresponding to involutions (). These yield index-2 stabilizers responsible for small orbits; counting across CRT components gives a factor . The doubling in the prime-lean regime (, at most one odd prime) and in composite-rich cases reflects whether both axes admit independent involutive symmetries after normal forms. A detailed orbit–stabilizer enumeration (omitted here for brevity) completes the count. □
Bi-affine layer
Empirically (and provably for small k): with if , else 0; and . For prime , and the ratio shows a constant-order core inside .
Piecewise Layers
With multiplicative local catalogs (tabulated by small fixed-point counts), exact Pólya forms are
11. Taxonomy by Collapse
S-OC: complete constructor + polytime canonicalization + ⇒ language in P (Thm. 1).
W-OC: large P-cores with subexponential type growth and nontrivial orbit coverage; full language may remain NP-hard.
NC: no such collapse under the chosen symmetries; expect NP-hardness beyond cores; target LRR.
12. How to Apply OCC
Pick ; design constructors ; count types; establish canonicalization and per-type tests; compute ; design distance-to-core algorithms; and craft LRR gadgets for hardness outside cores.
13. What is Proved vs Conjectured
Proved here: Collapse ⇒ P (Thm. 1); layered orbit sum; core-in-P; LRR closure; XP/FPT meta-results (with stated locality assumptions); bi-affine degree-4 certificates (Prop. 3) with constructive sketch.
Conjectural: L-ETH; full proof of the bi-affine count for all k; Wreath-invariant SoS lower bounds beyond cores.
Funding
No external funding.
Data Availability Statement
Tables and code snippets sufficient to reproduce all counts are included in the appendix; additional scripts will be provided upon request.
Acknowledgments
The author thanks collaborators and the broader community for feedback on early drafts of the OCC framework.
Conflicts of Interest
The author declares no conflict of interest.
Ethics
This study involves no human or animal subjects.
Appendix A. Python Utilities
import math
def phi(n):
r, m, p = n, n, 2
while p*p <= m:
if m % p == 0:
while m % p == 0: m //= p
r -= r // p
p += 1
if m > 1: r -= r // m
return r
def r2(n):
c = 0
for x in range(1, n):
if math.gcd(x, n) == 1 and (x*x) % n == 1:
c += 1
return c
def v2(n):
e = 0
while n % 2 == 0 and n > 0:
n //= 2
e += 1
return e
def omega_odd(n):
s, m, p = set(), n, 2
while p*p <= m:
if m % p == 0:
if p % 2: s.add(p)
while m % p == 0: m //= p
p += 1
if m > 1 and m % 2 == 1:
s.add(m)
return len(s)
def S_sep(k):
phi2 = phi(k)**2
R2 = r2(k)
E = (2*R2) if (v2(k) <= 1 and omega_odd(k) <= 1) else (4*R2)
return (phi2 + E)//2
References
- S. Cook, “The Complexity of Theorem-Proving Procedures,” Proceedings of the Third Annual ACM Symposium on Theory of Computing (STOC), 1971.
- R. M. Karp, “Reducibility among Combinatorial Problems,” in Complexity of Computer Computations, 1972.
- Courcelle, B. The Monadic Second-Order Logic of Graphs I: Recognizable Sets of Finite Graphs. Information and Computation 1990, 85(1), 12–75. [Google Scholar] [CrossRef]
|
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content. |
© 2025 by the author. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (https://creativecommons.org/licenses/by/4.0/).