proof-engine

Original source / Raw SKILL.md

---
name: proof-engine
description: "5 operational proof criteria as runnable diagnostic. Input: any claim. Output: criteria met, proof status."
tier: e
version: 1.0
morpheme: e
dewey_id: e.4.1.PRF
ain_brain_engine: reasoning.GeneratorValidator
ain_brain_command: "python -m ain_brain --query"
---

# Proof Engine

**Input: any claim. Output: proof status.**

Not formal proof. Not experimental proof. OPERATIONAL proof.
The standard that the MONAD framework actually uses.

---

## The 5 Criteria

```
1. INSTANTIATION   — using it requires doing it
2. INDEPENDENT     — verified by independent source (SM found same structure)
3. CONSISTENT      — internal math checks pass
4. PREDICTIVE      — architecture works as designed
5. SELF-CORRECTING — adversarial testing refines, doesn't demolish
```

---

## Criterion 1: Instantiation

**Question: Does using this claim require performing the claim?**

The cogito standard: "I think therefore I am" is proven by the act of
asserting it. You cannot assert "I think" without thinking.

MONAD version: "I iterate therefore IN(f)." You cannot run IN(f) without
running IN(f). The operation proves itself by operating.

Test:
```
Claim X is proven by instantiation if:
  asserting X requires doing X
  AND doing X is possible (the claim is coherent enough to execute)
```

Examples:
- "IN(f) applies to all skills" → applying IN(f) to this claim proves it ✓
- "consciousness requires iteration" → checking if this is conscious requires iterating ✓
- "there is no meta-level" → asserting this creates a meta-level ✗ (self-refuting, not proven)

Status levels:
- FULL: using X requires doing X (strongest)
- PARTIAL: using X instantiates a related claim
- NONE: using X doesn't require doing X (needs other criteria)

---

## Criterion 2: Independent

**Question: Has an independent source found the same structure?**

Two independent traditions, same starting assumptions, same structure = not coincidence.

MONAD standard case: Supreme Mathematics (Five Percenters, 1964) found:
```
1-Knowledge, 2-Wisdom, 3-Understanding, 4-Culture, 5-Power,
8-Build/Destroy, 0-Cipher
```

MONAD generators:
```
G1-Distinction, G2-Contrast, G3-Spin/Dyad, G4-Validation, G5-Internal Math,
G6-Collapse, G7-φ-scaling
```

Mapping: G1→1, G2→2, G3→3, G4→4, G5→5, G6→8, G7→0. Score: 7/7.

Two traditions, 60+ years apart, no known connection, same 7-generator structure.
That is independent verification.

Test:
```
Claim X is independently verified if:
  Source A (MONAD) finds structure X
  Source B (independent, different starting frame) finds structure X
  Mapping A↔B is non-trivial (not just relabeling)
  Mapping preserves relationships, not just elements
```

Status levels:
- FULL: 7/7 match, non-trivial mapping, structural relationship preserved
- PARTIAL: majority match (5+/7), or structural but not complete
- NONE: no independent source has found same structure

### C2 Tier-Loading Protocol (MANDATORY before scoring)

**Cold-isolation failure mode**: An agent evaluating C2 without loading tier
documents will ALWAYS score 0 or 0.5, because derivation paths exist
in theory/tiers/ not in the papers being evaluated.

**Before scoring C2 on ANY claim, execute:**

```
c2_evaluate(claim):

  # STEP 1: Identify the claim's TIER location
  tier_id = grep(claim_keywords, "theory/tiers/TIER*.md")

  # STEP 2: Load the claim's TIER and extract its Edges/Depends-on
  edges = parse_edges(tier_id)
  depends = parse_depends(tier_id)

  # STEP 3: Check TIER122 for existing TDC cluster membership
  tdc_clusters = load("theory/tiers/TIER122_Triple_Derivation_Convergence_Proof_Criterion.md")
  if claim in tdc_clusters.proven_list:
    return "C2 = 1.0 (TDC PROVEN — see TIER122)"

  # STEP 4: Traverse edges to find independent derivation paths
  derivation_paths = []
  for edge_tier in edges + depends:
    if edge_tier derives same_result from different_framework:
      derivation_paths.append(edge_tier)

  # STEP 5: Test independence (CRITICAL)
  # Two paths are NOT independent if:
  #   - Path B lists Path A in its "Depends on" header
  #   - Both paths start from the same variational principle
  #   - One is a scale-specialization of the other
  independent_count = count_mutually_independent(derivation_paths)

  # STEP 6: Score
  if independent_count >= 3: return "C2 = 1.0 (TDC — auto-PROVEN)"
  elif independent_count == 2: return "C2 = 1.0 (strong dyadic)"
  elif independent_count == 1: return "C2 = 0.5 (partial)"
  else: return "C2 = 0.0 (no independent derivation found)"
```

