Skip to content

ordinal(buchholz): rank-lex-jb scaffold — parallel rank with richer bplus second component#147

Merged
hyperpolymath merged 1 commit into
mainfrom
session/rank-lex-jb-scaffold
May 28, 2026
Merged

ordinal(buchholz): rank-lex-jb scaffold — parallel rank with richer bplus second component#147
hyperpolymath merged 1 commit into
mainfrom
session/rank-lex-jb-scaffold

Conversation

@hyperpolymath
Copy link
Copy Markdown
Owner

Summary

Opens the sole-viable forward path for the bplus-chain-level bpsi-source-at-equality discharge after PR #146's checked refutations of the two prior unblock routes (additive-principal on generic sums + strict-left-mono of _⊕_).

New module Ordinal.Buchholz.RankLexJointBplus:

  • leftmost-α : BT → Ord — leftmost-ψ-α-rank discriminator.
  • rank-lex-jb : BT → RankLex — parallel lex rank with richer bplus second component (leftmost-α instead of oz).
  • rank-lex-jb-strict-second-at-equal-first — load-bearing scaffold primitive: fires <lex-second at equal first components.
  • 4 + 4 definitional sanity lemmas; leftmost-α-bplus-left two-level convenience.

Honest scope

Scaffold-only. The full headline (joint-bplus <ᵇ-+1 discharge at bpsi-source-at-equality) requires the (a)+(b)+(c) assembly documented in the module preamble:

  • (a) equal-first lex-second leg — closed here.
  • (b) strict-first lex-first leg — multi-PR follow-on (same bplus-chain sum-bound challenge that motivated the refactor).
  • (c) first-component trichotomy — non-trivial Ord-valued decidability bridge not landed in Phase13 yet.

The next session's task is (b) + (c) + assembly into a full headline; this scaffold lays the foundation.

Test plan

  • agda --library-file=/tmp/echo-libraries -i proofs/agda proofs/agda/Ordinal/Buchholz/RankLexJointBplus.agda exits 0
  • agda --library-file=... proofs/agda/Ordinal/Buchholz/Smoke.agda exits 0
  • scripts/kernel-guard.sh PASS (kernel cone funext-free + classification in sync)
  • Wired into All.agda adjacent to RankLexSlice3; pinned in Ordinal/Buchholz/Smoke.agda under own block per CLAUDE.md Working rules
  • Zero postulates, --safe --without-K, no funext

🤖 Generated with Claude Code

…plus second component

Opens the sole-viable forward path for the bplus-chain-level
bpsi-source-at-equality discharge after PR #146's checked refutations
of the two prior unblock routes (additive-principal on generic sums +
strict-left-mono of `_⊕_`).

New module `Ordinal.Buchholz.RankLexJointBplus`:

* `leftmost-α : BT → Ord` — leftmost-ψ-α-rank discriminator (walks
  the left spine of a left-leaning `bplus` chain to its atomic leaf;
  reads off `rank-pow α` for `bpsi _ α` leaves, `oz` otherwise).
* `rank-lex-jb : BT → RankLex` — the parallel lex rank.  First
  component matches `RankLex.rank-lex` pointwise; second component
  diverges only on `bplus` (uses `leftmost-α` instead of `oz`).
* `rank-lex-jb-strict-second-at-equal-first` — the load-bearing
  primitive: fires `<lex-second` when first components are
  propositionally equal and `leftmost-α` witnesses are strictly
  ordered.  Closes the (a) leg of the follow-on case-split documented
  in the module preamble.
* Definitional sanity (4 per ranks: bzero / bOmega / bpsi / bplus).
* `leftmost-α-bplus-left` two-level convenience (mirrors
  `HeadOmega.head-Ω-bplus-left`).

Honest scope: this is scaffold-only.  The full headline (joint-bplus
`<ᵇ-+1` discharge at the bpsi-source-at-equality sub-case) requires
the (a)+(b)+(c) assembly the module preamble documents: a
first-component trichotomy, the equal-first lex-second leg (this
slice), and the strict-first lex-first leg (multi-PR follow-on).

