Documentation

LeanPool.BrillNoetherGraphs.LowGenus.ConfigurationMarkedRow

The row-authoring layer over a marked script #

GenusFiveRow05 proved AR's sixth family by hand: it named the two marked slots, built the potential, checked MarksAdmissible, read each slot as one or two ordinary arms, and closed the residual. All of that except the tables is independent of the row and of which slots carry a mark, and AR's seventh family (row 08) needs it three times over -- once per chamber, with a different pair of marked slots each time. This file is that layer, stated once.

The whole interface is driven by a single function mark : Fin 12 → ℕ. There is no separate "is this slot marked" flag, because

What a chamber supplies is a Profile: the mark is inside its slot, the height at each end of a marked slot is bounded by that end's half, one of those two heights vanishes (the chip sits where a flat stretch meets a full ramp), and the height is constant across collapsed slots. Those five facts give MarksAdmissible, the ledger reading of every slot, and the hypotheses of prin_splitScript_interiorVertex_ge_neg_one at the mark -- so the interior chip costs a chamber nothing beyond declaring its profile.

The script of a height profile #

The potential of a height profile, read at the canonical class representative so that class invariance is definitional.

Equations
Instances For

    The script's value at each mark. Zero on a genuinely marked slot -- the chip sits at the ambient level -- and the tail's own value on an unmarked one, which is what makes the unmarked slot literally the old single ramp.

    Equations
    Instances For

      The marked firing script of a height profile.

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

        What a chamber has to say about its height profile. Everything else in this file follows from these five facts.

        • le (e : Fin 12) : mark e ≤ d.length e

          Each mark lies inside its slot.

        • inBound (e : Fin 12) : 0 < mark e → h (d.core.tail e) ≤ mark e

          The near half of a marked slot is long enough for its rise.

        • outBound (e : Fin 12) : 0 < mark e → h (d.core.head e) ≤ d.length e - mark e

          The far half of a marked slot is long enough for its rise.

        • flat (e : Fin 12) : 0 < mark e → h (d.core.tail e) = 0 ∨ h (d.core.head e) = 0

          The chip sits where a flat stretch meets a full ramp.

        • const (e : Fin 12) : d.length e = 0 → h (d.core.tail e) = h (d.core.head e)

          The profile is constant across a collapsed slot, hence on every contracted class.

        Instances For

          Class constancy #

          theorem AtanasovRanganathan.ConfigurationMarkedRow.height_rep_eq (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {core : Utilities.Certificate.ExplicitPotential.Core 8 12} (hCore : d.core = core) {h : Fin 8 → ℕ} (hconst : ∀ (e : Fin 12), d.length e = 0 → h (d.core.tail e) = h (d.core.head e)) (F : Finset (Fin 12)) (hRepReach : ∀ (x y : Fin 8), d.rep x = d.rep y ↔ Utilities.Certificate.ContractionForestCensusGeneral.ReachIn core F x y) (hFZero : ∀ (e : Fin 12), e ∈ F ↔ d.length e = 0) (v : Fin 8) :
          h (d.rep v) = h v
          theorem AtanasovRanganathan.ConfigurationMarkedRow.heightPotential_eq (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {h : Fin 8 → ℕ} (hRep : ∀ (v : Fin 8), h (d.rep v) = h v) (v : Fin 8) :
          heightPotential d h v = -↑(h v)
          theorem AtanasovRanganathan.ConfigurationMarkedRow.heightPotential_rep (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {h : Fin 8 → ℕ} (hRep : ∀ (v : Fin 8), h (d.rep v) = h v) (v : Fin 8) :
          heightPotential d h (d.rep v) = -↑(h v)

          Admissibility #

          theorem AtanasovRanganathan.ConfigurationMarkedRow.markValue_of_pos (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {mark : Fin 12 → ℕ} {h : Fin 8 → ℕ} {e : Fin 12} (hpos : 0 < mark e) :
          markValue d mark h e = 0
          theorem AtanasovRanganathan.ConfigurationMarkedRow.markValue_of_zero (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {mark : Fin 12 → ℕ} {h : Fin 8 → ℕ} {e : Fin 12} (hzero : mark e = 0) :
          markValue d mark h e = heightPotential d h (d.rep (d.core.tail e))
          theorem AtanasovRanganathan.ConfigurationMarkedRow.marks_admissible (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {mark : Fin 12 → ℕ} {h : Fin 8 → ℕ} (hprof : Profile d mark h) (hRep : ∀ (v : Fin 8), h (d.rep v) = h v) :
          d.MarksAdmissible (heightPotential d h) mark (markValue d mark h)

          Each slot as one or two ordinary arms #

          The tail contribution of a slot, splitting at an interior mark when one is present.

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

            The head contribution of a slot, using the arm beyond an interior mark when it exists.

            Equations
            • One or more equations did not get rendered due to their size.
            Instances For
              theorem AtanasovRanganathan.ConfigurationMarkedRow.slotTailTerm_eq (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {mark : Fin 12 → ℕ} {h : Fin 8 → ℕ} (hprof : Profile d mark h) (hRep : ∀ (v : Fin 8), h (d.rep v) = h v) (e : Fin 12) :
              theorem AtanasovRanganathan.ConfigurationMarkedRow.slotHeadTerm_eq (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {mark : Fin 12 → ℕ} {h : Fin 8 → ℕ} (hprof : Profile d mark h) (hRep : ∀ (v : Fin 8), h (d.rep v) = h v) (e : Fin 12) :

              Specializations a chamber actually uses #

              At a marked slot one of the two end heights vanishes. Which one it is decides which of the two halves the chamber reads as an arm, and these four lemmas name the four readings so that a chamber never unfolds slotTailForm by hand.

              The tail end of a slot whose tail height vanishes.

              theorem AtanasovRanganathan.ConfigurationMarkedRow.slotHeadForm_of_flat_head (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {mark : Fin 12 → ℕ} {h : Fin 8 → ℕ} {e : Fin 12} (hhead : h (d.core.head e) = 0) (hzero : mark e = 0 → h (d.core.tail e) = 0) :
              slotHeadForm d mark h e = if mark e < d.length e then 0 else ConfigurationFive.headContribution (d.length e) (h (d.core.tail e)) 0

              The head end of a slot whose head height vanishes. The extra hypothesis is free at a marked slot: a mark sitting at the tail carries the tail's height, which is then zero as well.

              theorem AtanasovRanganathan.ConfigurationMarkedRow.slotTailForm_of_arm (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {mark : Fin 12 → ℕ} {h : Fin 8 → ℕ} {e : Fin 12} (hhead : h (d.core.head e) = 0) (hzero : mark e = 0 → h (d.core.tail e) = 0) :

              The near half of a marked slot, read as an arm from the tail.

              theorem AtanasovRanganathan.ConfigurationMarkedRow.slotHeadForm_of_arm (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {mark : Fin 12 → ℕ} {h : Fin 8 → ℕ} {e : Fin 12} (htail : h (d.core.tail e) = 0) (hle : mark e ≤ d.length e) (hbound : h (d.core.head e) ≤ d.length e - mark e) :
              slotHeadForm d mark h e = ConfigurationFive.headContribution (d.length e - mark e) 0 (h (d.core.head e))

              The far half of a marked slot, read as an arm from the head.

              theorem AtanasovRanganathan.ConfigurationMarkedRow.contribution_eq (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {mark : Fin 12 → ℕ} {h : Fin 8 → ℕ} (hprof : Profile d mark h) (hRep : ∀ (v : Fin 8), h (d.rep v) = h v) (v : Fin 8) :
              ConfigurationMarkedThree.positiveEndpointContribution d (heightPotential d h) mark (markValue d mark h) v = ∑ e : Fin 12, ((if d.core.tail e = v then slotTailForm d mark h e else 0) + if d.core.head e = v then slotHeadForm d mark h e else 0)

              The endpoint ledger of a chamber. Every slot, marked or not, reads as one or two ordinary arms; a chamber expands this sum against its own core.

              From per-vertex coefficients to the residual #

              theorem AtanasovRanganathan.ConfigurationMarkedRow.residual_of_coeff {alloc contrib : Fin 8 → ℤ} {owner : Fin 8} (hAll : ∀ (v : Fin 8), 0 ≤ alloc v + contrib v) (hOwner : 1 ≤ alloc owner + contrib owner) (v : Fin 8) :
              0 ≤ alloc v - ConfigurationCommon.indicatorWeight v owner + contrib v
              theorem AtanasovRanganathan.ConfigurationMarkedRow.mark_bounds (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {mark : Fin 12 → ℕ} {h : Fin 8 → ℕ} (hprof : Profile d mark h) (hRep : ∀ (v : Fin 8), h (d.rep v) = h v) {e : Fin 12} (hpos : 0 < mark e) :
              d.markRiseIn (heightPotential d h) (markValue d mark h) e ≤ ↑(mark e) ∧ -↑(d.length e - mark e) ≤ d.markRiseOut (heightPotential d h) (markValue d mark h) e ∧ (d.markRiseIn (heightPotential d h) (markValue d mark h) e = 0 ∨ d.markRiseOut (heightPotential d h) (markValue d mark h) e = 0)

              The hypotheses of the kink lemma, at a mark strictly inside its slot.

              theorem AtanasovRanganathan.ConfigurationMarkedRow.residual_effective (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {mark : Fin 12 → ℕ} {h : Fin 8 → ℕ} (hprof : Profile d mark h) (hRep : ∀ (v : Fin 8), h (d.rep v) = h v) {D : CFDiv d.graph} {base alloc : Fin 8 → ℤ} (hCoreValue : ∀ (r : Fin 8), D (d.coreVertex r) = ∑ v : Fin 8 with d.rep v = d.rep r, base v) (hInterior : ∀ (e : Fin 12) (o : Fin (d.length e - 1)), 0 ≤ D (d.interiorVertex e o)) (hChip : ∀ (e : Fin 12) (o : Fin (d.length e - 1)), ↑o + 1 = mark e → mark e < d.length e → 1 ≤ D (d.interiorVertex e o)) (hAlloc : ∀ (r : Fin 8), ∑ v : Fin 8 with d.rep v = d.rep r, alloc v = ∑ v : Fin 8 with d.rep v = d.rep r, base v) {center owner : Fin 8} (hOwnerRep : d.rep owner = d.rep center) (hLocal : ∀ (v : Fin 8), 0 ≤ alloc v - ConfigurationCommon.indicatorWeight v owner + ConfigurationMarkedThree.positiveEndpointContribution d (heightPotential d h) mark (markValue d mark h) v) :
              effective (D - oneChip (d.coreVertex center) + (prin d.graph) (script d mark h))

              The local Dhar move of a chamber. The divisor is abstract; a chamber supplies its value on core classes, its nonnegativity at interior vertices, and the one chip it keeps at each mark.

              Divisors with one or two chips inside a slot #

              A chamber's divisor is a core-class weight plus one chip at each marked slot's mark. These wrappers supply the four facts residual_effective asks for.

              A core-class weight plus chips at the marks of two slots.

              Equations
              Instances For

                A core-class weight plus a chip at the mark of one slot.

                Equations
                Instances For

                  The core-class weight of a two-mark divisor.

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

                    The core-class weight of a one-mark divisor.

                    Equations
                    Instances For
                      theorem AtanasovRanganathan.ConfigurationMarkedRow.markedDivisorTwo_effective (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) (W : Fin 8 → ℤ) (mark : Fin 12 → ℕ) (hW : ∀ (v : Fin 8), 0 ≤ W v) (e f : Fin 12) :
                      theorem AtanasovRanganathan.ConfigurationMarkedRow.baseTwo_nonneg (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) (W : Fin 8 → ℤ) (mark : Fin 12 → ℕ) (hW : ∀ (v : Fin 8), 0 ≤ W v) (e f : Fin 12) (v : Fin 8) :
                      0 ≤ baseTwo d W mark e f v
                      theorem AtanasovRanganathan.ConfigurationMarkedRow.baseOne_nonneg (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) (W : Fin 8 → ℤ) (mark : Fin 12 → ℕ) (hW : ∀ (v : Fin 8), 0 ≤ W v) (e : Fin 12) (v : Fin 8) :
                      0 ≤ baseOne d W mark e v
                      theorem AtanasovRanganathan.ConfigurationMarkedRow.markedDivisorTwo_coreVertex (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) (W : Fin 8 → ℤ) (mark : Fin 12 → ℕ) (e f : Fin 12) (r : Fin 8) :
                      markedDivisorTwo d W mark e f (d.coreVertex r) = ∑ v : Fin 8 with d.rep v = d.rep r, baseTwo d W mark e f v
                      theorem AtanasovRanganathan.ConfigurationMarkedRow.markedDivisorOne_coreVertex (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) (W : Fin 8 → ℤ) (mark : Fin 12 → ℕ) (e : Fin 12) (r : Fin 8) :
                      markedDivisorOne d W mark e (d.coreVertex r) = ∑ v : Fin 8 with d.rep v = d.rep r, baseOne d W mark e v
                      theorem AtanasovRanganathan.ConfigurationMarkedRow.markedDivisorTwo_interior (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) (W : Fin 8 → ℤ) (mark : Fin 12 → ℕ) (hW : ∀ (v : Fin 8), 0 ≤ W v) (e f g : Fin 12) (o : Fin (d.length g - 1)) :
                      0 ≤ markedDivisorTwo d W mark e f (d.interiorVertex g o)
                      theorem AtanasovRanganathan.ConfigurationMarkedRow.markedDivisorOne_interior (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) (W : Fin 8 → ℤ) (mark : Fin 12 → ℕ) (hW : ∀ (v : Fin 8), 0 ≤ W v) (e g : Fin 12) (o : Fin (d.length g - 1)) :
                      0 ≤ markedDivisorOne d W mark e (d.interiorVertex g o)
                      theorem AtanasovRanganathan.ConfigurationMarkedRow.markedDivisorTwo_chip (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) (W : Fin 8 → ℤ) (mark : Fin 12 → ℕ) {e f : Fin 12} (hsupp : ∀ (g : Fin 12), 0 < mark g → g = e ∨ g = f) (g : Fin 12) (o : Fin (d.length g - 1)) (hmark : ↑o + 1 = mark g) (hlt : mark g < d.length g) :
                      1 ≤ markedDivisorTwo d W mark e f (d.interiorVertex g o)

                      The chip a two-mark divisor keeps at each mark. hsupp says the mark function is supported on the two named slots, which is how a chamber declares which slots it marks.

                      theorem AtanasovRanganathan.ConfigurationMarkedRow.markedDivisorOne_chip (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) (W : Fin 8 → ℤ) (mark : Fin 12 → ℕ) {e : Fin 12} (hsupp : ∀ (g : Fin 12), 0 < mark g → g = e) (g : Fin 12) (o : Fin (d.length g - 1)) (hmark : ↑o + 1 = mark g) (hlt : mark g < d.length g) :
                      1 ≤ markedDivisorOne d W mark e (d.interiorVertex g o)
                      theorem AtanasovRanganathan.ConfigurationMarkedRow.one_le_markedDivisorTwo_at_chip (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) (W : Fin 8 → ℤ) (mark : Fin 12 → ℕ) (e f : Fin 12) (hW : ∀ (v : Fin 8), 0 ≤ W v) {c : Fin 8} (hc : 1 ≤ W c) :
                      1 ≤ markedDivisorTwo d W mark e f (d.coreVertex c)
                      theorem AtanasovRanganathan.ConfigurationMarkedRow.one_le_markedDivisorOne_at_chip (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) (W : Fin 8 → ℤ) (mark : Fin 12 → ℕ) (e : Fin 12) (hW : ∀ (v : Fin 8), 0 ≤ W v) {c : Fin 8} (hc : 1 ≤ W c) :
                      1 ≤ markedDivisorOne d W mark e (d.coreVertex c)