Skip to content

Claude/2026 sota benchmark xyp1zh - #27

Merged
jesusvilela merged 6 commits into
mainfrom
claude/2026-sota-benchmark-xyp1zh
Jul 8, 2026
Merged

jesusvilela merged 6 commits into
mainfrom
claude/2026-sota-benchmark-xyp1zh

Conversation

@jesusvilela

Copy link
Copy Markdown
Owner

No description provided.

claude added 6 commits July 7, 2026 20:53
…ndary

The standing critiques (favorable-by-construction; not a CDCL replacement;
CryptoMiniSat already does XOR+Gaussian) are all fair -- and all answered by a
three-way measurement (Kissat 4.0.4, CryptoMiniSat 5.14.7, middleware), not
assertion. docs/ladder/scripts/beyond_cdcl.py + BEYOND_CDCL_NOTE.md.

The decisive, honest result -- CryptoMiniSat owns PARITY but is blind to COUNTING:

  parity Tseitin nv100 : Kissat TIMEOUT | CMS 1268ms | mw 2ms   (CMS's XOR works)
  counting php10       : Kissat 403ms   | CMS TIMEOUT| mw 3ms   (CMS worse than
  counting php11       : Kissat 2558ms  | CMS TIMEOUT| mw 3ms    Kissat here --
  counting php12       : Kissat TIMEOUT | CMS TIMEOUT| mw 4ms    XOR prepass is
                                                                 pure overhead)

So the middleware is NOT redundant with CryptoMiniSat: on parity the frames merely
re-derive what CMS ships (no novelty claimed), but on counting CMS faces the same
exponential resolution wall as pure CDCL -- and times out even EARLIER than Kissat
on php10 -- while the counting frame is flat. The genuine, measured contribution
is the counting/cardinality fragment plus the cross-frame coupling (Nelson-Oppen),
which neither Kissat, CaDiCaL, nor CryptoMiniSat performs. Critique 2 (replacement)
answered honestly: the frontier is cooperation, not replacement -- feeding the
coupled router's entailed literals to CDCL as a warm-start is the next step.

- docs/ladder/scripts/beyond_cdcl.py: 3-way harness (bounded CMS via subprocess)
- docs/ladder/BEYOND_CDCL_NOTE.md: the boundary + all three critiques answered
- SOTA_BENCHMARK_REPORT.md: CryptoMiniSat section extended with the counting
  differentiation; README index row
- .gitignore: sota_benchmark_results.json (critic caveat -- harness no longer
  dirties the working tree)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Gkw2ccXyb4DEtqFo29ouQD
Two deliverables from the GRD inspiration and the warm-start ask.

1. GRD_CLASH_NOTE.md -- read CDCL, CryptoMiniSat and the frame router as motion
   on manifolds through the operator's Geodesic Resonance Descent. CDCL moves on
   the flat cube (sees no curvature); CryptoMiniSat adds ONE curved chart (parity)
   -- GRD's moving-frame correction -- and works there but grinds on counting;
   ours reads three charts and moves on the flat one, couples them, and gates on
   soundness. What SURVIVES the clash and returns unchanged around every inference
   loop is soundness = ZERO HOLONOMY DEFECT, which for our frames is a tested
   theorem (gluing_defect == 0: sound frames cannot disagree). GRD's dual clock
   (fast flow / slow certify) is our breathing coupling + DRAT/model certification.

2. Warm-start = GRD's escape field, made operational and MEASURED honestly.
   coupled_entailments exposes the literals the coupling entails via GF(2) even
   when it escalates -- sound (implied), so appending them as units before Kissat
   is a valid warm-start. Result (scripts/warmstart.py, 16 planted forcing-parity
   + hard-core instances): MEDIAN ~1.10x -- an honest half-negative. The mechanism
   is sound and occasionally large (a probe instance: cold 63ms -> warm 3ms, 21x),
   but median-neutral because (a) modern Kissat inprocessing already recovers much
   of the GF(2) structure, and (b) instances hard enough to benefit are usually
   fully DECIDED by the frames (no fallback) -- the warm-start only bites in a thin
   band of partial parity with a CDCL-hard residual. Reported as measured, not
   spun: the easy win it looked like a priori is small and high-variance here.

- backend/frame_solver.py: BreathTrace.entailed + coupled_entailments (escape field)
- backend/tests/test_frame_solver.py: entailed units preserve satisfiability (sound)
- docs/ladder/scripts/warmstart.py: cold-vs-warm Kissat harness
- docs/ladder/GRD_CLASH_NOTE.md + README index

597 tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Gkw2ccXyb4DEtqFo29ouQD
… GRD)

