Documentation

LeanPool.BrillNoetherGraphs.Utilities.Segments.AtanasovRanganathanConfigurations

Reusable Atanasov--Ranganathan configuration moves #

The seven pictures in Atanasov--Ranganathan, Lemma 4.1, are local Dhar calculations. This file records the common proof interface independently of those pictures: a configuration supplies an integral firing script whose removed-chip residual is effective, hence a StrongSeparator.Reaches fact.

Two geometric patterns are isolated here.

The paper's diagrams do not specify an ordered core-slot encoding, edge orientations, or which dashed half-edge continues outside each solid configuration. Consequently this module does not assert that a numbered picture, or Core 095, has been encoded. It gives the reusable checked moves to which such incidence data must eventually be connected.

A uniform interface for one Dhar calculation #

structure AtanasovRanganathan.Configurations.DharMove (G : CFGraph) (D : CFDiv G) (target : G.V) :
Type u_1

One local Dhar calculation: after removing the target chip, the displayed integral firing script leaves an effective residual.

  • script : firingScript G

    The integral firing script whose principal divisor makes the residual effective after subtracting a chip at the target.

  • residual_effective : effective (D - oneChip target + (prin G) self.script)
Instances For

    A checked local Dhar move proves the corresponding reachability fact.

    def AtanasovRanganathan.Configurations.DharMove.ofScript {G : CFGraph} {D : CFDiv G} {target : G.V} (script : firingScript G) (hEffective : effective (D - oneChip target + (prin G) script)) :
    DharMove G D target

    Conversely, an explicit effective representative and its firing script can be packaged as a local move without mentioning linear equivalence again.

    Equations
    Instances For
      noncomputable def AtanasovRanganathan.Configurations.DharMove.ofReaches {G : CFGraph} {D : CFDiv G} {target : G.V} (hReach : Utilities.Certificate.StrongSeparator.Reaches G D target) :
      DharMove G D target

      A reachability proof already contains a firing script: unfold its effective representative and extract the principal divisor witnessing linear equivalence. This converse is noncomputable only because Reaches is stated existentially; the resulting DharMove is checked by the same residual effectivity field as a hand-authored move.

      Equations
      Instances For
        noncomputable def AtanasovRanganathan.Configurations.DharMove.ofRankOne {G : CFGraph} {D : CFDiv G} (hRank : rank G D ≥ 1) (target : G.V) :
        DharMove G D target

        Rank at least one supplies a checked Dhar move at every target. This is the useful converse to DharMove.reaches when a row is proved by a global rank argument (for example a strong-separator or transmission theorem) rather than by retaining its local scripts as primary data.

        Equations
        Instances For
          theorem AtanasovRanganathan.Configurations.rank_ge_one_of_dharMoves_off_support {G : CFGraph} (D : CFDiv G) (hEffective : effective D) (hMoves : (vertex : G.V) → D vertex = 0 → DharMove G D vertex) :
          rank G D ≥ 1

          Configuration version of the off-support lemma: it is enough to attach a local Dhar move to every vertex outside the support of an effective divisor.

          theorem AtanasovRanganathan.Configurations.bnExists_one_of_dharMoves_off_support {G : CFGraph} (D : CFDiv G) (hEffective : effective D) {degree : ℤ} (hDegree : CFDiv.degree D = degree) (hMoves : (vertex : G.V) → D vertex = 0 → DharMove G D vertex) :

          Degree bookkeeping for a configuration proof of any rank-one pencil.

          theorem AtanasovRanganathan.Configurations.bnExists_one_three_of_dharMoves_off_support {G : CFGraph} (D : CFDiv G) (hEffective : effective D) (hDegree : CFDiv.degree D = 3) (hMoves : (vertex : G.V) → D vertex = 0 → DharMove G D vertex) :

          Degree-three specialization retained for the genus-four configurations.

          Three-chip divisors with a named moving chip #

          The degree-three divisor used throughout the genus-four pictures. The three vertices need not be distinct.

          Equations
          Instances For
            @[simp]
            theorem AtanasovRanganathan.Configurations.deg_threeChipDivisor {G : CFGraph} (first second third : G.V) :
            CFDiv.degree (threeChipDivisor first second third) = 3
            theorem AtanasovRanganathan.Configurations.threeChipDivisor_has_chip_first {G : CFGraph} (first second third : G.V) :
            1 ≤ threeChipDivisor first second third first
            theorem AtanasovRanganathan.Configurations.threeChipDivisor_has_chip_second {G : CFGraph} (first second third : G.V) :
            1 ≤ threeChipDivisor first second third second
            theorem AtanasovRanganathan.Configurations.threeChipDivisor_has_chip_third {G : CFGraph} (first second third : G.V) :
            1 ≤ threeChipDivisor first second third third
            theorem AtanasovRanganathan.Configurations.threeChipDivisor_reaches_of_eq {G : CFGraph} (first second third target : G.V) (hTarget : target = first ∨ target = second ∨ target = third) :

            Every displayed chip position is automatically reached; Dhar moves are needed only away from these three positions.

            def AtanasovRanganathan.Configurations.MovingDivisor.atMinLength {n p : ℕ} (spec : Utilities.Certificate.SubdivisionGraph.Spec n p) (movingEdge leftLength rightLength : Fin p) (hBound : min (spec.length leftLength) (spec.length rightLength) ≤ spec.length movingEdge) (fixedFirst fixedSecond : spec.Vertex) :

            A three-chip divisor whose first chip is at the min(a,b) position used in the sixth and seventh configurations of the paper.

            Equations
            • One or more equations did not get rendered due to their size.
            Instances For
              @[simp]
              theorem AtanasovRanganathan.Configurations.MovingDivisor.deg_atMinLength {n p : ℕ} (spec : Utilities.Certificate.SubdivisionGraph.Spec n p) (movingEdge leftLength rightLength : Fin p) (hBound : min (spec.length leftLength) (spec.length rightLength) ≤ spec.length movingEdge) (fixedFirst fixedSecond : spec.Vertex) :
              CFDiv.degree (atMinLength spec movingEdge leftLength rightLength hBound fixedFirst fixedSecond) = 3
              theorem AtanasovRanganathan.Configurations.MovingDivisor.effective_atMinLength {n p : ℕ} (spec : Utilities.Certificate.SubdivisionGraph.Spec n p) (movingEdge leftLength rightLength : Fin p) (hBound : min (spec.length leftLength) (spec.length rightLength) ≤ spec.length movingEdge) (fixedFirst fixedSecond : spec.Vertex) :
              effective (atMinLength spec movingEdge leftLength rightLength hBound fixedFirst fixedSecond)
              theorem AtanasovRanganathan.Configurations.MovingDivisor.reaches_minLengthPosition {n p : ℕ} (spec : Utilities.Certificate.SubdivisionGraph.Spec n p) (movingEdge leftLength rightLength : Fin p) (hBound : min (spec.length leftLength) (spec.length rightLength) ≤ spec.length movingEdge) (fixedFirst fixedSecond : spec.Vertex) :
              Utilities.Certificate.StrongSeparator.Reaches spec.graph (atMinLength spec movingEdge leftLength rightLength hBound fixedFirst fixedSecond) (spec.pathVertex movingEdge (spec.minLengthPosition movingEdge leftLength rightLength hBound))
              def AtanasovRanganathan.Configurations.MovingDivisor.atDifference {n p : ℕ} (spec : Utilities.Certificate.SubdivisionGraph.Spec n p) (movingEdge minuend subtrahend : Fin p) (hBound : spec.length minuend - spec.length subtrahend ≤ spec.length movingEdge) (fixedFirst fixedSecond : spec.Vertex) :

              A three-chip divisor whose first chip is at a truncated difference of edge lengths, as in the three macroscopic cases of the first genus-four family.

              Equations
              • One or more equations did not get rendered due to their size.
              Instances For
                @[simp]
                theorem AtanasovRanganathan.Configurations.MovingDivisor.deg_atDifference {n p : ℕ} (spec : Utilities.Certificate.SubdivisionGraph.Spec n p) (movingEdge minuend subtrahend : Fin p) (hBound : spec.length minuend - spec.length subtrahend ≤ spec.length movingEdge) (fixedFirst fixedSecond : spec.Vertex) :
                CFDiv.degree (atDifference spec movingEdge minuend subtrahend hBound fixedFirst fixedSecond) = 3
                theorem AtanasovRanganathan.Configurations.MovingDivisor.effective_atDifference {n p : ℕ} (spec : Utilities.Certificate.SubdivisionGraph.Spec n p) (movingEdge minuend subtrahend : Fin p) (hBound : spec.length minuend - spec.length subtrahend ≤ spec.length movingEdge) (fixedFirst fixedSecond : spec.Vertex) :
                effective (atDifference spec movingEdge minuend subtrahend hBound fixedFirst fixedSecond)
                theorem AtanasovRanganathan.Configurations.MovingDivisor.reaches_differencePosition {n p : ℕ} (spec : Utilities.Certificate.SubdivisionGraph.Spec n p) (movingEdge minuend subtrahend : Fin p) (hBound : spec.length minuend - spec.length subtrahend ≤ spec.length movingEdge) (fixedFirst fixedSecond : spec.Vertex) :
                Utilities.Certificate.StrongSeparator.Reaches spec.graph (atDifference spec movingEdge minuend subtrahend hBound fixedFirst fixedSecond) (spec.pathVertex movingEdge (spec.differencePosition movingEdge minuend subtrahend hBound))

                Configuration 1: two endpoint chips on a segment #

                An exact reflection starting with one chip at each of two endpoints. The second output chip is allowed to coincide with the requested target.

                Equations
                • One or more equations did not get rendered due to their size.
                Instances For
                  theorem AtanasovRanganathan.Configurations.effective_sub_two_distinct_chips {G : CFGraph} {D : CFDiv G} {left right : G.V} (hEffective : effective D) (hLeft : 1 ≤ D left) (hRight : 1 ≤ D right) (hDistinct : left ≠ right) :
                  effective (D - oneChip left - oneChip right)
                  theorem AtanasovRanganathan.Configurations.reaches_of_endpoint_chips_of_twoEndpointReflection {G : CFGraph} {D : CFDiv G} {left right target : G.V} (hEffective : effective D) (hLeft : 1 ≤ D left) (hRight : 1 ≤ D right) (hDistinct : left ≠ right) (hReflection : TwoEndpointReflection left right target) :

                  The first pictured configuration, abstracted to its exact principal identity: endpoint chips plus a segment reflection reach the requested point.

                  Exact geometric obligation for a subdivided segment: its two endpoint chips reflect to a named path position and one further effective chip.

                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For
                    theorem AtanasovRanganathan.Configurations.SegmentConfiguration.reaches_pathPosition {n p : ℕ} (spec : Utilities.Certificate.SubdivisionGraph.Spec n p) (D : CFDiv spec.graph) (edge : Fin p) (position : spec.PathPosition edge) (hEffective : effective D) (hTail : 1 ≤ D (spec.coreVertex (spec.core.tail edge))) (hHead : 1 ≤ D (spec.coreVertex (spec.core.head edge))) (hReflection : ReflectsTo spec edge position) :

                    Once the segment potential identity is known, the endpoint-chip configuration reaches the named subdivision position.

                    theorem AtanasovRanganathan.Configurations.SegmentConfiguration.reaches_minLengthPosition {n p : ℕ} (spec : Utilities.Certificate.SubdivisionGraph.Spec n p) (D : CFDiv spec.graph) (edge leftLength rightLength : Fin p) (hBound : min (spec.length leftLength) (spec.length rightLength) ≤ spec.length edge) (hEffective : effective D) (hTail : 1 ≤ D (spec.coreVertex (spec.core.tail edge))) (hHead : 1 ≤ D (spec.coreVertex (spec.core.head edge))) (hReflection : ReflectsTo spec edge (spec.minLengthPosition edge leftLength rightLength hBound)) :
                    Utilities.Certificate.StrongSeparator.Reaches spec.graph D (spec.pathVertex edge (spec.minLengthPosition edge leftLength rightLength hBound))

                    min(a,b) specialization of the segment configuration.

                    theorem AtanasovRanganathan.Configurations.SegmentConfiguration.reaches_differencePosition {n p : ℕ} (spec : Utilities.Certificate.SubdivisionGraph.Spec n p) (D : CFDiv spec.graph) (edge minuend subtrahend : Fin p) (hBound : spec.length minuend - spec.length subtrahend ≤ spec.length edge) (hEffective : effective D) (hTail : 1 ≤ D (spec.coreVertex (spec.core.tail edge))) (hHead : 1 ≤ D (spec.coreVertex (spec.core.head edge))) (hReflection : ReflectsTo spec edge (spec.differencePosition edge minuend subtrahend hBound)) :
                    Utilities.Certificate.StrongSeparator.Reaches spec.graph D (spec.pathVertex edge (spec.differencePosition edge minuend subtrahend hBound))

                    Difference-position specialization used by the first genus-four family.

                    Doubled-path configuration: a closed potential proof #

                    theorem AtanasovRanganathan.Configurations.reaches_parallelPathMarker_of_two_chips {n p : ℕ} (spec : Utilities.Certificate.SubdivisionGraph.Spec n p) (base marker : Fin n) (first second : Fin p) (hFirstSecond : first ≠ second) (hFirstTail : spec.core.tail first = base) (hFirstHead : spec.core.head first = marker) (hSecondTail : spec.core.tail second = base) (hSecondHead : spec.core.head second = marker) (hOnly : ∀ (edge : Fin p), spec.core.tail edge = marker ∨ spec.core.head edge = marker → edge = first ∨ edge = second) (D : CFDiv spec.graph) (hEffective : effective D) (hTwo : 2 ≤ D (spec.coreVertex base)) :

                    Two chips at the common base of two subdivided paths reach their bivalent marker. Unlike SegmentConfiguration.ReflectsTo, the geometric potential identity here is already fully proved by the truncated-ramp interpolation API.

                    theorem AtanasovRanganathan.Configurations.bnExists_one_three_of_parallelPathMarker {n p : ℕ} (spec : Utilities.Certificate.SubdivisionGraph.Spec n p) (hConnected : graphConnected spec.graph) (base marker : Fin n) (first second : Fin p) (hFirstSecond : first ≠ second) (hFirstTail : spec.core.tail first = base) (hFirstHead : spec.core.head first = marker) (hSecondTail : spec.core.tail second = base) (hSecondHead : spec.core.head second = marker) (hOnly : ∀ (edge : Fin p), spec.core.tail edge = marker ∨ spec.core.head edge = marker → edge = first ∨ edge = second) (D : CFDiv spec.graph) (hEffective : effective D) (hDegree : CFDiv.degree D = 3) (hTwo : 2 ≤ D (spec.coreVertex base)) (hOther : ∀ (vertex : Fin n), vertex ≠ marker → Utilities.Certificate.StrongSeparator.Reaches spec.graph D (spec.coreVertex vertex)) :

                    Rank-one wrapper for a subdivision in which the doubled-path marker is the only core reachability test not discharged elsewhere.