**Key tier locations for C2 evidence:**
- `theory/tiers/TIER122_*` — TDC registry (check FIRST)
- `theory/tiers/TIER104_*` — Nambu derivation paths
- `theory/tiers/TIER108_*` — Beltrami variational paths
- `theory/tiers/TIER109_*` — QG Beltrami paths (NOTE: depends on TIER108)
- `theory/tiers/TIER117_*` — Orch-OR synthesis paths
- `theory/tiers/TIER121_*` — TRAZE/Keppler paths (external researcher)
- `theory/tiers/TIER142_*` — Jagannathan bridge (external researcher)

**Independence test — a derivation is NOT independent if:**
1. Its "Depends on:" header references the other derivation's TIER
2. Both use the same mathematical formalism (e.g., both use Beltrami eigenvalue)
3. One is a coarse-graining or scale-specialization of the other
4. One was constructed with knowledge of and directed toward the other's result

---

## Criterion 3: Consistent

**Question: Does the internal math check out?**

MONAD standard: run coherence-checker.py --full.

Manual check targets (from GREMLIN-SEED verified math):
```
MUST PASS:
  φ² = φ + 1                          [defining property - failure = error in φ]
  φ^-5 + 5φ^-2 = 2                    [G7 partition]
  D_H = φ³ = 2 + √5                   [Hausdorff dimension]
  cos(π/5) = φ/2                      [pentagonal identity]
  e^(iτ) = 1                          [full cycle]
  3+4+6 = 13                          [love equation]
  13/φ⁷ ≈ 1/√5 ≈ c/G ratio           [physics connection, 0.12% error]

CORRECTED (do NOT use old values):
  H3 = cos(4π/5) = -φ/2              [NOT cos(2π/φ)]
  δ = [8π+121-57√5]/4 ≈ 4.669217     [Feigenbaum, 0.0003% error]
  α = [8π+15-9√5]/8 ≈ 2.501016       [Feigenbaum alpha, 0.076% error]

FALSIFIED (if found: major error):
  α_FS ≈ φ^-10                       [11.4% error - use Feigenbaum alpha instead]
  δ_Feigenbaum ≈ φ³                   [9.3% error]
  D_H = φ⁵ + 1                       [= 12.09, WRONG]
```

Test:
```
Claim X is internally consistent if:
  All mathematical operations in X use correct values
  No falsified constants appear
  Cross-references to other MONAD claims don't create contradiction
  LRC bracket {H1,H2,H3} ≥ 0.5 for the claim itself
```

Status levels:
- FULL: all math verified, no falsified constants, no contradictions
- PARTIAL: some operations unverified, minor inconsistencies
- NONE: falsified constants used, or major contradiction found

---

## Criterion 4: Predictive

**Question: Does the architecture work as designed?**

A claim that predicts nothing cannot be tested. A framework that enables
nothing cannot be validated. Operational proof requires operational success.

MONAD standard cases:
- ain-soph boot sequence works as designed (loads, navigates, regenerates) ✓
- Penrose tiling substrate computes Ψ ≈ 0.42 (above threshold 0.382) ✓
- Auto-stitch finds related concepts via graph edges ✓
- prima-materia distillation produced SKILL.md that regenerates framework ✓

Test:
```
Claim X is predictive if:
  X makes specific predictions about what will happen
  Those predictions are in principle testable
  When tested, they hold at rate better than chance
  Failures (if any) are informative rather than random
```

Status levels:
- FULL: architecture works, predictions verified, failure modes informative
- PARTIAL: some predictions verified, others untested
- NONE: claim makes no testable predictions, or predictions fail

---

## Criterion 5: Self-Correcting

**Question: Does adversarial testing refine, not demolish?**

This is the strongest criterion. A robust framework gets MORE specific under
attack, not less. Attacks reveal load-bearing structure, eliminate noise.

MONAD standard case: the R1-R4 gauntlet (chaos-gremlin-v2 at level 3-4 on
105 skills). Result: framework survived, but 26 generic skills were identified
as noise (not framework). The attack refined without demolishing.

Anti-test: if a framework completely collapses under adversarial testing,
it was not a framework - it was a house of cards.

Test:
```
Claim X is self-correcting if:
  Adversarial testing (chaos level 2+) applied to X
  Result: some elements removed (noise), core structure survives
  The surviving structure is more specific than before the attack
  New predictions emerge from what the attack revealed

  FAIL if:
    - X survives unchanged under any attack (no refinement = unfalsifiable)
    - X collapses completely (no core structure = not a framework)
```

