Documentation

LeanPool.BrillNoetherGraphs.Utilities.Subdivision.SubdivisionChipDescent

Descent of winnability and rank from a regular subdivision #

Let spec present a finite loopless multigraph with positive integral slot lengths, and let spec.scale N be its uniform N-fold refinement: every unit step of spec becomes a block of N unit steps. A divisor supported on the coarse vertices embeds into the fine graph, and this file studies what happens to a fine divisor of the form

embed D₀ + x₁ + ⋯ + xₘ

whose extra chips xᵢ sit at fine vertices strictly inside coarse steps. Each such chip is rounded to one end of its coarse step, at a cost equal to its fine distance to that end.

Theorem (winnable_of_winnable_scale). If the total rounding cost is less than N, then winnability of the fine divisor implies winnability of the rounded coarse divisor D₀ + z₁ + ⋯ + zₘ. The same holds for every rank lower bound (rank_ge_of_rank_scale_ge), because the coarse rank tests embed into fine rank tests. The sharper forms winnable_of_winnable_scale_cost and rank_ge_of_rank_scale_ge_cost charge each coarse step only the absolute value of the signed sum of its chips' costs (stepCost), so chips on one step rounded in opposite directions cancel each other.

Two chips on an odd refinement always satisfy the budget: each is within (N - 1) / 2 of its nearest coarse vertex, so the total cost is at most N - 1. That is the odd-subdivision descent used by Utilities/Subdivision/OddSubdivisionDescent.lean for Brill--Noether rank.

The proof #

Let σ be a fine winning script. Along each coarse step, the fine slopes of σ are nondecreasing except that they may drop by the number of chips at a fine vertex (prin_interiorVertex_eq_slopeDifference). Consequently the height difference B - A of σ across the step, corrected by the signed rounding cost δ of the chips in that step, lies between N * (s₁ - cL) and N * (s_N + cR), where s₁, s_N are the first and last fine slopes and cL, cR count the chips rounded to the left and right ends (Utilities.BlockSlopeRounding).

Because ∑ |δ| < N, CommonOffsetRounding.exists_common_offset gives one residue κ with round κ (B + δ) = round κ B for every step at once. The coarse script g v := round κ (σ (fineOf v)) therefore has, on every step, a slope between s₁ - cL and s_N + cR (round_sub_bounds). Summing the endpoint slopes at a coarse vertex shows that g loses, relative to σ, at most the number of chips rounded to that vertex — exactly what the rounded chips supply. No total unimodularity, period lattice, or cycle space is involved; the argument is one-dimensional on each step.

The proof is a genuine descent theorem and not the "prove it metrically, then round" fallacy recorded in the research notes: the rounding is justified step by step from the fine script, and the budget hypothesis is exactly what fails for two chips at the midpoints of an even refinement.

Coarse vertices inside the fine graph #

def Utilities.Certificate.SubdivisionGraph.Spec.scaledPosition {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) (edge : Fin p) (position : spec.PathPosition edge) :
(spec.scale N hN).PathPosition edge

The fine vertex at fine offset N * k of slot edge, for a coarse path position k.

