Skip to content

proof(Slice 3+4 Route A): (b) lex-first primitive + bpsi sub-case discharge#165

Merged
hyperpolymath merged 1 commit into
mainfrom
session/slice-3-route-a-strict-first
May 30, 2026
Merged

proof(Slice 3+4 Route A): (b) lex-first primitive + bpsi sub-case discharge#165
hyperpolymath merged 1 commit into
mainfrom
session/slice-3-route-a-strict-first

Conversation

@hyperpolymath
Copy link
Copy Markdown
Owner

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 ordinal(buchholz): rank-lex-jb scaffold — parallel rank with richer bplus second component #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 brouwer(arithmetic): checked refutations of strict-left-mono of _⊕_ and additive-principal closure on generic sums #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

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

🤖 Generated with Claude Code

…charge

Extends `Ordinal.Buchholz.RankLexJointBplus` with three primitives
advancing the rank-lex-jb pivot's (a)+(b)+(c) assembly plan beyond
the (a) primitive that PR #147 shipped.  No structural commitments,
no funext, zero postulates, `--safe --without-K` throughout.

## Three primitives added

1. `rank-lex-jb-strict-first` (leg (b), trivial at primitive level)
   — given `rank-pow (bplus x₁ x₂) <′ rank-pow (bplus y₁ y₂)`,
   fires `<lex-first`.  One-line proof.  The load-bearing content
   is consumer-side derivation of the hypothesis, which remains
   the multi-PR ordinal-arithmetic challenge (both pre-identified
   unblock routes — additive-principal closure on a generic sum,
   strict-left-mono of `_⊕_` — CHECKED-REFUTED in PR #146).
   Shipping the primitive separates trivial lex-rank wiring from
   the structural ordinal-arithmetic blocker.

2. `leftmost-α-strict-from-bpsi-source` (consumer helper) — given
   `α <ᵇ⁰ β` on the ψ-arguments, derives `leftmost-α (bplus
   (bpsi ν α) x₂) <′ leftmost-α (bplus (bpsi ν β) y₂)`.  Composes
   `leftmost-α-bplus` + `leftmost-α-bpsi` (both definitional) with
   `RankMonoUmbrella.rank-pow-mono-<ᵇ⁰`.  Parameterised in
   `_<ᵇ⁰_` (10-constructor umbrella) — the bpsi sub-case requires
   no constructor `_<ᵇ⁰_` doesn't already have.

3. `rank-lex-jb-bpsi-at-equality` (named theorem) — composition
   of `rank-lex-jb-strict-second-at-equal-first` (PR #147, leg (a))
   with `leftmost-α-strict-from-bpsi-source`.  Given the
   FIRST-COMPONENT EQUALITY (consumer-derived, gating obligation)
   plus the source-side `α <ᵇ⁰ β`, fires `<lex-second` at equal
   first components with the leftmost-α strict witness.  Closes
   the bpsi-source-at-equality sub-case at the rank-lex-jb level,
   parallel to `RankLexSlice3.rank-lex-bpsi-strict-at-equality`'s
   role for `rank-lex`.

## Where this sits in the assembly

Per the PR #147 module preamble's `(a)+(b)+(c)` plan:
- (a) equal-first lex-second leg — CLOSED in PR #147.
- (b) strict-first lex-first leg — primitive CLOSED here;
  consumer-side derivation of `rank-pow (bplus _ _) <′ rank-pow
  (bplus _ _)` remains the multi-PR challenge.
- (c) first-component trichotomy — STILL OPEN (Ord-valued
  decidability bridge in `Phase13` not yet attempted; `with`-based
  case-analysis over `_<′_` / `_≡_` is the sketched alternative).
- 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 notes (preserved in module)

- The trivial `<lex-first` shape of primitive (1) does not mean
  leg (b) is "done" — the consumer plumbing is the hard part.
- Primitive (2) is `_<ᵇ⁰_`-parameterised, not `_<ᵇ_`-parameterised.
  Lifting to full `_<ᵇ_` requires the joint-bplus closure that
  the rank-lex-jb pivot was designed to attack.
- Primitive (3) requires the first-eq hypothesis as input;
  consumer-side derivation is documented as still-gating per
  the file preamble.

## 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 three primitives pinned in `Ordinal/Buchholz/Smoke.agda`
under the existing `RankLexJointBplus` `using` block.

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

🔍 Hypatia Security Scan

Findings: 58 issues detected

Severity Count
🔴 Critical 17
🟠 High 22
🟡 Medium 19

⚠️ 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": "Action rpolymath/standards/.github/workflows/governance-reusable.yml@main\n needs attention",
    "type": "unpinned_action",
    "file": "governance.yml",
    "action": "pin_sha",
    "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 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"
  }
]

