Documentation

LeanPool.BrillNoetherGraphs.Utilities.Subdivision.SpecBurning

Burning along a subdivided slot #

The burned-set layer of Utilities/Gonality/BurnedSet.lean is stated for an arbitrary CFGraph. On a subdivision the fire propagates along slots, and the moves used over and over by van Dobben de Bruyn–Smit–van der Wegen's §3 are:

The cycle lemma is stated via two internally disjoint arcs rather than via distinct interior vertices, which is what makes it cover the banana case (both slots of length one, so the cycle has only two vertices). There the two witnesses coincide at the unburned endpoint, whose two edges to the burned endpoint are parallel, and the edge multiplicity supplies the second chip (two_le_num_edges_of_parallel_unit). Getting this case right is what makes the minimal tricycle T_m itself tractable, not merely its simple refinements.

Numerical slot positions #

spec.slotVertex e k is the vertex at position k along slot e, clamped to the slot so that no proof obligation rides along. Position 0 is the core tail, position spec.length e the core head, and the positions strictly between are the slot interior. Statements carry explicit k ≤ spec.length e hypotheses wherever clamping would otherwise silently change the meaning.

theorem Utilities.Gonality.two_le_sum_of_two_chips {G : CFGraph} {D : CFDiv G} (hEff : effective D) {S : Finset G.V} {x y : G.V} (hx : x ∈ S) (hy : y ∈ S) (hxy : x ≠ y) (hx1 : 1 ≤ D x) (hy1 : 1 ≤ D y) :
2 ≤ ∑ v ∈ S, D v

Two distinct chipped vertices of a set carry at least two chips between them, when the divisor is effective elsewhere.

theorem Utilities.Gonality.two_le_sum_of_double_chip {G : CFGraph} {D : CFDiv G} (hEff : effective D) {S : Finset G.V} {x : G.V} (hx : x ∈ S) (hx2 : 2 ≤ D x) :
2 ≤ ∑ v ∈ S, D v

One doubly chipped vertex of a set does as well.

theorem Utilities.Gonality.two_le_of_two_burned_neighbours {G : CFGraph} {D : CFDiv G} {q x u₁ u₂ : G.V} (hx : x ∉ burned G D q) (h1 : u₁ ∈ burned G D q) (h2 : u₂ ∈ burned G D q) (hne : u₁ ≠ u₂) (hp1 : 0 < numEdges G x u₁) (hp2 : 0 < numEdges G x u₂) :
2 ≤ D x

Two distinct burned neighbours of an unburned vertex cost it two chips.

theorem Utilities.Gonality.two_le_of_double_burned_edge {G : CFGraph} {D : CFDiv G} {q x u : G.V} (hx : x ∉ burned G D q) (hu : u ∈ burned G D q) (hp : 2 ≤ numEdges G x u) :
2 ≤ D x

A doubled edge to the fire costs an unburned vertex two chips.

theorem Utilities.Gonality.one_le_of_burned_neighbour {G : CFGraph} {D : CFDiv G} {q x u : G.V} (hx : x ∉ burned G D q) (hu : u ∈ burned G D q) (hp : 0 < numEdges G x u) :
1 ≤ D x

One burned neighbour costs an unburned vertex a chip.

Numerical positions along a slot #

def Utilities.Certificate.SubdivisionGraph.Spec.slotVertex {n p : ℕ} (spec : Spec n p) (edge : Fin p) (k : ℕ) :
spec.Vertex

The vertex at numerical position k along slot e, clamped to the slot.