Equations
Instances For
    @[simp]
    theorem Utilities.Certificate.SubdivisionGraph.Spec.scaledPosition_val {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) (edge : Fin p) (position : spec.PathPosition edge) :
    ↑(spec.scaledPosition N hN edge position) = N * ↑position
    def Utilities.Certificate.SubdivisionGraph.Spec.fineOf {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) :
    spec.Vertex → (spec.scale N hN).Vertex

    The embedding of the coarse vertices into the fine graph: core vertices go to core vertices, and the interior vertex at coarse offset j + 1 of a slot goes to fine offset N * (j + 1).

    Equations
    Instances For
      @[simp]
      theorem Utilities.Certificate.SubdivisionGraph.Spec.fineOf_coreVertex {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) (vertex : Fin n) :
      spec.fineOf N hN (spec.coreVertex vertex) = (spec.scale N hN).coreVertex vertex
      theorem Utilities.Certificate.SubdivisionGraph.Spec.fineOf_pathVertex {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) (edge : Fin p) (position : spec.PathPosition edge) :
      spec.fineOf N hN (spec.pathVertex edge position) = (spec.scale N hN).pathVertex edge (spec.scaledPosition N hN edge position)

      The embedding sends the coarse path vertex at position k to the fine path vertex at position N * k.

      Embedding coarse divisors #

      def Utilities.Certificate.SubdivisionGraph.Spec.embed {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) (D : CFDiv spec.graph) :
      CFDiv (spec.scale N hN).graph

      Push a coarse divisor forward along fineOf: the chips stay on the images of the coarse vertices and every other fine vertex carries none.

      Equations
      Instances For
        theorem Utilities.Certificate.SubdivisionGraph.Spec.embed_apply_fineOf {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) (D : CFDiv spec.graph) (x : spec.Vertex) :
        spec.embed N hN D (spec.fineOf N hN x) = D x
        theorem Utilities.Certificate.SubdivisionGraph.Spec.embed_apply_of_not_mem_range {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) (D : CFDiv spec.graph) (y : (spec.scale N hN).Vertex) (hy : y ∉ Set.range (spec.fineOf N hN)) :
        spec.embed N hN D y = 0
        theorem Utilities.Certificate.SubdivisionGraph.Spec.embed_add {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) (D E : CFDiv spec.graph) :
        spec.embed N hN (D + E) = spec.embed N hN D + spec.embed N hN E
        theorem Utilities.Certificate.SubdivisionGraph.Spec.embed_sub {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) (D E : CFDiv spec.graph) :
        spec.embed N hN (D - E) = spec.embed N hN D - spec.embed N hN E
        theorem Utilities.Certificate.SubdivisionGraph.Spec.effective_embed {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) {D : CFDiv spec.graph} (hD : effective D) :
        effective (spec.embed N hN D)
        theorem Utilities.Certificate.SubdivisionGraph.Spec.deg_embed {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) (D : CFDiv spec.graph) :

        Moving chips and their rounding #

        structure Utilities.Certificate.SubdivisionGraph.Spec.Chip {n p : ℕ} (spec : Spec n p) (N : ℕ) :

        A chip strictly inside a coarse step, together with the end of that step it is rounded to. The chip sits at fine offset N * step + offset of its slot, with 0 < offset < N.

        • edge : Fin p

          The slot of the coarse graph.

        • step : ℕ

          The coarse unit step of the slot, 0 ≤ step < length edge.

        • step_lt : self.step < spec.length self.edge
        • offset : ℕ

          The fine offset inside the coarse step.

        • offset_pos : 0 < self.offset
        • offset_lt : self.offset < N
        • toRight : Bool

          true rounds to the right end of the coarse step, false to the left.

        Instances For
          def Utilities.Certificate.SubdivisionGraph.Spec.Chip.finePosition {n p : ℕ} {spec : Spec n p} {N : ℕ} (hN : 0 < N) (c : spec.Chip N) :
          (spec.scale N hN).PathPosition c.edge

          The fine position of a chip: offset N * step + offset along its slot.

          Equations
          Instances For
            def Utilities.Certificate.SubdivisionGraph.Spec.Chip.fineVertex {n p : ℕ} {spec : Spec n p} {N : ℕ} (hN : 0 < N) (c : spec.Chip N) :
            (spec.scale N hN).Vertex

            The fine vertex carrying the chip.

            Equations
            Instances For
              def Utilities.Certificate.SubdivisionGraph.Spec.Chip.coarseStep {n p : ℕ} {spec : Spec n p} {N : ℕ} (c : spec.Chip N) :
              spec.Step

              The coarse step containing the chip.

              Equations
              Instances For
                def Utilities.Certificate.SubdivisionGraph.Spec.Chip.coarseVertex {n p : ℕ} {spec : Spec n p} {N : ℕ} (c : spec.Chip N) :
                spec.Vertex

                The coarse vertex the chip is rounded to.

                Equations
                Instances For
                  def Utilities.Certificate.SubdivisionGraph.Spec.Chip.distance {n p : ℕ} {spec : Spec n p} {N : ℕ} (c : spec.Chip N) :

                  The fine distance from the chip to the coarse vertex it is rounded to.

                  Equations
                  Instances For

                    The signed rounding cost: positive when rounding right, negative when rounding left. Adding it to the fine height at the right end of the step plays the role of moving the chip.

                    Equations
                    Instances For
                      theorem Utilities.Certificate.SubdivisionGraph.Spec.Chip.fineVertex_not_mem_range {n p : ℕ} {spec : Spec n p} {N : ℕ} (hN : 0 < N) (c : spec.Chip N) :
                      fineVertex hN c ∉ Set.range (spec.fineOf N hN)

                      A chip is never at a fine vertex in the image of the coarse graph.

                      def Utilities.Certificate.SubdivisionGraph.Spec.fineChips {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) {ι : Type u_1} [Fintype ι] (chips : ι → spec.Chip N) :
                      CFDiv (spec.scale N hN).graph

                      The fine divisor of a family of chips.

                      Equations
                      Instances For
                        def Utilities.Certificate.SubdivisionGraph.Spec.coarseChips {n p : ℕ} (spec : Spec n p) (N : ℕ) {ι : Type u_1} [Fintype ι] (chips : ι → spec.Chip N) :

                        The rounded coarse divisor of a family of chips.

                        Equations
                        Instances For

                          Slot values of a fine script #

                          def Utilities.Certificate.SubdivisionGraph.Spec.fineValue {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) (σ : firingScript (spec.scale N hN).graph) (edge : Fin p) (j : ℕ) :

                          The value of a fine script at fine offset j of slot edge (and 0 beyond the head, which is never used).

                          Equations
                          Instances For
                            def Utilities.Certificate.SubdivisionGraph.Spec.fineSlope {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) (σ : firingScript (spec.scale N hN).graph) (edge : Fin p) (j : ℕ) :

                            The fine slope across fine step j of slot edge.

                            Equations
                            Instances For
                              theorem Utilities.Certificate.SubdivisionGraph.Spec.isStepSlope_fineSlope {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) (σ : firingScript (spec.scale N hN).graph) :
                              (spec.scale N hN).IsStepSlope σ (spec.fineSlope N hN σ)
                              def Utilities.Certificate.SubdivisionGraph.Spec.roundedScript {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) (κ : Fin N) (σ : firingScript (spec.scale N hN).graph) :

                              The rounded coarse script: common-offset rounding of the fine values at the images of the coarse vertices.

                              Equations
                              Instances For
                                def Utilities.Certificate.SubdivisionGraph.Spec.roundedSlope {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) (κ : Fin N) (σ : firingScript (spec.scale N hN).graph) (edge : Fin p) (k : ℕ) :

                                The coarse slope of the rounded script across coarse step k of slot edge.

                                Equations
                                • One or more equations did not get rendered due to their size.
                                Instances For
                                  theorem Utilities.Certificate.SubdivisionGraph.Spec.isStepSlope_roundedSlope {n p : ℕ} (spec : Spec n p) (N : ℕ) (hN : 0 < N) (κ : Fin N) (σ : firingScript (spec.scale N hN).graph) :
                                  spec.IsStepSlope (spec.roundedScript N hN κ σ) (spec.roundedSlope N hN κ σ)

                                  The step inequality #

                                  def Utilities.Certificate.SubdivisionGraph.Spec.stepChips {n p : ℕ} (spec : Spec n p) (N : ℕ) {ι : Type u_1} [Fintype ι] (chips : ι → spec.Chip N) (step : spec.Step) :

                                  The chips of a family lying in a given coarse step.

                                  Equations
                                  Instances For
                                    def Utilities.Certificate.SubdivisionGraph.Spec.leftCount {n p : ℕ} (spec : Spec n p) (N : ℕ) {ι : Type u_1} [Fintype ι] (chips : ι → spec.Chip N) (step : spec.Step) :

                                    The number of chips of a step rounded to its left end.

                                    Equations
                                    Instances For
                                      def Utilities.Certificate.SubdivisionGraph.Spec.rightCount {n p : ℕ} (spec : Spec n p) (N : ℕ) {ι : Type u_1} [Fintype ι] (chips : ι → spec.Chip N) (step : spec.Step) :

                                      The number of chips of a step rounded to its right end.

                                      Equations
                                      Instances For
                                        def Utilities.Certificate.SubdivisionGraph.Spec.stepCost {n p : ℕ} (spec : Spec n p) (N : ℕ) {ι : Type u_1} [Fintype ι] (chips : ι → spec.Chip N) (step : spec.Step) :

                                        The total signed rounding cost of the chips of a step.

                                        Equations
                                        Instances For