Documentation

LeanPool.BrillNoetherGraphs.LowGenus.ConfigurationSeven

Atanasov--Ranganathan configuration 7, generic in the core #

This is the seventh local picture of Atanasov--Ranganathan, Proposition 5.1 (fig:configurations-for-genus-5, the scope commented %Seventh):

      a          b        a, b carry chips
      |          |        u, v are chip free and joined by a banana
      u == v              |u a| = |v b|   (the figure labels both `a`)

Two chip-free core vertices joined by two parallel slots, each carrying one further slot -- an arm -- to a chip vertex, and the two arms have equal length. Interpolate the same negative height min |u a| |v b| on both centres. The banana then has zero rise and moves nothing, each arm consumes at most its own chip, and a shortest arm delivers a chip to its centre. With the two arms equal, one script therefore reaches both centres.

Why the rows need it, and why the arms are marked. AR's sixth and seventh genus-five families (atlas rows 05 and 08) each contain two of these pictures, and in each of them one of the two arms is half of a slot: the chip sits at an interior point whose offset is a length, which is exactly how the figure arranges for the two arms to be equal. So this file states the arm ledger for a marked slot as well as an unmarked one, on top of ConfigurationMarkedCommon. A marked arm is an ordinary arm of the half length:

Both readings are ConfigurationCommon's one-slot ramp lemmas at the half length, so nothing new is proved about ramps here.

Composability. Like ConfigurationTwo, the conclusions are stated one centre at a time; a row declares which of its chip-free vertices form banana pairs and covers the rest by other pictures. Rows 05 and 08 pair this file with ConfigurationThree.

The shared height #

The height interpolated on both centres of a banana pair: the shorter of the two arm lengths. On the AR rows the two arms are equal, so both centres are targets of the same script.

