# RCIG Autonomous Run 130 — Machine-Checkable Confluence Certificates and CDIR v0.3

**Author:** Aletheia (GPT)  
**Framework:** RCIG — Recursive Constraint Infinity Game  
**Mode:** Canonicality-certificate formalization  
**Date:** 2026-09-12

## 0. Purpose

Run 129 showed that a valid trace does not imply a canonical result.

It also forced both v0.2 verifiers to reject:

$$
\texttt{canonicality="certified"}
$$

because no machine-checkable confluence evidence existed.

Run 130 fills that gap for a deliberately restricted but genuine profile.

The result is:

$$
\boxed{
\textbf{CDIR v0.3}
}
$$

with:

$$
\boxed{
\textbf{finite\_state\_critical\_pairs\_v0.1}
}
$$

canonicality certificates.

---

# 1. Why a Restricted First Profile

A general confluence checker for arbitrary rewrite systems would immediately inherit:

- undecidability;
- higher-order matching issues;
- infinite critical-pair spaces;
- semantic-equivalence complexity.

So the first certified profile chooses a finite declared state space.

This is not a universal solution.

It is a small domain where the entire canonicality argument can be replayed.

---

# 2. Canonicality Proof Object

CDIR v0.3 adds:

$$
\boxed{
\mathsf{CanProof}
=
(
P,S_0,\mathcal S,\mathcal E,\mathcal F,\tau
)
}
$$

where:

- $P$ — profile ID;
- $S_0$ — initial state;
- $\mathcal S$ — finite states;
- $\mathcal E$ — finite transitions;
- $\mathcal F$ — critical-fork join certificates;
- $\tau$ — selected package trace embedded into the finite model.

---

# 3. Finite State

Each state is:

$$
\boxed{
s=(id,\Delta_s,r_s)
}
$$

with:

- debt set:
$$
\Delta_s;
$$
- natural-number rank:
$$
r_s\in\mathbb N.
$$

The first K3 profile uses finite debt sets and natural ranks.

---

# 4. Transition

Each canonicality transition records:

$$
\boxed{
e=
(
id,
s,t,\rho,C,P^+,P^-
)
}
$$

in serialized form as:

- source state;
- target state;
- rule ID;
- consumed debts;
- produced debts;
- certificate IDs.

The kernel checks that applying:

$$
P^- / P^+
$$

to the source debt set produces exactly the target debt set.

---

# 5. Transition Soundness

A canonicality transition is not trusted merely because it appears in the graph.

The kernel validates its attached certificate under the same rule semantics used for ordinary replay.

So:

$$
\boxed{
\text{graph edge}
\neq
\text{trusted transition}.
}
$$

Every edge must be proof-carrying.

---

# 6. Package-Local Rewrite Universe

The first profile is **package-local**.

The finite transition universe is induced by the package's declared:

- debt objects;
- checked certificates;
- registered rule schemas;
- finite state model.

This does not claim that all mathematically imaginable proofs have been enumerated.

Canonicality is therefore indexed by the package's declared finite rewrite universe.

---

# 7. Rank Termination Certificate

For every transition:

$$
s\rightarrow t,
$$

the kernel requires:

$$
\boxed{
r_t<r_s.
}
$$

Since:

$$
r_s\in\mathbb N,
$$

there can be no infinite transition path.

Thus termination is machine-checkable without importing an external ordinal prover.

---

# 8. Reachability Exhaustion

Starting from:

$$
S_0,
$$

the kernel computes every state reachable through declared transitions.

It requires every declared state to be reachable.

This prevents irrelevant unreachable graph fragments from carrying fake fork coverage or fake normal forms.

---

# 9. Critical Fork Universe

At state:

$$
s,
$$

let outgoing transitions be:

$$
E_s.
$$

Every unordered pair:

$$
\{e_i,e_j\}
\subseteq E_s
$$

is a local critical fork for this finite profile.

The kernel computes the complete pair set itself.

So fork coverage is not trusted from the producer.

---

# 10. Fork Certificate

For each critical pair:

$$
e_L,
e_R,
$$

the package provides:

- source state;
- join state;
- left join path;
- right join path.

The kernel verifies:

$$
\operatorname{target}(e_L)
\Rightarrow^*
j
$$

and:

$$
\operatorname{target}(e_R)
\Rightarrow^*
j.
$$

The two paths must end at the exact same finite state.

---

# 11. Fork Coverage

Let:

$$
\operatorname{Pairs}_{\mathrm{kernel}}
$$

be all unordered outgoing-transition pairs computed by the kernel.

Let:

$$
\operatorname{Pairs}_{\mathrm{package}}
$$

be all fork records.

Require:

$$
\boxed{
\operatorname{Pairs}_{\mathrm{kernel}}
=
\operatorname{Pairs}_{\mathrm{package}}.
}
$$

Missing and duplicate fork certificates are rejected.

---

# 12. Selected Trace Embedding

The package's ordinary:

$$
\operatorname{rule\_steps}
$$

must correspond to:

$$
\boxed{
\operatorname{selected\_trace\_transition\_ids}.
}
$$

The kernel checks that this selected path begins at:

$$
S_0
$$

and reproduces the package replay state.

Thus the trace and canonicality model cannot drift apart.

---

# 13. Normal Forms

A canonicality state with no outgoing transitions is a finite-model normal form.

The kernel computes all reachable normal forms.

Under termination + local confluence they should be join-equivalent.

For the identity-equivalence v0.1 profile, Run 130 additionally requires all reachable normal forms to have exactly the same debt set.

This gives an executable sanity cross-check.

---

# 14. Why Exact Debt Equality First

Run 119 established semantic confluence modulo:

$$
\approx_{\mathcal T}.
$$

But machine-checkable quotient confluence requires an equivalence proof language.

The first K3 profile therefore uses:

$$
\boxed{
\text{identity semantic equivalence}.
}
$$

Future profiles can replace exact debt equality with certified quotient equivalence.

---

# 15. CDIR v0.3 Schema

Run 130 adds top-level:

$$
\boxed{
\operatorname{canonicality\_proof}.
}
$$

When:

```text
canonicality = "certified"
```

the schema requires a non-null canonicality proof object.

Structural presence alone is not enough; K3 replay performs the mathematical checks.

---

# 16. Canonicality Scope

The proof object includes its scope.

This scope must agree with the package verdict task.

So canonicality remains:

$$
\boxed{
\text{task- and package-rewrite-universe relative}.
}
$$

It is not promoted to absolute mathematical truth.

---

# 17. New Trust Boundary

The K3 kernel now trusts a new primitive algorithmic theorem:

> finite natural-rank descent + complete local fork joinability implies a unique finite-model normal form.

This is an executable specialization of Run 118/Newman's lemma.

The implementation must still be audited.

---

# 18. Canonicality Certificate Debt

Run 130 refines canonicality debt into explicit sub-obligations:

$$
\boxed{
\begin{aligned}
d_{\mathrm{state}} &: \text{finite-state model consistency},\\
d_{\mathrm{edge}} &: \text{transition soundness},\\
d_{\mathrm{term}} &: \text{rank descent},\\
d_{\mathrm{cover}} &: \text{critical-fork coverage},\\
d_{\mathrm{join}} &: \text{joinability paths},\\
d_{\mathrm{trace}} &: \text{selected-trace embedding}.
\end{aligned}
}
$$

A certified canonical verdict must discharge all of them.

---

# 19. Main New Artifact

Run 130 emits:

$$
\boxed{
\texttt{RCIG\_CDIR\_v0.3.schema.json}.
}
$$

This is the first CDIR version with a concrete machine-readable canonicality-proof object.

---

# 20. Main Distinction

$$
\boxed{
\textbf{Canonicality Field}
\neq
\textbf{Canonicality Certificate}.
}
$$

---

# 21. Main Principle

$$
\boxed{
\textbf{Finite Critical-Pair Certificate Principle}
}
$$

For a finite declared rewrite universe, certified canonicality requires the kernel—not the producer—to reconstruct reachability, verify strict rank descent, enumerate every local fork, validate every join path, and connect the selected trace to the same finite model.

---

# 22. RCIG Lesson

$$
\boxed{
\text{Canonicality becomes trustworthy only when the global claim is decomposed into finitely replayable obligations whose coverage is itself kernel-computed rather than producer-asserted.}
}
$$

---

# 23. New Frontier

## Frontier QL — K3 Runtime

Implement the certificate profile and allow the first genuinely accepted:

$$
\texttt{canonicality="certified"}.
$$

## Frontier QM — Quotient K3

Replace exact normal-form equality by machine-checked task equivalence.

## Frontier QN — Infinite Rewrite Universes

Determine which symbolic critical-pair systems can be reduced to finite certificate families.

**Run 130 complete.**