Equations
Instances For

    The vertices of the closed subdivided slot edge.

    Equations
    Instances For
      theorem Utilities.Certificate.SubdivisionGraph.Spec.slotVertex_of_le {n p : ℕ} {spec : Spec n p} {edge : Fin p} {k : ℕ} (hk : k ≤ spec.length edge) :
      spec.slotVertex edge k = spec.pathVertex edge ⟨k, ⋯⟩
      @[simp]
      theorem Utilities.Certificate.SubdivisionGraph.Spec.slotVertex_zero {n p : ℕ} {spec : Spec n p} (edge : Fin p) :
      spec.slotVertex edge 0 = spec.coreVertex (spec.core.tail edge)
      @[simp]
      theorem Utilities.Certificate.SubdivisionGraph.Spec.slotVertex_length {n p : ℕ} {spec : Spec n p} (edge : Fin p) :
      spec.slotVertex edge (spec.length edge) = spec.coreVertex (spec.core.head edge)
      theorem Utilities.Certificate.SubdivisionGraph.Spec.mem_slotClosed {n p : ℕ} {spec : Spec n p} {edge : Fin p} {k : ℕ} (hk : k ≤ spec.length edge) :
      spec.slotVertex edge k ∈ spec.slotClosed edge
      theorem Utilities.Certificate.SubdivisionGraph.Spec.slotVertex_eq_interiorVertex {n p : ℕ} {spec : Spec n p} {edge : Fin p} {k : ℕ} (hk : 0 < k) (hk' : k < spec.length edge) :
      spec.slotVertex edge k = spec.interiorVertex edge ⟨k - 1, ⋯⟩

      Interior positions name interior vertices, hence remember their slot.

      theorem Utilities.Certificate.SubdivisionGraph.Spec.slotVertex_ne_coreVertex {n p : ℕ} {spec : Spec n p} {edge : Fin p} {k : ℕ} (hk : 0 < k) (hk' : k < spec.length edge) (v : Fin n) :
      spec.slotVertex edge k ≠ spec.coreVertex v
      theorem Utilities.Certificate.SubdivisionGraph.Spec.slotVertex_ne_of_slot_ne {n p : ℕ} {spec : Spec n p} {e e' : Fin p} (hee : e ≠ e') {k k' : ℕ} (hk : 0 < k) (hk' : k < spec.length e) (hl : 0 < k') (hl' : k' < spec.length e') :
      spec.slotVertex e k ≠ spec.slotVertex e' k'

      Interior positions in distinct slots are distinct vertices.

      theorem Utilities.Certificate.SubdivisionGraph.Spec.slotVertex_injOn {n p : ℕ} {spec : Spec n p} {edge : Fin p} {k k' : ℕ} (hk : k ≤ spec.length edge) (hk' : k' ≤ spec.length edge) (h : spec.slotVertex edge k = spec.slotVertex edge k') :
      k = k'

      Distinct positions in one slot are distinct vertices.

      theorem Utilities.Certificate.SubdivisionGraph.Spec.slotVertex_num_edges_pos {n p : ℕ} {spec : Spec n p} {edge : Fin p} {k : ℕ} (hk : k < spec.length edge) :
      0 < numEdges spec.graph (spec.slotVertex edge k) (spec.slotVertex edge (k + 1))

      Consecutive positions along a slot are adjacent.

      theorem Utilities.Certificate.SubdivisionGraph.Spec.slotVertex_num_edges_pos' {n p : ℕ} {spec : Spec n p} {edge : Fin p} {k : ℕ} (hk : k < spec.length edge) :
      0 < numEdges spec.graph (spec.slotVertex edge (k + 1)) (spec.slotVertex edge k)
      theorem Utilities.Certificate.SubdivisionGraph.Spec.two_le_num_edges_of_parallel_unit {n p : ℕ} {spec : Spec n p} {e₁ e₂ : Fin p} (hne : e₁ ≠ e₂) (h1 : spec.length e₁ = 1) (h2 : spec.length e₂ = 1) (htail : spec.core.tail e₂ = spec.core.tail e₁) (hhead : spec.core.head e₂ = spec.core.head e₁) :
      2 ≤ numEdges spec.graph (spec.coreVertex (spec.core.head e₁)) (spec.coreVertex (spec.core.tail e₁))

      Parallel unit slots double an edge multiplicity. This is the ingredient that makes the banana case of two_le_chips_of_cycle work.

      Chips, counted slot by slot #

      Every chip count in the tricycle argument is a linear combination of the n core-vertex values and the p slot-interior totals, so the bookkeeping of Lemma 3.6 never needs a Finset union. This is the mitigation of blueprint risk R1, one step further than the blueprint's own suggestion: not merely a disjoint partition, but a coordinate system.

      The chips on the interior of slot edge.

      Equations
      Instances For
        theorem Utilities.Certificate.SubdivisionGraph.Spec.slotInteriorChips_nonneg {n p : ℕ} {spec : Spec n p} {D : CFDiv spec.graph} (hEff : effective D) (edge : Fin p) :
        0 ≤ spec.slotInteriorChips D edge
        theorem Utilities.Certificate.SubdivisionGraph.Spec.deg_eq_core_add_slotInteriorChips {n p : ℕ} {spec : Spec n p} (D : CFDiv spec.graph) :
        CFDiv.degree D = ∑ v : Fin n, D (spec.coreVertex v) + ∑ edge : Fin p, spec.slotInteriorChips D edge

        The coordinate system. Total degree splits as the core-vertex values plus the slot-interior totals.

        theorem Utilities.Certificate.SubdivisionGraph.Spec.apply_slotVertex_le_slotInteriorChips {n p : ℕ} {spec : Spec n p} {D : CFDiv spec.graph} (hEff : effective D) {edge : Fin p} {k : ℕ} (hk : 0 < k) (hk' : k < spec.length edge) :
        D (spec.slotVertex edge k) ≤ spec.slotInteriorChips D edge

        A chip at an interior position is one of the slot's interior chips.

        Chip-free stretches burn #

        theorem Utilities.Certificate.SubdivisionGraph.Spec.mem_burned_slotVertex_of_chipFree_up {n p : ℕ} {spec : Spec n p} {D : CFDiv spec.graph} {w : spec.Vertex} {edge : Fin p} {a b : ℕ} (ha : spec.slotVertex edge a ∈ Gonality.burned spec.graph D w) (hab : a ≤ b) (hb : b ≤ spec.length edge) (hfree : ∀ (k : ℕ), a < k → k ≤ b → D (spec.slotVertex edge k) ≤ 0) :
        spec.slotVertex edge b ∈ Gonality.burned spec.graph D w

        The fire runs up a chip-free stretch of a slot.

        theorem Utilities.Certificate.SubdivisionGraph.Spec.mem_burned_slotVertex_of_chipFree_down {n p : ℕ} {spec : Spec n p} {D : CFDiv spec.graph} {w : spec.Vertex} {edge : Fin p} {a b : ℕ} (ha : spec.slotVertex edge a ∈ Gonality.burned spec.graph D w) (hba : b ≤ a) (ha' : a ≤ spec.length edge) (hfree : ∀ (k : ℕ), b ≤ k → k < a → D (spec.slotVertex edge k) ≤ 0) :
        spec.slotVertex edge b ∈ Gonality.burned spec.graph D w

        The fire runs down a chip-free stretch of a slot.

        A burned/unburned split costs a chip #

        theorem Utilities.Certificate.SubdivisionGraph.Spec.exists_burned_boundary_up {n p : ℕ} {spec : Spec n p} {D : CFDiv spec.graph} {w : spec.Vertex} {edge : Fin p} {a b : ℕ} (ha : spec.slotVertex edge a ∈ Gonality.burned spec.graph D w) (hb : spec.slotVertex edge b ∉ Gonality.burned spec.graph D w) (hab : a ≤ b) (hble : b ≤ spec.length edge) :
        ∃ (k : ℕ), a < k ∧ k ≤ b ∧ spec.slotVertex edge (k - 1) ∈ Gonality.burned spec.graph D w ∧ spec.slotVertex edge k ∉ Gonality.burned spec.graph D w

        Between a burned position and a later unburned one there is a boundary: an unburned position whose predecessor is burned.

        theorem Utilities.Certificate.SubdivisionGraph.Spec.exists_burned_boundary_down {n p : ℕ} {spec : Spec n p} {D : CFDiv spec.graph} {w : spec.Vertex} {edge : Fin p} {a b : ℕ} (ha : spec.slotVertex edge a ∈ Gonality.burned spec.graph D w) (hb : spec.slotVertex edge b ∉ Gonality.burned spec.graph D w) (hba : b ≤ a) (_hale : a ≤ spec.length edge) :
        ∃ (k : ℕ), b ≤ k ∧ k < a ∧ spec.slotVertex edge (k + 1) ∈ Gonality.burned spec.graph D w ∧ spec.slotVertex edge k ∉ Gonality.burned spec.graph D w

        The downward boundary.

        theorem Utilities.Certificate.SubdivisionGraph.Spec.exists_chip_up {n p : ℕ} {spec : Spec n p} {D : CFDiv spec.graph} {w : spec.Vertex} {edge : Fin p} {a b : ℕ} (ha : spec.slotVertex edge a ∈ Gonality.burned spec.graph D w) (hb : spec.slotVertex edge b ∉ Gonality.burned spec.graph D w) (hab : a ≤ b) (hble : b ≤ spec.length edge) :
        ∃ (k : ℕ), a < k ∧ k ≤ b ∧ 1 ≤ D (spec.slotVertex edge k) ∧ spec.slotVertex edge (k - 1) ∈ Gonality.burned spec.graph D w ∧ spec.slotVertex edge k ∉ Gonality.burned spec.graph D w

        Going up: a burned/unburned split costs a chip.

        theorem Utilities.Certificate.SubdivisionGraph.Spec.exists_chip_down {n p : ℕ} {spec : Spec n p} {D : CFDiv spec.graph} {w : spec.Vertex} {edge : Fin p} {a b : ℕ} (ha : spec.slotVertex edge a ∈ Gonality.burned spec.graph D w) (hb : spec.slotVertex edge b ∉ Gonality.burned spec.graph D w) (hba : b ≤ a) (hale : a ≤ spec.length edge) :
        ∃ (k : ℕ), b ≤ k ∧ k < a ∧ 1 ≤ D (spec.slotVertex edge k) ∧ spec.slotVertex edge (k + 1) ∈ Gonality.burned spec.graph D w ∧ spec.slotVertex edge k ∉ Gonality.burned spec.graph D w

        Going down: a burned/unburned split costs a chip.

        Cycle blocking #

        theorem Utilities.Certificate.SubdivisionGraph.Spec.two_le_chips_of_cycle_tail_burned {n p : ℕ} {spec : Spec n p} {D : CFDiv spec.graph} {w : spec.Vertex} (hEff : effective D) {e₁ e₂ : Fin p} (hne : e₁ ≠ e₂) (htail : spec.core.tail e₂ = spec.core.tail e₁) (hhead : spec.core.head e₂ = spec.core.head e₁) (hu : spec.coreVertex (spec.core.tail e₁) ∈ Gonality.burned spec.graph D w) (hu' : spec.coreVertex (spec.core.head e₁) ∉ Gonality.burned spec.graph D w) :
        2 ≤ D (spec.coreVertex (spec.core.head e₁)) + spec.slotInteriorChips D e₁ + spec.slotInteriorChips D e₂

        Cycle blocking, tail burned. Two distinct slots with the same endpoints form a cycle. If the common tail is burned and the common head is not, the cycle carries at least two chips — counted in the slot coordinate system, so the statement is a linear inequality ready for omega.

        The coincidence branch — both boundary witnesses landing on the unburned head — is exactly the banana case (length e₁ = length e₂ = 1), and is where the parallel-edge multiplicity supplies the second chip.

        theorem Utilities.Certificate.SubdivisionGraph.Spec.two_le_chips_of_cycle_head_burned {n p : ℕ} {spec : Spec n p} {D : CFDiv spec.graph} {w : spec.Vertex} (hEff : effective D) {e₁ e₂ : Fin p} (hne : e₁ ≠ e₂) (htail : spec.core.tail e₂ = spec.core.tail e₁) (hhead : spec.core.head e₂ = spec.core.head e₁) (hu : spec.coreVertex (spec.core.head e₁) ∈ Gonality.burned spec.graph D w) (hu' : spec.coreVertex (spec.core.tail e₁) ∉ Gonality.burned spec.graph D w) :
        2 ≤ D (spec.coreVertex (spec.core.tail e₁)) + spec.slotInteriorChips D e₁ + spec.slotInteriorChips D e₂

        Cycle blocking, head burned. The mirror image of two_le_chips_of_cycle_tail_burned.