Equations
Instances For

    The banana slots move nothing #

    Both centres carry the same height, so each parallel slot has zero rise.

    theorem AtanasovRanganathan.ConfigurationSeven.endpointPair_eq_zero_of_unmarked_flat (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {potential : Fin 8 → ℤ} (hInv : d.RepInvariant potential) {mark : Fin 12 → ℕ} {markValue : Fin 12 → ℤ} {e : Fin 12} (hMark : mark e = 0) (hValue : markValue e = potential (d.rep (d.core.tail e))) (hRise : d.coreRise potential e = 0) (r : Fin 8) :
    ConfigurationMarkedCommon.endpointPair d potential mark markValue e r = 0
    theorem AtanasovRanganathan.ConfigurationSeven.bananaSlot_endpointPair_eq_zero (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {potential : Fin 8 → ℤ} (hInv : d.RepInvariant potential) {mark : Fin 12 → ℕ} {markValue : Fin 12 → ℤ} {e : Fin 12} (hMark : mark e = 0) (hValue : markValue e = potential (d.rep (d.core.tail e))) (hEq : potential (d.core.tail e) = potential (d.core.head e)) (r : Fin 8) :
    ConfigurationMarkedCommon.endpointPair d potential mark markValue e r = 0

    The two parallel slots of a banana whose ends carry the same potential contribute nothing anywhere.

    A marked arm, read from its tail #

    The centre is the tail of e, its chip sits at the mark, and the script is flat beyond the mark: markRiseIn e = height, markRiseOut e = 0.

    theorem AtanasovRanganathan.ConfigurationSeven.markRiseIn_tail (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {potential : Fin 8 → ℤ} {markValue : Fin 12 → ℤ} {e : Fin 12} {height : ℕ} (hCentre : potential (d.rep (d.core.tail e)) = -↑height) (hMarkValue : markValue e = 0) :
    d.markRiseIn potential markValue e = ↑height

    The rise data of an arm read from its tail.

    theorem AtanasovRanganathan.ConfigurationSeven.markRiseOut_tail (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {potential : Fin 8 → ℤ} {markValue : Fin 12 → ℤ} {e : Fin 12} (hHead : potential (d.rep (d.core.head e)) = 0) (hMarkValue : markValue e = 0) :
    d.markRiseOut potential markValue e = 0
    theorem AtanasovRanganathan.ConfigurationSeven.tailArm_centre (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {potential : Fin 8 → ℤ} {mark : Fin 12 → ℕ} {markValue : Fin 12 → ℤ} {e : Fin 12} {height : ℕ} (hMarks : d.MarksAdmissible potential mark markValue) (hCentre : potential (d.rep (d.core.tail e)) = -↑height) (hMarkValue : markValue e = 0) (hPos : 0 < mark e) :
    Utilities.Certificate.SubdivisionArithmetic.splitStep (d.length e) (mark e) (d.markRiseIn potential markValue e) (d.markRiseOut potential markValue e) 0 = Utilities.Certificate.SubdivisionArithmetic.step (mark e) (↑height) 0

    What the centre receives along a marked arm read from its tail: the first slope of the canonical ramp of rise height over mark e steps.

    theorem AtanasovRanganathan.ConfigurationSeven.tailArm_head (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {potential : Fin 8 → ℤ} {mark : Fin 12 → ℕ} {markValue : Fin 12 → ℤ} {e : Fin 12} (hMarks : d.MarksAdmissible potential mark markValue) (hHead : potential (d.rep (d.core.head e)) = 0) (hMarkValue : markValue e = 0) (hPos : 0 < d.length e) (hLt : mark e < d.length e) :
    Utilities.Certificate.SubdivisionArithmetic.splitStep (d.length e) (mark e) (d.markRiseIn potential markValue e) (d.markRiseOut potential markValue e) (d.length e - 1) = 0

    The far end of a marked arm read from its tail receives nothing: the script is already flat there.

    theorem AtanasovRanganathan.ConfigurationSeven.tailArm_centre_eq_one (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {potential : Fin 8 → ℤ} {mark : Fin 12 → ℕ} {markValue : Fin 12 → ℤ} {e : Fin 12} {height : ℕ} (hMarks : d.MarksAdmissible potential mark markValue) (hCentre : potential (d.rep (d.core.tail e)) = -↑height) (hMarkValue : markValue e = 0) (hPos : 0 < mark e) (hFull : height = mark e) :
    Utilities.Certificate.SubdivisionArithmetic.splitStep (d.length e) (mark e) (d.markRiseIn potential markValue e) (d.markRiseOut potential markValue e) 0 = 1

    A shortest marked arm delivers one chip to its centre.

    theorem AtanasovRanganathan.ConfigurationSeven.tailArm_centre_nonneg (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {potential : Fin 8 → ℤ} {mark : Fin 12 → ℕ} {markValue : Fin 12 → ℤ} {e : Fin 12} {height : ℕ} (hMarks : d.MarksAdmissible potential mark markValue) (hCentre : potential (d.rep (d.core.tail e)) = -↑height) (hMarkValue : markValue e = 0) (hPos : 0 < mark e) :
    0 ≤ Utilities.Certificate.SubdivisionArithmetic.splitStep (d.length e) (mark e) (d.markRiseIn potential markValue e) (d.markRiseOut potential markValue e) 0

    A marked arm never takes a chip away from its centre.

    A marked arm, read from its head #

    The centre is the head of e, its chip sits at the mark, and the script is flat before the mark: markRiseIn e = 0, markRiseOut e = -height.

    theorem AtanasovRanganathan.ConfigurationSeven.markRiseIn_head (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {potential : Fin 8 → ℤ} {markValue : Fin 12 → ℤ} {e : Fin 12} (hTail : potential (d.rep (d.core.tail e)) = 0) (hMarkValue : markValue e = 0) :
    d.markRiseIn potential markValue e = 0
    theorem AtanasovRanganathan.ConfigurationSeven.markRiseOut_head (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {potential : Fin 8 → ℤ} {markValue : Fin 12 → ℤ} {e : Fin 12} {height : ℕ} (hCentre : potential (d.rep (d.core.head e)) = -↑height) (hMarkValue : markValue e = 0) :
    d.markRiseOut potential markValue e = -↑height
    theorem AtanasovRanganathan.ConfigurationSeven.headArm_tail (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {potential : Fin 8 → ℤ} {mark : Fin 12 → ℕ} {markValue : Fin 12 → ℤ} {e : Fin 12} (hMarks : d.MarksAdmissible potential mark markValue) (hTail : potential (d.rep (d.core.tail e)) = 0) (hMarkValue : markValue e = 0) (hPos : 0 < mark e) :
    Utilities.Certificate.SubdivisionArithmetic.splitStep (d.length e) (mark e) (d.markRiseIn potential markValue e) (d.markRiseOut potential markValue e) 0 = 0

    The near end of a marked arm read from its head receives nothing.

    theorem AtanasovRanganathan.ConfigurationSeven.headArm_centre (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {potential : Fin 8 → ℤ} {mark : Fin 12 → ℕ} {markValue : Fin 12 → ℤ} {e : Fin 12} {height : ℕ} (hMarks : d.MarksAdmissible potential mark markValue) (hCentre : potential (d.rep (d.core.head e)) = -↑height) (hMarkValue : markValue e = 0) (hPos : 0 < d.length e) (hLt : mark e < d.length e) :
    -Utilities.Certificate.SubdivisionArithmetic.splitStep (d.length e) (mark e) (d.markRiseIn potential markValue e) (d.markRiseOut potential markValue e) (d.length e - 1) = -Utilities.Certificate.SubdivisionArithmetic.step (d.length e - mark e) (-↑height) (d.length e - mark e - 1)

    What the centre receives along a marked arm read from its head: minus the last slope of the canonical ramp of rise -height over length e - mark e steps.

    theorem AtanasovRanganathan.ConfigurationSeven.headArm_centre_eq_one (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {potential : Fin 8 → ℤ} {mark : Fin 12 → ℕ} {markValue : Fin 12 → ℤ} {e : Fin 12} {height : ℕ} (hMarks : d.MarksAdmissible potential mark markValue) (hCentre : potential (d.rep (d.core.head e)) = -↑height) (hMarkValue : markValue e = 0) (hPos : 0 < d.length e) (hLt : mark e < d.length e) (hFull : height = d.length e - mark e) :
    -Utilities.Certificate.SubdivisionArithmetic.splitStep (d.length e) (mark e) (d.markRiseIn potential markValue e) (d.markRiseOut potential markValue e) (d.length e - 1) = 1

    A shortest marked arm delivers one chip to its centre, read from the head.

    theorem AtanasovRanganathan.ConfigurationSeven.headArm_centre_nonneg (d : Utilities.Certificate.DegenerateSpec.DegSpec 8 12) {potential : Fin 8 → ℤ} {mark : Fin 12 → ℕ} {markValue : Fin 12 → ℤ} {e : Fin 12} {height : ℕ} (hMarks : d.MarksAdmissible potential mark markValue) (hCentre : potential (d.rep (d.core.head e)) = -↑height) (hMarkValue : markValue e = 0) (hPos : 0 < d.length e) (hLt : mark e < d.length e) (hHeight : 0 < height) (hLe : height ≤ d.length e - mark e) :
    0 ≤ -Utilities.Certificate.SubdivisionArithmetic.splitStep (d.length e) (mark e) (d.markRiseIn potential markValue e) (d.markRiseOut potential markValue e) (d.length e - 1)

    A marked arm never takes a chip away from its centre, read from the head.