Documentation

Q2Presentation.Induction.BlockRealizationAssembly

Generic helpers #

noncomputable def Q2Presentation.Induction.BlockR.torsorOfEquiv {G S : Type} [AddGroup G] (e : S ≃ G) :

A nonempty set equinumerous with a group is a torsor over it.

Equations
  • One or more equations did not get rendered due to their size.
Instances For
    noncomputable def Q2Presentation.Induction.BlockR.sigmaRestrict {ι : Type} {F : ι → Type} {P : ι → Prop} (hP : ∀ (i : ι), Nonempty (F i) → P i) :
    (i : ι) × F i ≃ (i : { i : ι // P i }) × F ↑i

    Restrict a sigma type to the support of its fibres.

    Equations
    • One or more equations did not get rendered due to their size.
    Instances For

      The cochain clauses and the torsor-data construction #

      (The former residual |Φ(K)| = 2 keep sec7_scalarCoverCountAgreement stood here; DELETED by the P8 surgery — audit/BLOCKR_P8_DESIGN.md §5.6. Its content is now derived through the R2–R5 children of the card-2 branch below, with the residual trust in the four coordinated keeps of Induction/BlockRecursionKeeps.lean.)

      Finite 𝔽₂ duality preserves cardinality.

      The block character space is the consumer invariant-dual space: Bstar.XR = conjInvDuals (xrKernel) — the two-sided XRTransport computation (conjOnR_eq_conjEndN_inv at y⁻¹).

      The pinned local obstruction in block spelling: the local-duality keep's bundled witness (localObstruction, q2_localduality_general), transported along blockXR_eq_conjInvDuals — the verbatim mirror of blockObstructionA.

      Equations
      • One or more equations did not get rendered due to their size.
      Instances For

        The invariant dual attached to a character of the block obstruction space: double-dual reflexivity (Module.evalEquiv at the finite 𝔽₂ space 𝒳_R) followed by the blockXR_eq_conjInvDuals transport — the χ ↔ λ leg of lem:obstructionseparation.

        Equations
        • One or more equations did not get rendered due to their size.
        Instances For

          A nonzero character attaches a nonzero invariant dual (evalEquiv.symm is injective and the inclusion cast is value-preserving).

          Candidate per-character fibres are cover-lift counts (lem:obstructionseparation, candidate half, at λ := blockCharDual χ): for χ ≠ 0 the χ-fibre of the canonical candidate obstruction is the set of child maps that weakly lift through B_λ.

          One source's torsor bijection from the engine.

          Equations
          • One or more equations did not get rendered due to their size.
          Instances For

            The per-character strata children (P8-lite, |Φ(K)| ≥ 4 branch) #

            For each nonzero character χ of the block obstruction space, the exact-image strata of the scalar cover B_{λ(χ)} (λ(χ) := blockCharDual χ) form a block of engine children; blockChildrenTail concatenates the blocks over a fixed enumeration of the nonzero characters, and the counting formula reads the χ-block back positionally (splitByLengths).

            @[reducible, inline]

            The nonzero characters of the block obstruction space — the index type of the per-character strata blocks.

            Equations
            • One or more equations did not get rendered due to their size.
            Instances For

              A fixed enumeration of the nonzero characters; the position of χ is the index of its strata block in the children tail.

              Equations
              Instances For

                The block position of a character, as a total function (0 at χ = 0, where the counting formula never reads it).

                Equations
                Instances For

                  The strata block of the nonzero character c: the exact-image strata of the scalar cover at λ = blockCharDual c.1, as a list of framed pairs.

                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For

                    Every member of the c-block is strictly smaller once 4 ≤ |Φ(K)| (the per-child witness for the engine's small field; no stratum is assumed smaller — all are proven so through the uniform bound ≤ 2·(xrChild measure) < parent measure).

                    The full children tail: the concatenation of the strata blocks over the fixed enumeration of the nonzero characters.

                    Equations
                    • One or more equations did not get rendered due to their size.
                    Instances For

                      Mapping the children tail commutes with the block structure (List.map_flatMap, recorded at the tail's definitional unfolding).

                      Chunk readout: the c-chunk of the mapped children tail (split by the raw block lengths) is the mapped c-strata block.

                      The card-2 R2–R5 children layer (audit/BLOCKR_P8_DESIGN.md §4) #

                      For |Φ(K)| = 2 the children of one nonzero character χ are a TWO-LEVEL block: the R3 strata of every PROPER image stratum (enumerated by V5's properIdx), then — on the zero-edge branch of λ(χ) — the R5 phase-cover strata at the definite bundle's phase classes (enumerated by xtIdx).

                      @[reducible, inline]

                      The invariant dual attached to a character, as a raw functional (the lamC of the design §3; reducible, so all P8-lite spellings unify).

                      Equations
                      Instances For
                        noncomputable def Q2Presentation.Induction.BlockR.xtIdx {p : FramedPair} (chief : FirstNonScalarChiefFactor p) (K : KernelMinimal chief.toNonScalarChiefFactor) :
                        ↥(XT chief K) ≃ Fin (Nat.card ↥(XT chief K))

                        A fixed enumeration of 𝒳_T (mirror of properIdx); the position of χ' is its phase-chunk index.

                        Equations
                        Instances For

                          The proper-image subtraction read from an inner chunk list (Σ_{i<nJ} (chunk i).sum / 8; design §3.3).

                          Equations
                          Instances For

                            The phase-cover sum read from an inner chunk list (Σ_{j<nX} (chunk (nJ+j)).sum / 8; design §3.3's Sn).

                            Equations
                            • One or more equations did not get rendered due to their size.
                            Instances For

                              The inner block list of one nonzero character (design §4.2): nJ proper-image strata blocks, then — on the zero-edge branch of λ(χ) — nX phase-cover strata blocks at the DEFINITE bundle's phase classes (else nothing; zeroEdgeZtermAt's dite matches).

                              Equations
                              • One or more equations did not get rendered due to their size.
                              Instances For

                                The card-2 children tail: the flatMap of the per-χ R2–R5 blocks over the SAME fixed enumeration as the 4 ≤ |Φ(K)| tail.

                                Equations
                                • One or more equations did not get rendered due to their size.
                                Instances For

                                  Outer chunk readout (blockChildrenTail_chunk transplant): the c-chunk of the mapped card-2 tail is the mapped c-block.

                                  Inner chunk readout (design §4.3): splitting the mapped c-block by the raw inner lengths recovers the mapped inner blocks — the generic splitByLengths_flatMap_getD at g := id.

                                  Position i < nJ of the inner list is the i-th proper block.

                                  theorem Q2Presentation.Induction.BlockR.r2r5InnerBlocks_getElem_phase {p : FramedPair} (chief : FirstNonScalarChiefFactor p) (K : KernelMinimal chief.toNonScalarChiefFactor) (X : MinimalBlockPreheadInvariantCharacterData (sec7RawTowerPacketCanonical chief K).preheadTowerData) (Fdet : MinimalBlockPreheadExtraspecialEquivariantFamilyData (sec7RawTowerPacketCanonical chief K).preheadTowerData) (A : MinimalBlockPreheadExtraspecialAnnihilationData Fdet) (Rdet : MinimalBlockPreheadExtraspecialRadicalData Fdet) (N : MinimalBlockPreheadExtraspecialNonzeroData Fdet) (h : ¬ScalarTerminal p) (c : BlockNZChar chief K X Fdet A Rdet N h) (hZE : ZeroEdge chief K (blockLam chief K X Fdet A Rdet N h ↑c) ⋯) (j : ℕ) (hj : j < Nat.card ↥(XT chief K)) (hj' : Nat.card { J : mImageStrata chief K // ↑J ≠ ⊤ } + j < (r2r5InnerBlocks chief K X Fdet A Rdet N h c).length) :
                                  (r2r5InnerBlocks chief K X Fdet A Rdet N h c)[Nat.card { J : mImageStrata chief K // ↑J ≠ ⊤ } + j] = phaseStrataChildren chief K (Delta chief K (blockLam chief K X Fdet A Rdet N h ↑c) ⋯ (↑(theZeroEdgeBundle chief K (blockLam chief K X Fdet A Rdet N h ↑c) ⋯ ⋯ hZE)) ((xtIdx chief K).symm ⟨j, hj⟩)) ⋯ ⋯ ⋯

                                  Position nJ + j of the inner list, on the zero-edge branch, is the j-th phase block at the DEFINITE bundle (getElem?-route: the dite is rewritten under getElem?, which carries no bound proof, so no dependent motive arises). Per-declaration fuel per the TransgressionCore precedent (round-1 whnf/isDefEq timeouts at this declaration).

                                  Every member of the card-2 children tail is strictly smaller at bare hR (design §4.5): proper blocks by properStrataChildren_measure_lt (the enumerated J carries J.1 ≠ ⊤ from the subtype), phase blocks by the branch-free phaseStrataChildren_measure_lt.

                                  The per-χ inner chunk list read from a tail-counts list (design §3.3's inner): the outer chunk at the χ-position, split by the raw inner lengths.

                                  Equations
                                  • One or more equations did not get rendered due to their size.
                                  Instances For

                                    Realized inner readout: at the realized card-2 tail, chunk i of r2r5InnerAt is the mapped i-th inner block (outer chunk + inner chunk, design §4.3).

                                    The zero-edge Z-term (design §3.3, at a nonzero character c): on the zero-edge branch of λ(c), the R4b closed form at the definite bundle and the definite sign (Sn read positionally from the inner chunks); on the nonzero-edge branch, the R4a closed form 2^{2·dimM − 1}·e.

                                    Equations
                                    • One or more equations did not get rendered due to their size.
                                    Instances For
                                      theorem Q2Presentation.Induction.BlockR.zeroEdgeZtermAt_pos {p : FramedPair} (chief : FirstNonScalarChiefFactor p) (K : KernelMinimal chief.toNonScalarChiefFactor) (X : MinimalBlockPreheadInvariantCharacterData (sec7RawTowerPacketCanonical chief K).preheadTowerData) (Fdet : MinimalBlockPreheadExtraspecialEquivariantFamilyData (sec7RawTowerPacketCanonical chief K).preheadTowerData) (A : MinimalBlockPreheadExtraspecialAnnihilationData Fdet) (Rdet : MinimalBlockPreheadExtraspecialRadicalData Fdet) (N : MinimalBlockPreheadExtraspecialNonzeroData Fdet) (h : ¬ScalarTerminal p) (c : BlockNZChar chief K X Fdet A Rdet N h) (e : ℕ) (inner : List (List ℕ)) (hZE : ZeroEdge chief K (blockLam chief K X Fdet A Rdet N h ↑c) ⋯) :
                                      zeroEdgeZtermAt chief K X Fdet A Rdet N h c e inner = if zeroEdgeSign chief K (blockLam chief K X Fdet A Rdet N h ↑c) ⋯ ↑(theZeroEdgeBundle chief K (blockLam chief K X Fdet A Rdet N h ↑c) ⋯ ⋯ hZE) = true then (muT chief K * (2 ^ dimV chief K * e + 2 ^ (dimV chief K / 2 + 1) * phaseSumRead chief K inner) - muT chief K * 2 ^ (dimV chief K / 2) * 2 ^ rT chief K * e) / 2 ^ (rT chief K + 1) else (muT chief K * (2 ^ dimV chief K * e + 2 ^ (dimV chief K / 2) * 2 ^ rT chief K * e) - muT chief K * 2 ^ (dimV chief K / 2 + 1) * phaseSumRead chief K inner) / 2 ^ (rT chief K + 1)

                                      zeroEdgeZtermAt, zero-edge branch.

                                      The card-2 χ ≠ 0 elementary term (design §3.3, dite-totalized in χ): zeroEdgeZterm − properTerm, both read positionally from the counts list (counts.tail.headI = the cChild count e_Γ(C), counts.tail.tail = the card-2 tail counts). At χ = 0 it is never read (the formula's χ = 0 branch fires first).

                                      Equations
                                      • One or more equations did not get rendered due to their size.
                                      Instances For

                                        Proper chunk i, candidate source: (chunk i).sum / 8 = m_{A,λ(c)}(J_i) (V4's transform through V5's list form; the division is exact).

                                        theorem Q2Presentation.Induction.BlockR.r2r5_phaseRead_gammaA {p : FramedPair} (chief : FirstNonScalarChiefFactor p) (K : KernelMinimal chief.toNonScalarChiefFactor) (X : MinimalBlockPreheadInvariantCharacterData (sec7RawTowerPacketCanonical chief K).preheadTowerData) (Fdet : MinimalBlockPreheadExtraspecialEquivariantFamilyData (sec7RawTowerPacketCanonical chief K).preheadTowerData) (A : MinimalBlockPreheadExtraspecialAnnihilationData Fdet) (Rdet : MinimalBlockPreheadExtraspecialRadicalData Fdet) (N : MinimalBlockPreheadExtraspecialNonzeroData Fdet) (h : ¬ScalarTerminal p) (c : BlockNZChar chief K X Fdet A Rdet N h) (hZE : ZeroEdge chief K (blockLam chief K X Fdet A Rdet N h ↑c) ⋯) (j : ℕ) (hj : j < Nat.card ↥(XT chief K)) :
                                        ((r2r5InnerAt chief K X Fdet A Rdet N h c (List.map (⇑Cardinal.toNat ∘ framedCountA) (blockChildrenTail₂ chief K X Fdet A Rdet N h))).getD (Nat.card { J : mImageStrata chief K // ↑J ≠ ⊤ } + j) []).sum / 8 = phaseCount chief K (Delta chief K (blockLam chief K X Fdet A Rdet N h ↑c) ⋯ (↑(theZeroEdgeBundle chief K (blockLam chief K X Fdet A Rdet N h ↑c) ⋯ ⋯ hZE)) ((xtIdx chief K).symm ⟨j, hj⟩)) ⋯ ⋯ ⋯ boundaryPackage_GammaA

                                        Phase chunk j, candidate source, zero-edge branch: (chunk (nJ+j)).sum / 8 = n_{A,0}(Δ_{χ'_j,κ}) at the definite bundle.

                                        theorem Q2Presentation.Induction.BlockR.r2r5_phaseRead_gq2 {p : FramedPair} (chief : FirstNonScalarChiefFactor p) (K : KernelMinimal chief.toNonScalarChiefFactor) (X : MinimalBlockPreheadInvariantCharacterData (sec7RawTowerPacketCanonical chief K).preheadTowerData) (Fdet : MinimalBlockPreheadExtraspecialEquivariantFamilyData (sec7RawTowerPacketCanonical chief K).preheadTowerData) (A : MinimalBlockPreheadExtraspecialAnnihilationData Fdet) (Rdet : MinimalBlockPreheadExtraspecialRadicalData Fdet) (N : MinimalBlockPreheadExtraspecialNonzeroData Fdet) (h : ¬ScalarTerminal p) (c : BlockNZChar chief K X Fdet A Rdet N h) (hZE : ZeroEdge chief K (blockLam chief K X Fdet A Rdet N h ↑c) ⋯) (j : ℕ) (hj : j < Nat.card ↥(XT chief K)) :
                                        ((r2r5InnerAt chief K X Fdet A Rdet N h c (List.map (⇑Cardinal.toNat ∘ framedCountQ) (blockChildrenTail₂ chief K X Fdet A Rdet N h))).getD (Nat.card { J : mImageStrata chief K // ↑J ≠ ⊤ } + j) []).sum / 8 = phaseCount chief K (Delta chief K (blockLam chief K X Fdet A Rdet N h ↑c) ⋯ (↑(theZeroEdgeBundle chief K (blockLam chief K X Fdet A Rdet N h ↑c) ⋯ ⋯ hZE)) ((xtIdx chief K).symm ⟨j, hj⟩)) ⋯ ⋯ ⋯ boundaryPackage_GQ2

                                        Phase chunk j, local source, zero-edge branch.

                                        The card-2 candidate realization (design §6.2, candidate column): m_{A,λ(c)}(B) = zeroEdgeZterm − properTerm at the realized children counts. R2 (sec7_properImageSubtraction_gammaA) + R3 readouts are PROVEN; the branch step consumes exactly keep 1 (through the recovered sec7_edgeHalving_gammaA) on ¬ZeroEdge and keep 3 (through theZeroEdgeBundle_countA) on ZeroEdge.

                                        The card-2 local realization (design §6.2, local column): mirror of cardTwoRealizedA, consuming exactly keep 2 (q2_edgeHalving) on ¬ZeroEdge and keep 4 (through theZeroEdgeBundle_countQ, at the SAME definite bundle as the candidate side) on ZeroEdge.

                                        The §8 lift-torsor data over the pinned block (hoisted from the packet proof): candidate side fully proven ([A1]/[A2] + sourceBij), local side from the PINNED obstruction ([Q1]/[Q2] + sourceBij); the common cocycle model is (Fin dimExp → 𝔽₂) × 𝒳_R^∨, of size z_R.

                                        Equations
                                        • One or more equations did not get rendered due to their size.
                                        Instances For

                                          The split counting formula (P8-lite): at χ = 0 the partial count is the CHILD count (counts.headI — threaded through children, so the engine's induction hypothesis supplies the source-agreement there, m_{Γ,0}(B) = e_Γ(B), prop:finalfourier l.4249); at χ ≠ 0 with 4 ≤ |Φ(K)| it is the χ-strata chunk sum of the children counts divided by 8 (eq:covertransform at the scalar cover B_{λ(χ)}: the strata are children, so the engine IH supplies the per-stratum source-agreement, and the division is exact — at the realized lists the numerator is 8·m_{Γ,λ(χ)}(B) by sec7_scalarCoverPartition_gammaA/gq2); at χ ≠ 0 with |Φ(K)| = 2 it is the R2–R5 recursion term cardTwoTerm (design §3.3): zeroEdgeZterm − properTerm, both read positionally from the card-2 children counts — one shared source-independent term, so partialRecipe_of_sourceAgreement … rfl survives unchanged.

                                          Equations
                                          • One or more equations did not get rendered due to their size.
                                          Instances For

                                            The block realization packet, PROVEN over the engine, carrying BOTH source realizations of the split counting formula: candidate side fully proven ([A1]/[A2] theorems + the child-count identity at χ = 0), local side from the PINNED obstruction ([Q1]/[Q2] keep-clause theorems

                                            • the proven χ = 0 child-count identity). The χ ≠ 0 branch converts to per-λ cover-lift counts on both sides (blockPerChar*_card_eq_coverCount) and is then closed through the |Φ(K)| case split (P8-lite, audit/BLOCKR_P8LITE_DESIGN.md):
                                            • at 4 ≤ |Φ(K)| — WITHOUT any keep: the scalar-cover strata are children (each with the PROVEN strict-decrease witness ≤ 2·(xrChild measure) < parent measure), and BOTH realizations are the eight-lift partition theorems sec7_scalarCoverPartition_gammaA/gq2 read through the positional chunk of the children counts list, so the engine's strong induction (boundaryFramed_counts_equal_corrected) derives the per-character source-agreement stratum-by-stratum;
                                            • at |Φ(K)| = 2 (the exact complement, Φ(K) ≤ L_Y being a 2-group) — the R2–R5 recursion (audit/BLOCKR_P8_DESIGN.md §6.2): children are xrChild :: cChild :: blockChildrenTail₂ (proper R3 strata + zero-edge R5 phase strata, all strictly smaller at bare hR), and each source's realization is blockPerChar*_card_eq_coverCount composed with cardTwoRealizedA/Q — R2 subtraction and all chunk readouts PROVEN, the edge branch closed per source by exactly the four coordinated keeps of Induction/BlockRecursionKeeps.lean (candidate: sec7_edgeTwistFlip_gammaA via the proven flip involution, sec7_zeroEdgeCount_gammaA; local: q2_edgeHalving, q2_zeroEdgeCount — both zero-edge keeps at the SAME definite pinned bundle theZeroEdgeBundle and definite sign zeroEdgeSign). The former residual count-agreement keep is DELETED: agreement is now derived per child by the engine IH. hcard (card_kernelFrattini_eq_two) is no longer consumed by an axiom; the branch hypotheses used are hR and h4.

                                            The rewired branch #

                                            The 𝒳_R ≠ 0 branch over the PROVEN packet.