Wired into `All.agda` adjacent to `RankLexSlice3`; pinned in
`Ordinal/Buchholz/Smoke.agda` under own block per CLAUDE.md
Working rules.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
@hyperpolymath hyperpolymath enabled auto-merge May 28, 2026 10:06
@github-actions
Copy link
Copy Markdown

🔍 Hypatia Security Scan

Findings: 74 issues detected

Severity Count
🔴 Critical 17
🟠 High 36
🟡 Medium 21

⚠️ Action Required: Critical security issues found!

View findings
[
  {
    "reason": "No test directory or test files found",
    "type": "no_tests",
    "file": "/home/runner/work/echo-types/echo-types",
    "action": "flag",
    "rule_module": "honest_completion",
    "severity": "high",
    "deduction": 20
  },
  {
    "reason": "Issue in codeql.yml",
    "type": "missing_workflow",
    "file": "codeql.yml",
    "action": "create",
    "rule_module": "workflow_audit",
    "severity": "high"
  },
  {
    "reason": "Issue in secret-scanner.yml",
    "type": "missing_workflow",
    "file": "secret-scanner.yml",
    "action": "create",
    "rule_module": "workflow_audit",
    "severity": "high"
  },
  {
    "reason": "Issue in agda.yml",
    "type": "unknown",
    "file": "agda.yml",
    "action": "flag",
    "rule_module": "workflow_audit",
    "severity": "medium"
  },
  {
    "reason": "Issue in agda.yml",
    "type": "unknown",
    "file": "agda.yml",
    "action": "flag",
    "rule_module": "workflow_audit",
    "severity": "medium"
  },
  {
    "reason": "Issue in governance.yml",
    "type": "unknown",
    "file": "governance.yml",
    "action": "flag",
    "rule_module": "workflow_audit",
    "severity": "medium"
  },
  {
    "reason": "Issue in hypatia-scan.yml",
    "type": "unknown",
    "file": "hypatia-scan.yml",
    "action": "flag",
    "rule_module": "workflow_audit",
    "severity": "medium"
  },
  {
    "reason": "Issue in mirror.yml",
    "type": "unknown",
    "file": "mirror.yml",
    "action": "flag",
    "rule_module": "workflow_audit",
    "severity": "medium"
  },
  {
    "reason": "Issue in scorecard.yml",
    "type": "unknown",
    "file": "scorecard.yml",
    "action": "flag",
    "rule_module": "workflow_audit",
    "severity": "medium"
  },
  {
    "reason": "Agda postulate assumes without proof -- potential soundness hole (1 occurrences, CWE-704)",
    "type": "agda_postulate",
    "file": "/home/runner/work/echo-types/echo-types/tutorial/epistemic_erasure/EpistemicErasure.agda",
    "action": "flag",
    "rule_module": "code_safety",
    "severity": "critical"
  }
]

Powered by Hypatia Neurosymbolic CI/CD Intelligence

@hyperpolymath hyperpolymath merged commit 791bb70 into main May 28, 2026
13 checks passed
@hyperpolymath hyperpolymath deleted the session/rank-lex-jb-scaffold branch May 28, 2026 10:08
hyperpolymath added a commit that referenced this pull request May 28, 2026
…ay's closed cases

Ships the deliberately-narrowed `_<ᵇ⁻_` umbrella covering ALL CASES
THAT CLOSE AT THE RANK-POW LEVEL TODAY:

* 10 constructors via `_<ᵇ⁰_` inheritance (the
  `Ordinal.Buchholz.RankMonoUmbrella.rank-pow-mono-<ᵇ⁰` workhorse).
