Documentation

LeanPool.BrillNoetherGraphs.Utilities.Pseudocore.PseudocorePresentation

WP-A: the pseudocore presentation theorem #

This module builds, for an arbitrary connected leafless graph, a subdivision presentation over a small core: one in which every core vertex either has core valence at least three, or is a bivalent marker whose two slots run to a common neighbour. That shape is exactly the loopless split of a loop-aware pseudocore, which is what Certificate/PseudocoreSplitGlue.lean consumes.

The construction is genus-generic. Its engine is a single merge step at the level of subdivision specifications:

Both are proved by exhibiting the larger specification as a SubdivisionGraph.Spec.Relabeling of the canonical one-slot split (OneEdgeSplitRefinement.splitSpec) of the smaller one, so no new vertex/unit-step bijection has to be built by hand: the split's own canonicalSplitLaplacianEquiv supplies it.

Shrinking Fin (m + 1) away from its last element #

A total left inverse of Fin.castSucc, defaulting to 0.

Equations
Instances For
    theorem Utilities.Certificate.PseudocorePresentation.castSucc_shrink {m : ℕ} (hm : 0 < m) {x : Fin (m + 1)} (hx : x ≠ Fin.last m) :
    (shrink hm x).castSucc = x
    theorem Utilities.Certificate.PseudocorePresentation.shrink_injective_of_ne_last {m : ℕ} (hm : 0 < m) {x y : Fin (m + 1)} (hx : x ≠ Fin.last m) (hy : y ≠ Fin.last m) (h : shrink hm x = shrink hm y) :
    x = y

    Slot ends at a core vertex #

    The set of slot ends at a core vertex. (edge, true) is the head end of edge and (edge, false) its tail end.

    Equations
    Instances For

      Core valence: the number of slot ends at a core vertex.

      Equations
      Instances For
        theorem Utilities.Certificate.PseudocorePresentation.mem_slotEnds {n p : ℕ} (core : ExplicitPotential.Core n p) (vertex : Fin n) (x : Fin p × Bool) :
        x ∈ slotEnds core vertex ↔ if x.2 = true then core.head x.1 = vertex else core.tail x.1 = vertex

        The far endpoint of a slot end.

        Equations
        Instances For

          The merge step #

          theorem Utilities.Certificate.PseudocorePresentation.swap_ne_last {m : ℕ} (v : Fin (m + 1)) {x : Fin (m + 1)} (hx : x ≠ v) :

          Swapping a vertex with the last index moves nothing else onto the last index.

          Witness that a core vertex carries exactly two slot ends, lying on two distinct slots whose far endpoints differ. Such a vertex is a genuine subdivision point and can be suppressed.

          Instances For
            theorem Utilities.Certificate.PseudocorePresentation.MergeData.slot_eq_of_tail {n p : ℕ} {core : ExplicitPotential.Core n p} (data : MergeData core) (_hLoopless : ∀ (edge : Fin p), core.tail edge ≠ core.head edge) {edge : Fin p} (hEdge : core.tail edge = data.vertex) :
            edge = data.first.1 ∨ edge = data.second.1
            theorem Utilities.Certificate.PseudocorePresentation.MergeData.slot_eq_of_head {n p : ℕ} {core : ExplicitPotential.Core n p} (data : MergeData core) (_hLoopless : ∀ (edge : Fin p), core.tail edge ≠ core.head edge) {edge : Fin p} (hEdge : core.head edge = data.vertex) :
            edge = data.first.1 ∨ edge = data.second.1
            theorem Utilities.Certificate.PseudocorePresentation.exists_merge {n p : ℕ} (spec : SubdivisionGraph.Spec (n + 1) (p + 1)) (hn : 0 < n) (hp : 0 < p) (data : MergeData spec.core) :
            ∃ (spec' : SubdivisionGraph.Spec n p), Nonempty (LaplacianEquiv spec.graph spec'.graph)

            Suppressing a bivalent core vertex preserves the subdivided graph. The smaller specification is obtained by concatenating the two slots at the vertex; the equality of graphs is read off from the canonical one-slot split of the smaller specification.

            Iterating the merge step #

            Every subdivision specification presents its graph over a reduced core.

            Valence of a core vertex inside the subdivided graph #

            theorem Utilities.Certificate.PseudocorePresentation.slotValence_eq_natSum {n p : ℕ} (core : ExplicitPotential.Core n p) (v : Fin n) :
            slotValence core v = ∑ edge : Fin p, ((if core.tail edge = v then 1 else 0) + if core.head edge = v then 1 else 0)
            theorem Utilities.Certificate.PseudocorePresentation.slotValence_eq_sum {n p : ℕ} (core : ExplicitPotential.Core n p) (v : Fin n) :
            ↑(slotValence core v) = ∑ edge : Fin p, ((if core.tail edge = v then 1 else 0) + if core.head edge = v then 1 else 0)

            Handshake at the core: every slot has two ends.

            theorem Utilities.Certificate.PseudocorePresentation.card_incidentSlots {n p : ℕ} (core : ExplicitPotential.Core n p) (hLoopless : ∀ (edge : Fin p), core.tail edge ≠ core.head edge) (v : Fin n) :
            {edge : Fin p | core.tail edge = v ∨ core.head edge = v}.card = slotValence core v

            Slots incident to a vertex, counted without their orientation.

            Reading off the shape of a reduced core #

            theorem Utilities.Certificate.PseudocorePresentation.exists_marker_pair {n p : ℕ} {core : ExplicitPotential.Core n p} (hLoopless : ∀ (edge : Fin p), core.tail edge ≠ core.head edge) (hReduced : Reduced core) (v : Fin n) (hVal : slotValence core v = 2) :
            ∃ (x : Fin p × Bool) (y : Fin p × Bool), x ∈ slotEnds core v ∧ y ∈ slotEnds core v ∧ x.1 ≠ y.1 ∧ (∀ z ∈ slotEnds core v, z = x ∨ z = y) ∧ farEnd core x = farEnd core y

            In a reduced loopless core, a vertex with exactly two slot ends carries them on two distinct slots running to one common neighbour.

            Core connectedness from graph connectedness #

            The side of a vertex cut of the core that a subdivision vertex lies on: core vertices by themselves, interior vertices by the tail of their slot.

            Equations
            Instances For
              theorem Utilities.Certificate.PseudocorePresentation.sideOf_stepLeft {n p : ℕ} (spec : SubdivisionGraph.Spec n p) (S : Finset (Fin n)) (edge : Fin p) (offset : Fin (spec.length edge)) :
              sideOf spec S (spec.stepLeft edge offset) ↔ spec.core.tail edge ∈ S
              theorem Utilities.Certificate.PseudocorePresentation.sideOf_stepRight {n p : ℕ} (spec : SubdivisionGraph.Spec n p) (S : Finset (Fin n)) (edge : Fin p) (offset : Fin (spec.length edge)) (hNoCross : spec.core.tail edge ∈ S ↔ spec.core.head edge ∈ S) :
              sideOf spec S (spec.stepRight edge offset) ↔ spec.core.head edge ∈ S

              Cut connectedness of the subdivided graph implies cut connectedness of the core. This is the converse of graph_connected_of_coreConnected.

              Unordered multiplicities of a core #

              theorem Utilities.Certificate.PseudocorePresentation.sum_explicitCoreMultiplicity {n p : ℕ} (core : ExplicitPotential.Core n p) (hLoopless : ∀ (edge : Fin p), core.tail edge ≠ core.head edge) (v : Fin n) :

              Total unordered multiplicity at a vertex is its slot valence.

              The shape of a reduced core #

              A core presented as the loopless split of a loop-aware pseudocore: every vertex is either stable, or a marker carrying exactly two slots to a single stable partner.

              Instances For

                Building the marked shape of a reduced core #

                theorem Utilities.Certificate.PseudocorePresentation.marker_structure {N P : ℕ} {spec : SubdivisionGraph.Spec N P} (hReduced : Reduced spec.core) (v : Fin N) (hVal : slotValence spec.core v = 2) :
                ∃ (w : Fin N), w ≠ v ∧ (∀ (edge : Fin P), spec.core.tail edge = v → spec.core.head edge = w) ∧ ∀ (edge : Fin P), spec.core.head edge = v → spec.core.tail edge = w

                In a reduced core, a vertex with exactly two slot ends has all of its slots running to one common neighbour.

                theorem Utilities.Certificate.PseudocorePresentation.mult_eq_slotValence_of_structure {N P : ℕ} {spec : SubdivisionGraph.Spec N P} {v w : Fin N} (hTail : ∀ (edge : Fin P), spec.core.tail edge = v → spec.core.head edge = w) (hHead : ∀ (edge : Fin P), spec.core.head edge = v → spec.core.tail edge = w) :
                theorem Utilities.Certificate.PseudocorePresentation.mult_eq_zero_of_structure {N P : ℕ} {spec : SubdivisionGraph.Spec N P} {v w u : Fin N} (hNe : u ≠ w) (hTail : ∀ (edge : Fin P), spec.core.tail edge = v → spec.core.head edge = w) (hHead : ∀ (edge : Fin P), spec.core.head edge = v → spec.core.tail edge = w) :
                theorem Utilities.Certificate.PseudocorePresentation.partner_not_bivalent_of_genus_ne_one {N P : ℕ} {spec : SubdivisionGraph.Spec N P} (hReduced : Reduced spec.core) (hConnected : graphConnected spec.graph) {g : ℕ} (hGenus : spec.graph.genus = ↑g) (hGenus_ne_one : g ≠ 1) {v w : Fin N} (hvw : w ≠ v) (hVal : slotValence spec.core v = 2) (hTail : ∀ (edge : Fin P), spec.core.tail edge = v → spec.core.head edge = w) (hHead : ∀ (edge : Fin P), spec.core.head edge = v → spec.core.tail edge = w) :

                Two adjacent bivalent vertices would exhaust the graph, which has genus one.

                theorem Utilities.Certificate.PseudocorePresentation.exists_markedShapeAt {N P g : ℕ} (spec : SubdivisionGraph.Spec N P) (hReduced : Reduced spec.core) (hConnected : graphConnected spec.graph) (hGenus : spec.graph.genus = ↑g) (hGenus_ne_one : g ≠ 1) (hDegree : ∀ (v : Fin N), 2 ≤ slotValence spec.core v) :

                Shape of a reduced presentation. Every vertex of a reduced core is either stable or a bivalent marker attached to a single stable base.

                theorem Utilities.Certificate.PseudocorePresentation.exists_markedShape {N P : ℕ} (spec : SubdivisionGraph.Spec N P) (hReduced : Reduced spec.core) (hConnected : graphConnected spec.graph) (hGenus : spec.graph.genus = 4) (hDegree : ∀ (v : Fin N), 2 ≤ slotValence spec.core v) :

                The genus-four specialization of exists_markedShapeAt.

                Encoding a marked shape as a pseudocore with split metadata #

                theorem Utilities.Certificate.PseudocorePresentation.MarkedShape.head_eq_partner {N P : ℕ} {spec : SubdivisionGraph.Spec N P} (shape : MarkedShape spec) (v : Fin N) (hv : shape.isMarker v = true) (edge : Fin P) (hEdge : spec.core.tail edge = v) :
                spec.core.head edge = shape.partner v
                theorem Utilities.Certificate.PseudocorePresentation.MarkedShape.tail_eq_partner {N P : ℕ} {spec : SubdivisionGraph.Spec N P} (shape : MarkedShape spec) (v : Fin N) (hv : shape.isMarker v = true) (edge : Fin P) (hEdge : spec.core.head edge = v) :
                spec.core.tail edge = shape.partner v
                theorem Utilities.Certificate.PseudocorePresentation.pseudocorePresentation_of_markedShapeAt {N P g : ℕ} (spec : SubdivisionGraph.Spec N P) (shape : MarkedShape spec) (hConnected : graphConnected spec.graph) (hGenus : spec.graph.genus = ↑g) {G : CFGraph} (hG : Nonempty (LaplacianEquiv G spec.graph)) :
                ∃ (k : ℕ) (core : GenusFourPseudocore.Pseudocore k) (split : core.SplitMetadata), k ≤ 2 * (g - 1) ∧ core.ValidAt g ∧ PseudocoreSplitGlue.Compatible split ∧ ∃ (spec' : SubdivisionGraph.Spec (k + core.loopCount) core.splitEdgeCount), spec'.core = split.splitCore ∧ Nonempty (LaplacianEquiv G spec'.graph)

                The pseudocore encoding. A marked-shape presentation of a connected genus-g graph is the loopless split of a valid pseudocore on at most 2 * (g - 1) vertices.

                The genus-four specialization of pseudocorePresentation_of_markedShapeAt.

                theorem Utilities.Certificate.PseudocorePresentation.pseudocorePresentation_of_leafless {g : ℕ} (G : CFGraph) (hConnected : graphConnected G) (hGenus : G.genus = ↑g) (hGenusLower : 2 ≤ g) (hLeafless : ∀ (vertex : G.V), vertexDegree G vertex ≠ 1) :
                ∃ (k : ℕ) (core : GenusFourPseudocore.Pseudocore k) (split : core.SplitMetadata), k ≤ 2 * (g - 1) ∧ core.ValidAt g ∧ PseudocoreSplitGlue.Compatible split ∧ ∃ (spec : SubdivisionGraph.Spec (k + core.loopCount) core.splitEdgeCount), spec.core = split.splitCore ∧ Nonempty (LaplacianEquiv G spec.graph)

                Every connected leafless graph of genus at least two is Laplacian-equivalent to a positive subdivision of the loopless split of a valid pseudocore on at most 2(g-1) base vertices.

                theorem Utilities.Certificate.PseudocorePresentation.pseudocorePresentation_genusFive (G : CFGraph) (hConnected : graphConnected G) (hGenus : G.genus = 5) (hLeafless : ∀ (vertex : G.V), vertexDegree G vertex ≠ 1) :

                Every connected leafless genus-five graph is Laplacian-equivalent to a positive subdivision of the loopless split of a valid genus-five pseudocore on at most eight vertices.