Documentation

LeanPool.BrillNoetherGraphs.LowGenus.GenusFourRow097Closed

Unconditional CLOSED-ORTHANT existence on genus-four Core 097 #

The pencil is expressed over Utilities.Certificate.DegenerateSpec.DegSpec, whose lengths may vanish, so the conclusion covers the whole closed orthant: every subdivision of the row-097 core and every equal-genus contraction of one.

The positive-length statement follows from the result here.

The face ℓ₈ = 0 also supplies the corresponding row-068 case.

The mathematics is the same; the bookkeeping is different #

Writing the split core as

e0 0-4   e1 0-5   e2 0-5   e3 1-2   e4 1-3
e5 1-5   e6 2-3   e7 2-4   e8 3-4

the vertices 2 and 3 are the hubs of a theta graph with arcs e6, e3 + e4 (through 1) and e7 + e8 (through 4); the interior vertices 1 and 4 of the last two arcs are joined by a handle 1 —e5— 5 =banana(e1,e2)= 0 —e0— 4. Writing Δ = length 0 - length 5 and d = min Δ (length 4), the pencil is

D = 3 + 4 + (the point at distance d from 1 along e3),

moved onto the core by marches across the three-edge cuts star 2, {e0,e3,e4}, star 0 and across the two-edge cut {e0,e5} (used twice). The Klein four-group σ = (0 5)(1 4), τ = (2 3) puts an arbitrary length vector in the chamber length 5 ≤ length 0, length 4 ≤ length 3.

Three things change on the closed orthant, and all three are handled once, in Certificate/DegenerateRamp.lean, rather than per march:

The four per-march divisor identities of the retired open proof — four set_option maxHeartbeats 1000000 declarations there — are replaced by a single generic one, DegSpec.prin_ramp_eq, instantiated nine-slot-wise. This file needs no heartbeat override.

Finite-index bookkeeping #

theorem LowGenus.GenusFourRow097Closed.sum_univ_nine {M : Type u_1} [AddCommMonoid M] (f : Fin 9 → M) :
∑ i : Fin 9, f i = f 0 + f 1 + f 2 + f 3 + f 4 + f 5 + f 6 + f 7 + f 8
theorem LowGenus.GenusFourRow097Closed.forall_fin_nine {P : Fin 9 → Prop} (h0 : P 0) (h1 : P 1) (h2 : P 2) (h3 : P 3) (h4 : P 4) (h5 : P 5) (h6 : P 6) (h7 : P 7) (h8 : P 8) (e : Fin 9) :
P e
theorem LowGenus.GenusFourRow097Closed.forall_fin_six {P : Fin 6 → Prop} (h0 : P 0) (h1 : P 1) (h2 : P 2) (h3 : P 3) (h4 : P 4) (h5 : P 5) (v : Fin 6) :
P v

Rank one from reaching the core classes #

The closed-orthant analogue of Utilities.Certificate.CoreVertexReachability.bnExists_of_reaches_coreVertices. Both hypotheses it needs about the ambient graph are already hypothesis-free on a DegSpec: the class vertices are a strong separator (DegSpec.strongSeparatorCertificate) and connectivity comes from the finite cut certificate on the uncontracted core (DegSpec.graph_connected_of_coreConnected).

The oriented row-097 core #

The orientation data of the row-097 split core, read on the core rather than on a positive subdivision: on the closed orthant the slot lengths are not part of this datum.