* `<ᵇ-+1` joint-bplus UNDER STRICT HEAD via `_<ᵇ¹_-+1-+` (the
  Slice 3 closure landed in PR #142).

New module `Ordinal.Buchholz.RankMonoUmbrellaSlice4`:

* `_<ᵇ⁻ⁿ_` — narrowed WfCNF-restricted relation bundling source-WfCNF
  + target-WfCNF + `_<ᵇ¹_` derivation.
* `<ᵇ⁻ⁿ-from-<ᵇ⁰`, `<ᵇ⁻ⁿ-+1-+` — constructor-level embeddings.
* `rank-pow-mono-<ᵇ⁻ⁿ` — THE NARROWED UMBRELLA, forwards via
  `rank-pow-mono-<ᵇ¹`.
* `<ᵇ⁻ⁿ-shortfall-{lex,equal-head}` — matched-negative `⊤`-aliases
  pinning the two `<ᵇ`-constructor-level shortfalls with explicit
  in-file pointers to where each closure lives (lex-rank level for
  `<ᵇ-ψΩ≤`; rank-lex-jb pivot for `<ᵇ-+1` at equal-head, PR #147
  scaffold).

Honest scope: this is the narrowed-but-real umbrella.  The two
shortfalls are not patched here; they are pinned as `grep`-able
markers so the next session can extend the umbrella without
re-deriving the analysis.  The (a)+(b)+(c) assembly for the
equal-head closure is the multi-PR follow-on documented in
`RankLexJointBplus.agda`'s preamble.

Wired into `All.agda` adjacent to `RankMonoUmbrellaSlice3`; pinned
in `Ordinal/Buchholz/Smoke.agda` under own block per CLAUDE.md
Working rules.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
hyperpolymath added a commit that referenced this pull request May 28, 2026
…ay's closed cases (#149)

## Summary

Deliberately-narrowed `_<ᵇ⁻_` umbrella covering ALL cases that close at
the rank-pow level today: 10 inherited via `_<ᵇ⁰_` + 1 strict-head
joint-bplus via `_<ᵇ¹_-+1-+`.

New module `Ordinal.Buchholz.RankMonoUmbrellaSlice4`:

* `_<ᵇ⁻ⁿ_` — narrowed WfCNF-restricted relation bundling source-WfCNF +
target-WfCNF + `_<ᵇ¹_` derivation.
* `<ᵇ⁻ⁿ-from-<ᵇ⁰`, `<ᵇ⁻ⁿ-+1-+` — constructor-level embeddings.
* `rank-pow-mono-<ᵇ⁻ⁿ` — THE NARROWED UMBRELLA.
* `<ᵇ⁻ⁿ-shortfall-{lex,equal-head}` — `⊤`-aliases for the two shortfalls
(greppable).

## Honest scope

Two `<ᵇ`-constructor shortfalls pinned but NOT closed:

* `<ᵇ-ψΩ≤` boundary — closes only at the lex-rank level
(`RankLex.rank-mono-<ᵇ-ψΩ≤-lex`); rank-pow-level closure structurally
impossible.
* `<ᵇ-+1` at equal-head — gated on the rank-lex-jb pivot (PR #147
scaffold); next-session (a)+(b)+(c) assembly.

## Test plan

- [x] `agda --library-file=...
proofs/agda/Ordinal/Buchholz/RankMonoUmbrellaSlice4.agda` EXIT 0
- [x] `proofs/agda/Ordinal/Buchholz/Smoke.agda` EXIT 0
- [x] `scripts/kernel-guard.sh` PASS
- [x] Wired into `All.agda` adjacent to `RankMonoUmbrellaSlice3`
- [x] Pinned in `Ordinal/Buchholz/Smoke.agda` under own block per
CLAUDE.md Working rules

🤖 Generated with [Claude Code](https://claude.com/claude-code)
hyperpolymath added a commit that referenced this pull request May 28, 2026
…ils policy (#152)

Four narrative-alignment edits after the post-compact session:

- **CONTRIBUTING.md**: add Pre-merge checklist item #5 documenting
\`tools/check-guardrails.sh\` (the CI-enforced no-postulates + mandatory
\`--safe --without-K\` policy across \`proofs/agda/**\`). PR #148
(postulated \`EchoImageFactorizationPropPostulated\` consumer) was
closed precisely because this guardrail was not discoverable in
user-facing docs. **Critical** — addresses a real contributor gotcha.
- **docs/echo-types/MAP.adoc**: index the two new Buchholz modules from
this session — \`RankLexJointBplus\` (PR #147) and
\`RankMonoUmbrellaSlice4\` (PR #149) — alongside the existing Slice 3
trio.
- **roadmap.adoc**: refresh Lane 3 status — Slice 3 + Slice 4 both
LANDED 2026-05-28 with the two constructor-level shortfalls pinned as
\`⊤\`-aliases; bottleneck moves to unbudgeted \`_<ᵇʳᶠ_\` global WF.
- **README.md**: Ordinal track one-line ledger gains 2026-05-28 Slice 3
+ Slice 4 entry.

Pure narrative — no Agda touched, no proof obligations changed.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
hyperpolymath added a commit that referenced this pull request May 30, 2026
…charge (#165)

## Summary

Advances the rank-lex-jb pivot's `(a)+(b)+(c)` assembly plan beyond the
(a) primitive that PR #147 shipped. Three primitives added to
\`Ordinal.Buchholz.RankLexJointBplus\` and pinned in
\`Ordinal/Buchholz/Smoke.agda\`. Zero postulates, \`--safe
--without-K\`, no funext.

## Three primitives

| Primitive | Type | Role |
|---|---|---|
| \`rank-lex-jb-strict-first\` | \`rank-pow (bplus _ _) <′ rank-pow
(bplus _ _) → rank-lex-jb _ <lex rank-lex-jb _\` | Leg (b) primitive;
one-line via \`<lex-first\` |
| \`leftmost-α-strict-from-bpsi-source\` | \`α <ᵇ⁰ β → leftmost-α (bplus
(bpsi ν α) x₂) <′ leftmost-α (bplus (bpsi ν β) y₂)\` | Consumer helper
composing \`leftmost-α-{bplus,bpsi}\` with \`rank-pow-mono-<ᵇ⁰\` |
| \`rank-lex-jb-bpsi-at-equality\` | \`first-eq → α <ᵇ⁰ β → rank-lex-jb
_ <lex rank-lex-jb _\` | Named theorem closing the
bpsi-source-at-equality sub-case at rank-lex-jb level, gated on first-eq
hypothesis |

## Where this sits in the assembly

Per the PR #147 module preamble's \`(a)+(b)+(c)\` plan (see
\`RankLexJointBplus.agda\` preamble):

- **(a) equal-first lex-second leg** — CLOSED in PR #147
(\`rank-lex-jb-strict-second-at-equal-first\`).
- **(b) strict-first lex-first leg** — primitive CLOSED here;
consumer-side derivation of \`rank-pow (bplus _ _) <′ rank-pow (bplus _
_)\` remains the multi-PR ordinal-arithmetic challenge.
- **(c) first-component trichotomy** — STILL OPEN (Ord-valued
decidability bridge in \`Phase13\` not yet attempted).
- **Assembly into full \`<ᵇ-+1\`-at-equal-head headline** = multi-PR
follow-on, still gated on (c).

This slice records that every other discharge step composes cleanly (the
bpsi sub-case now ships as a named theorem under the first-eq
hypothesis); resolving the gating obligations unblocks the headline
mechanically.

## Honest scope (preserved in module preambles)

- The trivial \`<lex-first\` shape of primitive (1) does **not** mean
leg (b) is "done" — the consumer plumbing is the hard part. Both
pre-identified unblock routes (additive-principal closure on a generic
sum, strict-left-mono of \`_⊕_\`) are CHECKED-REFUTED in PR #146.
- Primitive (2) is \`_<ᵇ⁰_\`-parameterised, not \`_<ᵇ_\`-parameterised.
Lifting to full \`_<ᵇ_\` requires the joint-bplus closure that this very
pivot was designed to attack.
- Primitive (3) requires the first-eq hypothesis as input; consumer-side
derivation is the gating obligation.

## Local verification

- \`agda -i proofs/agda
proofs/agda/Ordinal/Buchholz/RankLexJointBplus.agda\` — clean.
- \`agda -i proofs/agda proofs/agda/Ordinal/Buchholz/Smoke.agda\` —
clean, exit 0.
- \`agda -i proofs/agda proofs/agda/Smoke.agda\` — clean, exit 0.
- \`agda -i proofs/agda proofs/agda/All.agda\` — clean, exit 0.
- \`bash tools/check-guardrails.sh proofs/agda\` — 160 modules pass.
- \`sh scripts/kernel-guard.sh\` — PASS.

## Test plan

- [x] All four Agda lanes typecheck locally.
- [x] Three new primitives pinned in Buchholz Smoke.
- [x] Foundation guardrail + kernel-guard pass.
- [ ] CI: \`check\` + \`cold-check\` + governance lanes green.
- [ ] Auto-merge on green.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
hyperpolymath added a commit that referenced this pull request May 30, 2026
…ivation (#166)

## Summary

Follow-on to PR #165's (b) primitive. Adds the **(c) trichotomy** data
type and the **consumer-side first-eq derivation** tools the (a)+(b)+(c)
assembly plan calls for, plus a named theorem fully closing the
bpsi-source-at-equal-head sub-case at the rank-lex-jb level GIVEN only a
tail-rank-equality discharge. Zero postulates, \`--safe --without-K\`,
no funext.

## What lands

### Consumer-side first-eq derivation (2 primitives)

The DEFINITIONAL fact underlying the closure: \`rank-pow (bplus x y) =
rank-pow x ⊕ rank-pow y\` (\`RankPow.rank-pow-bplus\`, \`refl\`). So
first-eq REDUCES to a conjunction of summand-equalities via \`cong₂
_⊕_\`.

| Name | Role |
|---|---|
| \`rank-pow-bplus-eq-from-summands\` | Generic \`cong₂ _⊕_\` helper |
| \`first-eq-from-bpsi-source-at-equal-head\` | Specialised: bpsi-source
at equal head (left-rank-eq is \`refl\`); reduces consumer-side first-eq
to **tail-rank-equality only** |

### (c) Trichotomy data type + dispatchers (5 primitives)

Brouwer ordinals are NOT decidably ordered in general (\`Ord\` carries
\`olim f\` over arbitrary ℕ → Ord functions), so a universal trichotomy
on \`rank-pow (bplus _ _)\` is unattainable under \`--safe --without-K\`
without postulates. The TRACTABLE narrowing is a STRUCTURAL trichotomy
data type that records the strict / equal cases the consumer can derive.

| Name | Role |
|---|---|
| \`BplusFirstTri x₁ x₂ y₁ y₂\` | Data type with two constructors:
\`bplus-tri-strict\` (rank-strict) and \`bplus-tri-equal\` (rank-equal)
|
| \`bplus-tri-from-strict\` / \`bplus-tri-from-equal\` | Wrapper
constructors lifting consumer-derived witnesses into the trichotomy |
| \`dispatch-trichotomy-to-<lex\` | Assembly headline: consumes a
trichotomy + leftmost-α strict witness, produces \`<lex\` at rank-lex-jb
level. Strict → \`<lex-first\` via (b) primitive (#165); equal →
\`<lex-second\` via (a) primitive (#147). |

### Named theorem: bpsi-source-at-equal-head fully discharged (1)

| Name | Type |
|---|---|
| \`rank-lex-jb-bpsi-equal-head-from-tail-eq\` | \`rank-pow x₂ ≡
rank-pow y₂ → α <ᵇ⁰ β → rank-lex-jb (bplus (bpsi ν α) x₂) <lex
rank-lex-jb (bplus (bpsi ν β) y₂)\` |

The tail-rank-equality gate is **THE SAME structural obligation** that
the ψ-rank-level closure
(\`RankLexSlice3.rank-adm-bpsi-strict-at-equality\`) carries. Resolving
that one structural blocker unblocks BOTH the ψ-rank-level and the
bplus-chain-level closures mechanically.

## Honest scope

- The Brouwer-arithmetic blocker (strict-left-mono of \`_⊕_\` +
additive-principal closure on generic sums, both CHECKED-REFUTED in PR
#146) means **strict-first via strict-left-rank** is structurally
unreachable at the bplus-chain level. Strict-first via strict-head-Ω
already lands in PR #141 / \`<ᵇ¹-+1-+\`.
- Equal-first beyond the bpsi-source-at-equal-head case is open multi-PR
research; the trichotomy data type leaves room for future dispatchers
without committing to any specific closure path.
- \`dispatch-trichotomy-to-<lex\` shows the assembly composes
mechanically — the structural ordinal-arithmetic obligation is the SOLE
remaining gating, and it's pushed to the precise consumer call site
rather than scattered across the proof.

## (a)+(b)+(c) assembly status after this PR

Per PR #147's preamble plan:

| Leg | Status |
|---|---|
| (a) equal-first lex-second | CLOSED in #147 |
| (b) strict-first lex-first primitive | CLOSED in #165 (one-liner via
\`<lex-first\`) |
| (c) first-component trichotomy | CLOSED HERE as a structural data type
+ dispatchers |
| Consumer-side first-eq derivation | CLOSED HERE for the
bpsi-source-at-equal-head case (parameterised on tail-rank-eq) |
| Full assembly headline | \`rank-lex-jb-bpsi-equal-head-from-tail-eq\`
named theorem closes the bpsi sub-case given **only** tail-rank-eq |

The bplus-chain-level rank-mono umbrella over **all** 13 \`_<ᵇ_\`
constructors is still gated on (i) tail-rank-equality discharge
(structural ordinal-arithmetic work) AND (ii) the equal-first dispatch
beyond the bpsi-source case (open research). Per the SLICE 4 narrowing
(\`RankMonoUmbrellaSlice4\`), the \`<ᵇ⁻ⁿ-shortfall-equal-head\`
matched-negative remains.

## Local verification

- \`agda -i proofs/agda
proofs/agda/Ordinal/Buchholz/RankLexJointBplus.agda\` — clean.
- \`agda -i proofs/agda proofs/agda/Ordinal/Buchholz/Smoke.agda\` —
clean, exit 0.
- \`agda -i proofs/agda proofs/agda/Smoke.agda\` — clean, exit 0.
- \`agda -i proofs/agda proofs/agda/All.agda\` — clean, exit 0.
- \`bash tools/check-guardrails.sh proofs/agda\` — 160 modules pass.
- \`sh scripts/kernel-guard.sh\` — PASS.

All eleven new names pinned in \`Ordinal/Buchholz/Smoke.agda\`.

## Test plan

- [x] All Agda lanes typecheck locally.
- [x] New names pinned in Buchholz Smoke.
- [x] Foundation guardrail + kernel-guard pass.
- [ ] CI: \`check\` + \`cold-check\` + governance lanes green.
- [ ] Auto-merge on green.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
hyperpolymath added a commit that referenced this pull request May 30, 2026
)

## Summary

Mechanises the **Path-3 alternative** identified in PR #166's closing
note: enrich the SOURCE RULE rather than the rank function. New module
\`Ordinal.Buchholz.RankMonoSameLeft\` introduces a \`<ᵇ⁰\`-grounded
same-left joint-bplus constructor and closes its rank-pow obligation in
**one line**, bypassing the rank-lex-jb pivot's first-eq derivation
entirely for the same-literal-left sub-case. Zero postulates, \`--safe
--without-K\`, no funext.

## The structural insight tested

PR #166's closing note flagged Path-3 as a possible reframing:

> The source rule may need enrichment, not the rank function.
> For a valid \`<ᵇ-+1\`-at-equal-head derivation under WfCNF, rank-mono
soundness *requires* tail-rank-strict. Path-3 alternative: enrich the
source side instead — promote \`_<ᵇ_\` to carry a \`<ᵇ⁺-+2\`-style
same-left constructor with both head-eq and tail-strict premises baked
in.

This PR mechanises that intuition concretely. **Result: WORKS.**

## Headlines

| Name | Role |
|---|---|
| \`_<ᵇ⁺²_\` | Extended relation: \`<ᵇ⁺²-from-<ᵇ⁰\` embeds 10 closed
cases + \`<ᵇ⁺²-same-left\` adds the source-rule enrichment |
| \`rank-pow-mono-<ᵇ⁺²\` | Two-case structural recursion: each case ONE
LINE |
| \`rank-pow-mono-same-left\` | Direct lemma showing the same-left case
without routing through embedding |

## Path-3 vs rank-lex-jb (complementary, not subsuming)

| Sub-case | Path | Closure |
|---|---|---|
| Same LITERAL left (\`bplus x s\` vs \`bplus x t\`) | **Path-3 (this
PR)** | One-line via \`rank-pow-bplus-right-mono\` |
| Same head-Ω, different left syntax (\`bpsi ν α\` vs \`bOmega ν\`) |
rank-lex-jb (#147+#165+#166) | Multi-step: leftmost-α + first-eq +
\`<lex-second\` |

The same-left case is UNREACHABLE in K-free \`_<ᵇ_\` (would require
\`<ᵇ-irrefl\` violation via \`<ᵇ-+1 (x <ᵇ x)\`); reachable only in the
extended \`_<ᵇ⁺_\` of \`Ordinal.Buchholz.OrderExtended\` via \`<ᵇ⁺-+2\`.
This prototype narrows the tail premise to \`_<ᵇ⁰_\` to keep the closure
inductively grounded.

The K-restriction does NOT bite at constructor formation (only at
pattern-match elimination), so the same-binder \`<ᵇ⁺²-same-left\`
constructor is fine under \`--safe --without-K\`.

## Honest scope

- Does NOT prove well-foundedness of \`_<ᵇ⁺²_\` — separate from
rank-mono; would need a Brouwer-rank embedding (the rank function here
provides the seed).
- Does NOT subsume rank-lex-jb for the cross-head case — Path-3 and
rank-lex-jb are complementary.
- Does NOT extend the tail premise to \`_<ᵇ¹_\` — composes mechanically
via \`rank-pow-mono-<ᵇ¹\` but kept out of the prototype for minimality.
- Does NOT wrap in WfCNF endpoints (à la \`_<ᵇ⁻ⁿ_\` from Slice 4) — left
for downstream consumers.

## Implication confirmed

PR #166's #3 implication holds mechanically: enriching the source rule
is structurally simpler than the rank-function enrichment for this
scenario. The one-line closure here contrasts with the multi-PR
rank-lex-jb assembly chain. This suggests the **future bplus-chain
rank-mono umbrella may want to be designed as a UNION of source-rule
extensions** (Path-3 style for cleanly-decomposable cases) rather than a
single enriched rank function (rank-lex-jb style for cross-head cases).

## Local verification

- \`agda -i proofs/agda
proofs/agda/Ordinal/Buchholz/RankMonoSameLeft.agda\` — clean.
- \`agda -i proofs/agda proofs/agda/Ordinal/Buchholz/Smoke.agda\` —
clean, exit 0.
- \`agda -i proofs/agda proofs/agda/Smoke.agda\` — clean, exit 0.
- \`agda -i proofs/agda proofs/agda/All.agda\` — clean, exit 0.
- \`bash tools/check-guardrails.sh proofs/agda\` — **161 modules** pass
(one new).
- \`sh scripts/kernel-guard.sh\` — PASS.

Five new names pinned in \`Ordinal/Buchholz/Smoke.agda\` under a new
\`RankMonoSameLeft\` \`using\` block.

## Test plan

- [x] Module typechecks under \`--safe --without-K\` with zero
postulates.
- [x] Full suite + Smoke remain green with the new module wired in.
- [x] Foundation guardrail + kernel-guard pass with 161 modules.
- [ ] CI: \`check\` + \`cold-check\` + governance lanes green.
- [ ] Auto-merge on green.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
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.

1 participant