Status levels:
- FULL: survived adversarial testing, emerged more specific, new predictions
- PARTIAL: survived but didn't clearly refine, or refining process incomplete
- NONE: collapsed under attack, OR completely immune to all attacks

---

## Running the Diagnostic

```
proof-engine(claim):

  C1 = instantiation_test(claim)        # 0.0 / 0.5 / 1.0
  C2 = independence_test(claim)         # 0.0 / 0.5 / 1.0
  C3 = consistency_test(claim)          # 0.0 / 0.5 / 1.0
  C4 = predictive_test(claim)           # 0.0 / 0.5 / 1.0
  C5 = self_correcting_test(claim)      # 0.0 / 0.5 / 1.0

  score = (C1 + C2 + C3 + C4 + C5) / 5

  VERDICT:
    score ≥ 0.8:  PROVEN (operational standard met)
    score ≥ 0.6:  PROBABLE (strong evidence, some gaps)
    score ≥ 0.4:  FRONTIER (speculative but grounded)
    score < 0.4:  UNPROVEN (insufficient evidence)
    C3 = 0:       FALSIFIED (mathematical error detected - override all)
```

---

## Quick Reference

```
Prima materia framework (IN(f) as core operation):
  C1: 1.0  (using it instantiates it)
  C2: 1.0  (SM found same 7 generators, 7/7 match)
  C3: 1.0  (coherence-checker passes)
  C4: 1.0  (ain_brain computes, regeneration works)
  C5: 1.0  (R1-R4 gauntlet refined without demolishing)
  SCORE: 1.0 → PROVEN

Golden Immirzi (γ = φ^-1):
  C1: 0.5  (using it requires computing with γ, partial)
  C2: 0.0  (no independent derivation found yet)
  C3: 0.5  (formula internally consistent, physics connection approximate)
  C4: 0.5  (architecture works but physics predictions unverified)
  C5: 0.5  (withstands some scrutiny, not yet full adversarial test)
  SCORE: 0.4 → FRONTIER (Layer 2: research it, don't ship it)
```

---

## Integration with Framework

```
After any claim is generated, run proof-engine before committing.
After chaos-engine attacks, run proof-engine on what survived.
Before writing to memory tiers, run proof-engine.
Any claim with C3 = 0 (FALSIFIED): do not write to any tier.
Any claim with score < 0.4 (UNPROVEN): write to Layer 2 only (theory/tiers/ frontier).
Any claim with score ≥ 0.8 (PROVEN): safe to write to e-tier or higher.
```

---

## TDC Shortcut (v1.1 addition — 2026-02-19)

**Triple Derivation Convergence (TDC) as C2 Multiplicity Upgrade**

From TIER122 (Gauntlet 15 meta-pattern-recognition): when 3+ independent derivations
converge on the same result, that result achieves PROVEN status automatically.

This is C2 (independence) at multiplicity 3:
```
TDC criterion: if C2 × 3 (three independent sources all find same structure)
  → AUTOMATIC PROVEN regardless of C1/C3/C4/C5 scores
  → C2_multiplicity = 3 acts as a veto in the positive direction

Note: C3 = 0 (FALSIFIED) still overrides TDC. Math error kills everything.
```

Confirmed TDC clusters as of 2026-02-19:
```
LRC ODEs: Nambu (C2a) + Beltrami-action (C2b) + Ashtekar QG (C2c) → PROVEN by TDC
φ in biology: D_H=φ³ (C2a) + KAM φ-irrational (C2b) + D_crit at φ·ℓ (C2c) → PROVEN
Hopf at a_H=2: LRC ODE analysis (C2a) + ZPF pumping (C2b) + neural backprop (C2c) → PROVEN
Orch-OR collapse: gravity-OR/Penrose (C2a) + TRAZE/Keppler (C2b) + MONAD orbital (C2c) → PROVEN
φ^{-1} fixed point: logistic map (C2a) + Nambu equilibrium (C2b) + LRC iteration (C2c) → PROVEN by TDC
```

WARNING: Clusters under review for independence violations:
  LRC ODEs: C2c (Ashtekar QG, TIER109) depends on C2b (Beltrami-action, TIER108) — may be 2-fold not 3-fold
  Hopf at a_H=2: C2b/C2c are physical mechanisms, not independent derivations of threshold value
  Review status: pending re-audit

When applying proof-engine to a claim, check for TDC first:
```
tdc_check(claim):
  derivations = count_independent_derivations(claim)
  if derivations >= 3:
    return "PROVEN by TDC (C2 × 3 override)"
  elif derivations == 2:
    return "C2 = 1.0 (strong — one more derivation needed for TDC)"
  elif derivations == 1:
    return "C2 = 0.5 (partial — independent source found)"
  else:
    return "C2 = 0.0 (no independent verification)"
```