Instances For

    The row-097 core is connected: any nonempty proper cut of the six vertices is crossed by some slot. Assuming no slot crosses the cut, the nine slots link all six vertices into a single chain 0 - 4, 0 - 5 - 1, 1 - 2, 1 - 3, so every vertex agrees with 0.

    The pencil parameters #

    Every parameter is a function of the length vector alone; no positivity and no spec is involved.

    Depth of the moving chip on slot e3.

    Equations
    Instances For

      Residual handle imbalance.

      Equations
      Instances For

        Length of the star 2 march.

        Equations
        Instances For

          Length of the second pass of the {e0,e5} march.

          Equations
          Instances For

            The four marches #

            Core potential of the star 2 march.

            Equations
            Instances For

              Slot signs of the star 2 march.

              Equations
              Instances For
                def LowGenus.GenusFourRow097Closed.vLo (L : Fin 9 → ℕ) (u : ℕ) :
                Fin 9 → ℕ

                Window starts of the star 2 march.

                Equations
                Instances For

                  Core potential of the {e0,e3,e4} march.

                  Equations
                  Instances For

                    Slot signs of the {e0,e3,e4} march.

                    Equations
                    Instances For
                      def LowGenus.GenusFourRow097Closed.pLo (L : Fin 9 → ℕ) (s : ℕ) :
                      Fin 9 → ℕ

                      Window starts of the {e0,e3,e4} march.

                      Equations
                      Instances For

                        Core potential of the {e0,e5} march.

                        Equations
                        Instances For

                          Slot signs of the {e0,e5} march.

                          Equations
                          Instances For

                            Window starts of the {e0,e5} march starting from depth a on e0.

                            Equations
                            Instances For

                              Core potential of the star 0 march.

                              Equations
                              Instances For

                                Slot signs of the star 0 march.

                                Equations
                                Instances For
                                  def LowGenus.GenusFourRow097Closed.wLo (L : Fin 9 → ℕ) (w : ℕ) :
                                  Fin 9 → ℕ

                                  Window starts of the star 0 march.

                                  Equations
                                  • One or more equations did not get rendered due to their size.
                                  Instances For
                                    @[simp]
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.vLo_0 {L : Fin 9 → ℕ} {u : ℕ} :
                                    vLo L u 0 = 0
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.vLo_1 {L : Fin 9 → ℕ} {u : ℕ} :
                                    vLo L u 1 = 0
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.vLo_2 {L : Fin 9 → ℕ} {u : ℕ} :
                                    vLo L u 2 = 0
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.vLo_3 {L : Fin 9 → ℕ} {u : ℕ} :
                                    vLo L u 3 = dpos L
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.vLo_4 {L : Fin 9 → ℕ} {u : ℕ} :
                                    vLo L u 4 = 0
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.vLo_5 {L : Fin 9 → ℕ} {u : ℕ} :
                                    vLo L u 5 = 0
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.vLo_6 {L : Fin 9 → ℕ} {u : ℕ} :
                                    vLo L u 6 = L 6 - u
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.vLo_7 {L : Fin 9 → ℕ} {u : ℕ} :
                                    vLo L u 7 = L 7 - u
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.vLo_8 {L : Fin 9 → ℕ} {u : ℕ} :
                                    vLo L u 8 = 0
                                    @[simp]
                                    @[simp]
                                    @[simp]
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.pLo_0 {L : Fin 9 → ℕ} {s : ℕ} :
                                    pLo L s 0 = L 0 - s
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.pLo_1 {L : Fin 9 → ℕ} {s : ℕ} :
                                    pLo L s 1 = 0
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.pLo_2 {L : Fin 9 → ℕ} {s : ℕ} :
                                    pLo L s 2 = 0
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.pLo_3 {L : Fin 9 → ℕ} {s : ℕ} :
                                    pLo L s 3 = dpos L - s
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.pLo_4 {L : Fin 9 → ℕ} {s : ℕ} :
                                    pLo L s 4 = L 4 - s
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.pLo_5 {L : Fin 9 → ℕ} {s : ℕ} :
                                    pLo L s 5 = 0
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.pLo_6 {L : Fin 9 → ℕ} {s : ℕ} :
                                    pLo L s 6 = 0
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.pLo_7 {L : Fin 9 → ℕ} {s : ℕ} :
                                    pLo L s 7 = 0
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.pLo_8 {L : Fin 9 → ℕ} {s : ℕ} :
                                    pLo L s 8 = 0
                                    @[simp]
                                    @[simp]
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.mLo_0 {r a : ℕ} :
                                    mLo a r 0 = a - r
                                    @[simp]
                                    @[simp]
                                    @[simp]
                                    @[simp]
                                    @[simp]
                                    @[simp]
                                    @[simp]
                                    @[simp]
                                    @[simp]
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.wLo_0 {L : Fin 9 → ℕ} {w : ℕ} :
                                    wLo L w 0 = cRest L - m2Max L - w
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.wLo_1 {L : Fin 9 → ℕ} {w : ℕ} :
                                    wLo L w 1 = L 1 - w
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.wLo_2 {L : Fin 9 → ℕ} {w : ℕ} :
                                    wLo L w 2 = L 2 - w
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.wLo_3 {L : Fin 9 → ℕ} {w : ℕ} :
                                    wLo L w 3 = 0
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.wLo_4 {L : Fin 9 → ℕ} {w : ℕ} :
                                    wLo L w 4 = 0
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.wLo_5 {L : Fin 9 → ℕ} {w : ℕ} :
                                    wLo L w 5 = 0
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.wLo_6 {L : Fin 9 → ℕ} {w : ℕ} :
                                    wLo L w 6 = 0
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.wLo_7 {L : Fin 9 → ℕ} {w : ℕ} :
                                    wLo L w 7 = 0
                                    @[simp]
                                    theorem LowGenus.GenusFourRow097Closed.wLo_8 {L : Fin 9 → ℕ} {w : ℕ} :
                                    wLo L w 8 = 0

                                    The ramps #

                                    RampData.repInv — the one field the open orthant does not need — is supplied uniformly by RampData.of_reachIn from RepGen, so each march below proves exactly the two conditions its open counterpart proves.

                                    The census hypothesis every closed-orthant march needs: rep-equality is witnessed by a chain of vanishing slots. Free for RowProof.censusSpec, whose rep is compFold of the vanishing set (compFold_iff).

                                    Equations
                                    Instances For
                                      theorem LowGenus.GenusFourRow097Closed.vRamp {d : Utilities.Certificate.DegenerateSpec.DegSpec 6 9} (hp : IsCore097 d.core) (hrep : RepGen d) {u : ℕ} (hu3 : dpos d.length + u ≤ d.length 3) (hu6 : u ≤ d.length 6) (hu7 : u ≤ d.length 7) :
                                      d.RampData (vPot u) vSgn (vLo d.length u) u
                                      theorem LowGenus.GenusFourRow097Closed.pRamp {d : Utilities.Certificate.DegenerateSpec.DegSpec 6 9} (hp : IsCore097 d.core) (hrep : RepGen d) {s : ℕ} (hs0 : s ≤ d.length 0) (hsd : s ≤ dpos d.length) (hd3 : dpos d.length ≤ d.length 3) (hs4 : s ≤ d.length 4) :
                                      d.RampData (pPot s) pSgn (pLo d.length s) s
                                      theorem LowGenus.GenusFourRow097Closed.mRamp {d : Utilities.Certificate.DegenerateSpec.DegSpec 6 9} (hp : IsCore097 d.core) (hrep : RepGen d) {a r : ℕ} (ha : a ≤ d.length 0) (hr1 : r ≤ a) (hr2 : r ≤ d.length 5) :
                                      d.RampData (mPot r) mSgn (mLo a r) r
                                      theorem LowGenus.GenusFourRow097Closed.wRamp {d : Utilities.Certificate.DegenerateSpec.DegSpec 6 9} (hp : IsCore097 d.core) (hrep : RepGen d) {w : ℕ} (hx : cRest d.length - m2Max d.length ≤ d.length 0) (hww : w ≤ cRest d.length - m2Max d.length) (hw1 : w ≤ d.length 1) (hw2 : w ≤ d.length 2) :
                                      d.RampData (wPot w) wSgn (wLo d.length w) w

                                      Divisor identities for the four marches #

                                      Each is one instantiation of the generic DegSpec.prin_ramp_eq, expanded over the nine slots. No case analysis and no heartbeat override occurs.

                                      theorem LowGenus.GenusFourRow097Closed.prin_v_eq {d : Utilities.Certificate.DegenerateSpec.DegSpec 6 9} {u : ℕ} (h : d.RampData (vPot u) vSgn (vLo d.length u) u) (hu6 : u ≤ d.length 6) (hu7 : u ≤ d.length 7) :
                                      (prin d.graph) (vScript d u) = oneChip (d.pathAt 3 (dpos d.length + u)) - oneChip (d.pathAt 3 (dpos d.length)) + (oneChip (d.pathAt 6 (d.length 6 - u)) - oneChip (d.pathAt 6 (d.length 6))) + (oneChip (d.pathAt 7 (d.length 7 - u)) - oneChip (d.pathAt 7 (d.length 7)))
                                      theorem LowGenus.GenusFourRow097Closed.prin_p_eq {d : Utilities.Certificate.DegenerateSpec.DegSpec 6 9} {s : ℕ} (h : d.RampData (pPot s) pSgn (pLo d.length s) s) (hs0 : s ≤ d.length 0) (hsd : s ≤ dpos d.length) (hs4 : s ≤ d.length 4) :
                                      (prin d.graph) (pScript d s) = oneChip (d.pathAt 0 (d.length 0 - s)) - oneChip (d.pathAt 0 (d.length 0)) + (oneChip (d.pathAt 3 (dpos d.length - s)) - oneChip (d.pathAt 3 (dpos d.length))) + (oneChip (d.pathAt 4 (d.length 4 - s)) - oneChip (d.pathAt 4 (d.length 4)))
                                      theorem LowGenus.GenusFourRow097Closed.prin_m_eq {d : Utilities.Certificate.DegenerateSpec.DegSpec 6 9} {a r : ℕ} (h : d.RampData (mPot r) mSgn (mLo a r) r) (hr1 : r ≤ a) :
                                      (prin d.graph) (mScript d a r) = oneChip (d.pathAt 0 (a - r)) - oneChip (d.pathAt 0 a) - (oneChip (d.pathAt 5 0) - oneChip (d.pathAt 5 r))
                                      theorem LowGenus.GenusFourRow097Closed.prin_w_eq {d : Utilities.Certificate.DegenerateSpec.DegSpec 6 9} {w : ℕ} (h : d.RampData (wPot w) wSgn (wLo d.length w) w) (hww : w ≤ cRest d.length - m2Max d.length) (hw1 : w ≤ d.length 1) (hw2 : w ≤ d.length 2) :
                                      (prin d.graph) (wScript d w) = oneChip (d.pathAt 0 (cRest d.length - m2Max d.length - w)) - oneChip (d.pathAt 0 (cRest d.length - m2Max d.length)) + (oneChip (d.pathAt 1 (d.length 1 - w)) - oneChip (d.pathAt 1 (d.length 1))) + (oneChip (d.pathAt 2 (d.length 2 - w)) - oneChip (d.pathAt 2 (d.length 2)))

                                      Bridging core classes and path positions #

                                      On the closed orthant these are the only places where a slot's two endpoints can coincide, and pathAt already knows: pathAt e k = coreVertex (head e) for every k ≥ length e, including k = 0 on a vanishing slot.

                                      The pencil and the states it passes through #

                                      theorem LowGenus.GenusFourRow097Closed.state_v {d : Utilities.Certificate.DegenerateSpec.DegSpec 6 9} (hp : IsCore097 d.core) (hrep : RepGen d) {u : ℕ} (hu3 : dpos d.length + u ≤ d.length 3) (hu6 : u ≤ d.length 6) (hu7 : u ≤ d.length 7) :
                                      pen d + (prin d.graph) (vScript d u) = oneChip (d.pathAt 3 (dpos d.length + u)) + oneChip (d.pathAt 6 (d.length 6 - u)) + oneChip (d.pathAt 7 (d.length 7 - u))
                                      theorem LowGenus.GenusFourRow097Closed.state_p {d : Utilities.Certificate.DegenerateSpec.DegSpec 6 9} (hp : IsCore097 d.core) (hrep : RepGen d) {s : ℕ} (hs0 : s ≤ d.length 0) (hsd : s ≤ dpos d.length) (hd3 : dpos d.length ≤ d.length 3) (hs4 : s ≤ d.length 4) :
                                      pen d + (prin d.graph) (pScript d s) = oneChip (d.pathAt 0 (d.length 0 - s)) + oneChip (d.pathAt 3 (dpos d.length - s)) + oneChip (d.pathAt 4 (d.length 4 - s))
                                      theorem LowGenus.GenusFourRow097Closed.state_m1 {d : Utilities.Certificate.DegenerateSpec.DegSpec 6 9} (hp : IsCore097 d.core) (hrep : RepGen d) (hd0 : dpos d.length ≤ d.length 0) (hd3 : dpos d.length ≤ d.length 3) (hd4 : dpos d.length ≤ d.length 4) {r : ℕ} (hr : r ≤ d.length 5) (hrle : r ≤ d.length 0 - dpos d.length) :
                                      pen d + (prin d.graph) (pScript d (dpos d.length) + mScript d (d.length 0 - dpos d.length) r) = oneChip (d.pathAt 0 (d.length 0 - dpos d.length - r)) + oneChip (d.pathAt 5 r) + oneChip (d.pathAt 4 (d.length 4 - dpos d.length))
                                      theorem LowGenus.GenusFourRow097Closed.state_m2 {d : Utilities.Certificate.DegenerateSpec.DegSpec 6 9} (hp : IsCore097 d.core) (hrep : RepGen d) (hd0 : dpos d.length ≤ d.length 0) (hd3 : dpos d.length ≤ d.length 3) (hd4 : dpos d.length ≤ d.length 4) (hcase : d.length 4 = dpos d.length) (h5 : d.length 5 ≤ d.length 0 - dpos d.length) {r : ℕ} (hr : r ≤ d.length 5) (hrc : r ≤ cRest d.length) :
                                      pen d + (prin d.graph) (pScript d (dpos d.length) + mScript d (d.length 0 - dpos d.length) (d.length 5) + mScript d (cRest d.length) r) = oneChip (d.pathAt 0 (cRest d.length - r)) + oneChip (d.pathAt 5 r) + oneChip (d.coreVertex 5)
                                      theorem LowGenus.GenusFourRow097Closed.state_w {d : Utilities.Certificate.DegenerateSpec.DegSpec 6 9} (hp : IsCore097 d.core) (hrep : RepGen d) (hd0 : dpos d.length ≤ d.length 0) (hd3 : dpos d.length ≤ d.length 3) (hd4 : dpos d.length ≤ d.length 4) (hcase : d.length 4 = dpos d.length) (h5 : d.length 5 ≤ d.length 0 - dpos d.length) (hm2 : m2Max d.length = d.length 5) {w : ℕ} (hww : w ≤ cRest d.length - m2Max d.length) (hw1 : w ≤ d.length 1) (hw2 : w ≤ d.length 2) :
                                      pen d + (prin d.graph) (pScript d (dpos d.length) + mScript d (d.length 0 - dpos d.length) (d.length 5) + mScript d (cRest d.length) (d.length 5) + wScript d w) = oneChip (d.pathAt 0 (cRest d.length - m2Max d.length - w)) + oneChip (d.pathAt 1 (d.length 1 - w)) + oneChip (d.pathAt 2 (d.length 2 - w))

                                      Reaching every core class #

                                      The covering argument #

                                      A nonzero residual imbalance forces the moving chip to sit at the far end of slot e4.

                                      If the star 0 march is nontrivial then the second {e0,e5} pass ran to the end of slot e5.

                                      theorem LowGenus.GenusFourRow097Closed.banana_pair {d : Utilities.Certificate.DegenerateSpec.DegSpec 6 9} (hp : IsCore097 d.core) (hrep : RepGen d) (hba : d.length 5 ≤ d.length 0) (hbc : d.length 4 ≤ d.length 3) (hx0 : cRest d.length - m2Max d.length = 0) :
                                      ∃ (script : firingScript d.graph) (Z : d.graph.V), pen d + (prin d.graph) script = oneChip (d.coreVertex 0) + oneChip (d.coreVertex 5) + oneChip Z

                                      A state with chips at both banana endpoints, available whenever the star 0 march is trivial.

                                      At the end of the star 2 march there is a chip at the hub 2.

                                      At the end of the star 0 march there is a chip at the vertex 0.

                                      Row 097 on the closed orthant, in the chamber length 5 ≤ length 0, length 4 ≤ length 3.

                                      The catalog row, on the closed orthant #

                                      An arbitrary length vector is moved into the chamber length 5 ≤ length 0 ∧ length 4 ≤ length 3 by the Klein four-group of automorphisms of the row-097 core, transported with ClosedCoreSymmetry.bnExists_iff — the closed-orthant counterpart of Certificate/SubdivisionIso.lean's bnExists_of_coreAuto. The transport is along the contracted graphs, so the chamber reduction costs nothing extra at a face.

                                      @[reducible, inline]

                                      The row-097 split core is the public cubic-atlas presentation.

                                      Equations
                                      Instances For

                                        σ = (0 5)(1 4) on core vertices.

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

                                          σ on edge slots: e0 ↔ e5, e3 ↔ e7, e4 ↔ e8.

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

                                            τ = (2 3) on core vertices.

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

                                              τ on edge slots: e3 ↔ e4, e7 ↔ e8.

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

                                                σ, as a core symmetry.

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

                                                  τ, as a core symmetry.

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

                                                    censusSpec's representative map is a compFold of the vanishing set, so RepGen — the one hypothesis a closed-orthant ramp needs beyond the open-orthant ones — is free.

                                                    BNExists … 1 3 for catalog row 097, on the whole closed length orthant. Quantified over every length vector whose vanishing set is a non-loopy forest — every subdivision of the row-097 core and every equal-genus contraction of one.

                                                    No Boolean check, no generated data, and no length chamber decomposition occurs anywhere below: the four cases are the orbit of one under the core's Klein four-group.