Powered by Hypatia Neurosymbolic CI/CD Intelligence

@hyperpolymath hyperpolymath merged commit f21c62f into main May 30, 2026
12 of 13 checks passed
@hyperpolymath hyperpolymath deleted the session/slice-3-route-a-strict-first branch May 30, 2026 13:50
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>
hyperpolymath added a commit that referenced this pull request May 30, 2026
…ns (#168)

## Summary

Realises the **architectural recommendation** from PR #167's closing
note: the future bplus-chain rank-mono umbrella shipped as a UNION OF
SOURCE-RULE EXTENSIONS rather than a single enriched rank function.
**Zero new proof obligations**; purely structural composition via Sum +
\`[_,_]\` mediator. \`--safe --without-K\`, no postulates, no funext.

## What the union umbrella ships

| Name | Type | Role |
|---|---|---|
| \`_<ᵇᵘ_\` | \`BT → BT → Set\` | Disjoint sum of \`_<ᵇ¹_\` (Slice 3)
and \`_<ᵇ⁺²_\` (Path-3) |
| \`rank-pow-mono-<ᵇᵘ\` | \`∀ {x y} → x <ᵇᵘ y → rank-pow x <′ rank-pow
y\` | Coproduct mediator via \`[_,_]\` — **ONE LINE** |
| \`<ᵇᵘ-from-<ᵇ¹\` / \`<ᵇᵘ-from-<ᵇ⁺²\` / \`<ᵇᵘ-from-<ᵇ⁰\` (+symmetric) |
embeddings | Convenience injections |

## The architectural design

PR #167's closing observation:

> 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).

This PR mechanises that recommendation. Each contributing extension
keeps its own proof obligation local; the union dispatches via case
analysis on which extension witnesses the relation. The mediator is \`[
rank-pow-mono-<ᵇ¹ , rank-pow-mono-<ᵇ⁺² ]\` — a single \`[_,_]\` over the
existing per-extension umbrellas.

## Why this architectural shape (three observations)

1. **Different sub-cases prefer different rank-mono machinery.**
Strict-head joint-bplus closes via head-Ω + \`ω-rank-pow-succ\`;
same-left closes via \`rank-pow-bplus-right-mono\`; cross-head
rank-equal closes at LEX-RANK via rank-lex-jb. No single rank function
dominates.

2. **Source-rule enrichment is structurally simpler than rank-function
enrichment** (Path-3 verdict, PR #167). The consumer-side first-eq
derivation that rank-lex-jb requires (PR #166 (c) trichotomy + first-eq)
gets bypassed entirely when the source rule carries the discriminator.

3. **Union of extensions scales.** Every new sub-case ships as its own
extension module with its own rank-mono theorem, then unions in
mechanically. No interference between extensions; closure is local.

## Extension recipe (for future contributors)

Documented in the module preamble. To add a new source-rule extension:

1. Define the relation + rank-pow-mono in its own module (use
\`RankMonoSameLeft\` as canonical template).
2. Re-export through \`Ordinal/Buchholz/Smoke.agda\` with its own
\`using\` block.
3. Update this module to extend \`_<ᵇᵘ_\` with the new disjunct and
extend \`rank-pow-mono-<ᵇᵘ\` with the new case via \`[_,_]\`.

Both edits mechanical; no new proof obligations.

## Honest scope (preserved in module preamble)

- Does NOT wrap with WfCNF endpoints (à la
\`RankMonoUmbrellaSlice4._<ᵇ⁻ⁿ_\`).
- Does NOT include rank-lex-jb discharge — cross-head rank-equal case
lives at LEX-RANK level, different rank-relation. Union is over
\`rank-pow <′\` discharges only.
- Does NOT prove well-foundedness of the union — orthogonal to
rank-mono.

## Slice 3+4 Route A arc summary (4 PRs total)

After this PR the session arc is closed:

| PR | Role |
|---|---|
| #165 | (b) \`<lex-first\` primitive + bpsi sub-case discharge |
| #166 | (c) trichotomy data type + first-eq derivation |
| #167 | Path-3 prototype (same-left source-rule extension) |
| **THIS PR** | **RankMonoUnion** (architectural realisation) |

The full bplus-chain rank-mono umbrella over all 13 \`_<ᵇ_\`
constructors is still gated on (i) tail-rank-equality discharge for the
bpsi-source-at-equal-head case AND (ii) the cross-head rank-equal case
via rank-lex-jb's structural research; **neither is closed by this PR**.
The architecture is now in place for those closures to plug in
mechanically.

## Local verification

- All four Agda lanes typecheck clean, exit 0.
- \`bash tools/check-guardrails.sh proofs/agda\` — **162 modules** pass.
- \`sh scripts/kernel-guard.sh\` — PASS.

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

## Test plan

- [x] All Agda lanes typecheck under \`--safe --without-K\` with zero
postulates.
- [x] Foundation guardrail + kernel-guard pass with 162 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>
hyperpolymath added a commit that referenced this pull request May 30, 2026
## Summary

**Closes Gate 2 of the Slice 3+4 Route A session arc.** Derives
\`WellFounded _<ᵇᵘ_\` mechanically from \`rank-pow-mono-<ᵇᵘ\` (#168) and
the existing \`wf-<′\` via the standard Subrelation + InverseImage
transport pattern documented in \`Ordinal.Buchholz.RankBrouwer\`'s
preamble. **Zero new proof obligations**; purely structural. \`--safe
--without-K\`, no postulates, no funext.

## The rank-embedding recipe

```agda
wf-rank-pow-pullback : WellFounded (λ x y → rank-pow x <′ rank-pow y)
wf-rank-pow-pullback = On.wellFounded rank-pow wf-<′

wf-<ᵇᵘ : WellFounded _<ᵇᵘ_
wf-<ᵇᵘ = Subrelation.wellFounded rank-pow-mono-<ᵇᵘ wf-rank-pow-pullback
```

Two steps:

1. \`On.wellFounded\` (= \`InverseImage.wellFounded\`) lifts
well-foundedness of \`_<′_\` on \`Ord\` to the pullback \`_<′_ on
rank-pow\` on \`BT\`.
2. \`Subrelation.wellFounded\` transports well-foundedness from the
pullback to \`_<ᵇᵘ_\`, consuming \`rank-pow-mono-<ᵇᵘ\` as the witness
that \`_<ᵇᵘ_\` is a sub-relation of the pullback.

The pattern is documented at \`RankBrouwer.agda:55-56\`.

## Slice 3+4 Route A gate status after this PR

| Gate | Status |
|---|---|
| 1 — tail-rank-equality discharge (cross-head rank-equal case) | open
(structural blocker) |
| **2 — well-foundedness of \`_<ᵇᵘ_\`** | **CLOSED HERE** |
| 3 — Path-4 + further source-rule extensions | open (future-work,
mechanical) |

## What this does NOT do

- Does NOT prove well-foundedness of the WfCNF-narrowed \`_<ᵇᵘⁿ_\`
(#169) separately — follows by the same Subrelation transport from
\`wf-<ᵇᵘ\` via the canonical \`<ᵇᵘⁿ → <ᵇᵘ\` projection. Left for a thin
follow-on if specifically needed.
- Does NOT add a Brouwer-rank embedding stronger than \`rank-pow\` —
\`rank-pow\` is K-free + lands in \`Ord\` + already discharges the WF
transport.

## Local verification

- All four Agda lanes typecheck clean, exit 0.
- \`bash tools/check-guardrails.sh proofs/agda\` — 163 modules pass.
- \`sh scripts/kernel-guard.sh\` — PASS.

Two new names pinned in \`Ordinal/Buchholz/Smoke.agda\`:
\`wf-rank-pow-pullback\`, \`wf-<ᵇᵘ\`.

## Slice 3+4 Route A session arc (6 PRs)

| PR | Layer |
|---|---|
| #165 | rank-lex-jb (b) primitive |
| #166 | rank-lex-jb (c) trichotomy + first-eq |
| #167 | Path-3 same-left source-rule extension |
| #168 | RankMonoUnion architecture |
| #169 | WfCNF wrap of the union |
| **THIS PR** | **WF of the union (Gate 2 closure)** |

## Test plan

- [x] Module typechecks under \`--safe --without-K\` with zero
postulates.
- [x] Full suite + Smoke remain green with the new module wired in.
- [ ] 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
…171)

## Summary

Seam-analyst gigafan agent surfaced three documents enumerating the
ordinal-track work that referenced only the pre-2026-05-30 state.
Updates reflect the **rank-lex-jb (a)+(b)+(c) assembly completion**, the
**Path-3 source-rule enrichment**, the **RankMonoUnion architectural
realisation**, the **WfCNF wrap**, and the **Gate 2 (well-foundedness)
closure**.

## Files

| File | Update |
|---|---|
| \`docs/echo-types/MAP.adoc\` §"Ordinal" Proofs line | Extends the
per-module enumeration to mention the six new modules from PRs #165-#170
with their roles |
| \`roadmap.adoc\` Lane 3 close-out | Adds the "Slice 3+4 Route A 6-PR
arc" subsection with the (a)+(b)+(c) + Path-3 + union + WfCNF + WF
breakdown |
| \`docs/echo-types/buchholz-rank-obstruction.adoc\` per-constructor
verdict table | Updates the \`<ᵇ-+1\` row from "Slice 3 headline
remaining" to "closed for strict-head + literal-same-left sub-cases;
cross-head rank-equal (Gate 1) open with documented structural
blockers". Score footer revised to "12/13 at the per-case level" |

## Honest scope preserved

Documents what LANDED, not what's CLOSED-OPEN conceptually. The
\`<ᵇ-+1\` joint-bplus case now has **two of three sub-cases closed**
(strict-head + literal-same-left); the cross-head rank-equal sub-case
(Gate 1) is explicitly documented as still open with both pre-identified
unblock routes refuted in PR #146 AND the WfCNF-constraint refutation
also closed.

R-2026-05-18 retraction narrowings respected: no "graded comonad" /
"model-independence" / "universal property" / "conservativity
metatheorem" language added.

## Local verification

- \`bash tools/check-guardrails.sh proofs/agda\` — 163 modules pass (no
Agda touched; docs-only change).

## Test plan

- [x] No Agda touched; docs-only diff.
- [x] Foundation guardrail still passes.
- [ ] CI: 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

**Stacked on #168.** Mirrors \`RankMonoUmbrellaSlice4._<ᵇ⁻ⁿ_\`'s
WfCNF-bundling pattern over \`RankMonoUnion._<ᵇᵘ_\` from #168. Provides
the canonical-form invariant downstream Buchholz consumers need
alongside the rank-relation. Zero new proof obligations; \`--safe
--without-K\`, no postulates, no funext.

## What ships

| Name | Type | Role |
|---|---|---|
| \`_<ᵇᵘⁿ_\` | record (WfCNF + WfCNF + \`_<ᵇᵘ_\`) | WfCNF-narrowed union
relation |
| \`mk<ᵇᵘⁿ\` | record constructor | Bundling combinator |
| \`<ᵇᵘⁿ-from-<ᵇ⁰\` / \`<ᵇᵘⁿ-from-<ᵇ¹\` / \`<ᵇᵘⁿ-from-<ᵇ⁺²\` |
embeddings | Constructor-level uplifts under WfCNF endpoints |
| \`rank-pow-mono-<ᵇᵘⁿ\` | rank-mono theorem | One-liner forwarding
through bundled \`<ᵇᵘ-d\` |

## Architectural payoff preserved

The "union of extensions" pattern from #168 extends through the WfCNF
wrap automatically. Future contributors adding a new source-rule
extension \`_<ᵇⁿ_\`:

1. Edit \`RankMonoUnion\` to extend \`_<ᵇᵘ_\` with the new disjunct +
\`rank-pow-mono-<ᵇᵘ\` with the new case.
2. **This module updates AUTOMATICALLY** — no edit needed.

Per-extension proof work + structural composition. No proof obligations
multiply across the WfCNF boundary either.

## Slice 3+4 Route A session arc (5 PRs)

| PR | Layer |
|---|---|
| #165 | rank-lex-jb (b) primitive |
| #166 | rank-lex-jb (c) trichotomy + first-eq |
| #167 | Path-3 prototype (same-left source-rule extension) |
| #168 | RankMonoUnion (architecture) |
| **THIS PR** | **WfCNF wrap of the union** |

## Local verification

- All four Agda lanes typecheck clean, exit 0.
- \`bash tools/check-guardrails.sh proofs/agda\` — **163 modules** pass.
- \`sh scripts/kernel-guard.sh\` — PASS.

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

## Test plan

- [x] Module typechecks under \`--safe --without-K\` with zero
postulates.
- [x] Full suite + Smoke remain green with the new module wired in.
- [ ] CI: \`check\` + \`cold-check\` + governance lanes green.
- [ ] Auto-merge on green AFTER #168 merges (stacked).

🤖 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