Clashing the operator's continuous escape-field / continuous-geometry framework
(Eikonal ||grad U|| = 1/c with viscosity solutions, signed distance ||grad f||=1,
geodesic descent -- the smooth backbone of GRD's escape field eps*T and Exp
geodesic) against our discrete algebraic decidability, by MEASURING both fields.

Our discrete analogs: escape-field value U(x) = coupling rounds to a verdict;
signed distance f(x) = hyperbolic_depth to the decidable region. Diluting a
satisfiable parity core with random noise, both SNAP at the boundary
(scripts/escape_fold.py): between coverage 1.00 and 0.91 the verdict goes SAT ->
CDCL_NEEDED, U jumps 0 -> infinity, f jumps 0.20 -> 14.16 (straight to the
boundary at infinity), and the far side is near-empty (the coupling entails ~1
var out of 26 and never more). Pure random 3-SAT is beyond the fold at every
alpha. So the SAT decidability landscape is a Thom catastrophe FOLD, not a graded
Riemannian field -- there is no smooth gradient to descend across the boundary
(the operator's "shadow fold").

Why GRD pertains, sharply: its V_t = -grad E + U_t + J grad H + eps*T carries a
SEPARATE bounded-tunnelling term eps*T because a purely-geodesic optimizer would
be trapped at the fold -- exactly as a pure-frame solver is trapped at
CDCL_NEEDED. You cannot geodesically cross a catastrophe fold; you must tunnel.
Our architecture IS that decomposition: descend the smooth chart on the island
(the coupling breathes), tunnel across the fold (certified CDCL). This also
explains why the warm-start was a half-negative (the far side is near-empty, so
the escape field has almost nothing to hand the tunnel).

- docs/ladder/scripts/escape_fold.py: the measured fold (cliff + flat far side)
- docs/ladder/ESCAPE_FIELD_NOTE.md: the clash + GRD's two-velocity vindication,
  with honest Charter boundary (behaves-like-SDF, not a proven viscosity solution)
- backend/tests/test_frame_solver.py: the fold snaps (verdict/U/depth), far side
  near-empty; README index

598 tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Gkw2ccXyb4DEtqFo29ouQD
…ao finding

Instead of a single solving stream, treat GRD as the omni viscosity medium
filling instance-space and SCOUT it: predict where the decidability folds (the
CDCL tunnelings) arise before falling into them. backend/scout.py reads cheap
algebraic detectors (far cheaper than the deciders they forecast) and classifies
each instance: ISLAND (a frame decides), TUNNEL (no structure -> straight to
CDCL), or FOLD (partial parity, the ambiguous boundary layer).

Measured accuracy on a mixed corpus: ISLAND 16/16 correct, TUNNEL 10/10 correct,
and the FOLD band honestly mixed (9 decided / 5 escalated). The scout is exact in
the confident regions and REFUSES TO GUESS exactly where guessing is impossible.

Two sub-findings: (1) structure is invisible to clause-shape -- Tseitin and random
3-SAT are identical by clause length; the difference lives in sign patterns and
orbits, so the algebraic detectors are required. (2) Payoff for the overhead
critique: on confident TUNNEL the router can skip the frame deciders and go
straight to CDCL, removing the pre-pass overhead on unstructured instances.

Fisher-Rao (the operator's question): it is the right natural metric -- the
scout's field P(decide|features) is a statistical manifold, and the fold should be
a Fisher metric singularity where I = (P')^2/(P(1-P)) diverges. But measured along
the cheap COVERAGE coordinate, sqrt(I) does NOT spike: P(decide|coverage) stays
~0.9 because the coupling is robust and the fold's LOCATION is instance-dependent
(set by the exact GF(2) rank, not the surface coverage), so averaged it smears.
Honest lesson (hypercomplex/hyperdim/infinitesimal): the infinitesimal metric only
reveals the fold in the NATURAL algebraic coordinate (rank-deficiency), not the
naive Euclidean feature coordinate -- Fisher-Rao is the right instrument, coverage
is the wrong chart. This is also why the FOLD band resists cheap prediction.

- backend/scout.py: scout() + scout_features() (ISLAND/TUNNEL/FOLD)
- backend/tests/test_scout.py: confident regions exact, fold band exempt
- docs/ladder/SCOUT_NOTE.md + README index

603 tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Gkw2ccXyb4DEtqFo29ouQD
…e rank chart

The operator's challenge -- "can you not measure the sign-patterns and orbits?" --
answered decisively YES, and it vindicates the whole Fisher-Rao thread.

Measuring the ACTUAL algebraic content of the sign-patterns -- the GF(2) rank-
deficiency of the recovered XOR system (scout.xor_rank_deficiency) -- reveals the
fold that the crude coverage feature completely smeared:

  P(decide) vs XOR rank-deficiency (consistent systems):
    deficiency 0.00 (Gaussian DETERMINES the vars): P=0.99  island   Fisher sqrt(I)=0
    deficiency 0.05                                : P=0.33           Fisher sqrt(I)~18  <-- spike
    deficiency 0.10 (a free variable remains)      : P=0.12  tunnel   Fisher sqrt(I)=0

So Fisher-Rao DOES geometrize the decidability fold as a metric singularity --
but only in the NATURAL algebraic coordinate (rank-deficiency), not the naive
Euclidean coverage coordinate where it washes out. The metric is the right
instrument; the sign-patterns (as GF(2) rank) are the right chart. This is the
hypercomplex/hyperdim/infinitesimal lesson made concrete and measured.

Feeding the natural coordinate back into the scout resolves the fold it could not
predict before: confident coverage 65% -> 90% (ISLAND 32/32, TUNNEL 15/15, ZERO
errors), ambiguous band 14 -> 5 (the residual thin layer at deficiency ~0.05 where
P(decide)~0.3 is a genuine coin-flip the geometry localizes but cannot remove).

- backend/scout.py: xor_rank_deficiency (the natural fold coordinate); scout now
  reads it instead of coverage for the parity band
- docs/ladder/scripts/fisher_fold.py: the Fisher metric spike, reproducible
  (flat along coverage, spikes along rank-deficiency)
- backend/tests/test_scout.py: the rank coordinate + resolved fold
- docs/ladder/SCOUT_NOTE.md: the vindication + the honest residual coin-flip floor

606 tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Gkw2ccXyb4DEtqFo29ouQD
Treat the instance's initial state not as a viscosity medium (a field to
move through) but as a FABRIC: a tapestry of qualities threaded together
for a holistic view before any solving.

- backend/fabric.py: Fabric dataclass + fabric() weaving six threads
  (parity rank-deficiency, orbit coarseness, gyration/hyperbolic depth,
  counting, implication, shape). Each thread is a chart of the cosmo
  manifold with its own natural coordinate.
- scripts/fabric_ledger.py: distributional ledger placing families in
  distinct regions (Tseitin/XORSAT on the parity thread, PHP on the
  orbit thread, random at the gyration boundary, mixed strung between).
- scripts/fisher_fold.py: adds the orbit thread (P(counting refutes) vs
  symmetry coarseness) alongside the parity thread. Both fold as
  Fisher-Rao metric singularities in their natural coordinate:
  parity/rank-deficiency sqrt(I)~18.4 at 0.05, orbit/symmetry sqrt(I)~158
  at 0.90 -- both catastrophe walls, both flat in the crude chart.
- docs/ladder/FABRIC_NOTE.md + README index entry.

610 passed.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Gkw2ccXyb4DEtqFo29ouQD
@jesusvilela
jesusvilela merged commit a17ab25 into main Jul 8, 2026
4 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants