Definitions of TypeDensity.Formula.PatternCounts
DefinitionTypeDensity_Formula_PatternCountsCounting divisors with a given tangent pattern
Over a finite field k, the exceptional divisors realizing a tangent pattern P of a state
s are in bijection with tuples of colorings of the nonboundary closed directions (one
coloring per degree), which yields the closed formula #patternDivisors = tangentCount(q)
with q = #k. Consequences: tangent counts and state-law coefficients are nonnegative at
prime powers. The file also records the count of nonboundary closed directions of each degree
and a continuity criterion for congruence-compatible maps.
Main results
TypeDensity.nonboundary_direction_count: number of nonboundary directions of degreeδ.TypeDensity.patternDivisors_equiv_colorings: divisors with patternP≃ colorings.TypeDensity.pattern_divisor_count:#patternDivisors k s P = tangentCount s P (#k).TypeDensity.tangent_count_nonneg,TypeDensity.state_law_coeff_nonneg.TypeDensity.continuousOn_of_congruence_compatible.
Provenance: Thm_SurfaceBlowupV2_{nonboundary_direction_count, pattern_divisors_equiv_colorings_v2, pattern_divisor_count, tangent_count_nonneg, state_law_coeff_nonneg, continuousOn_of_congruence_compatible} (the second inlines the proof
of divisor_degree_pattern_weight).
-- Generated by the TypeDensity exporter from TypeDensity/Formula/PatternCounts.lean (namespace TypeDensity); do not edit.
import Definitions.Def_TypeDensity_Basic
import Definitions.Def_TypeDensity_Blowup_Directions
import Definitions.Def_TypeDensity_Measure_AdicCylinders
import Definitions.Def_TypeDensity_Formula_LawAlgebra
import Definitions.Def_TypeDensity_Measure_HenselProducts
import Definitions.Def_TypeDensity_Surfaces_Lengths
import Definitions.Def_TypeDensity_Surfaces_PowerSeries
import Definitions.Def_TypeDensity_Formula_FiniteFieldCounts
import Definitions.Def_TypeDensity_Formula_StateCombinatorics
import Mathlib.FieldTheory.RatFunc.Basic
import Mathlib.MeasureTheory.Measure.Haar.Unique
import Mathlib.NumberTheory.ArithmeticFunction.Moebius
import Mathlib.NumberTheory.Padics.PadicIntegers
import Mathlib.RingTheory.IntegralClosure.IntegralRestrict
import Mathlib.RingTheory.MvPowerSeries.Basic
import Mathlib.RingTheory.RamificationInertia.Basic
import Mathlib.Topology.Algebra.Nonarchimedean.AdicTopology
import Mathlib.Topology.Algebra.MvPolynomial
import Mathlib.FieldTheory.Finite.GaloisField
import Mathlib.RingTheory.AdicCompletion.Algebra
import Mathlib.RingTheory.RegularLocalRing.Defs
import Mathlib.Algebra.Group.Pi.Units
import Mathlib.Order.CompletePartialOrder
import Mathlib.RingTheory.Henselian
import Mathlib.RingTheory.Polynomial.Resultant.Basic
import Mathlib.RingTheory.SimpleRing.Principal
import Mathlib.FieldTheory.Finite.Extension
import Mathlib.RingTheory.AdicCompletion.Noetherian
import Mathlib.RingTheory.MvPowerSeries.Equiv
import Mathlib.RingTheory.PicardGroup
set_option autoImplicit false
open scoped BigOperators ENNReal
namespace TypeDensity
/-- Over a finite field `k`, the number of nonboundary closed directions of degree `δ > 0` is
the value at `q = #k` of `availablePoints` (with offset `-1` at a crossing state, where the
zero direction is also boundary). -/
theorem nonboundary_direction_count (k : Type) [Field k] [Finite k] (s : State) (δ : ℕ)
(hδ : 0 < δ) :
((Nat.card {Q : ClosedDirection k // Q ∉ boundaryDirections k s ∧
directionDegree k Q = δ} : ℕ) : ℚ) =
(availablePoints
(match s with | State.single _ _ => (0 : ℤ) | State.crossing _ _ _ _ => (-1 : ℤ))
δ).eval (Nat.card k) := by
have hN := finite_field_irreducible_count k δ hδ
have hp1 : (pointCount 1).eval (Nat.card k) = (Nat.card k : ℚ) := by
simp [pointCount, Expr.sum, Expr.eval, Expr.pow]
set C : Prop := ((s matches State.crossing _ _ _ _) = true) with hC
set T : Set (Polynomial k) :=
{g | (g.Monic ∧ Irreducible g ∧ g.natDegree = δ) ∧ (C → g ≠ Polynomial.X)} with hT
have hcard : Nat.card {Q : ClosedDirection k //
Q ∉ boundaryDirections k s ∧ directionDegree k Q = δ} = Set.ncard T := by
rw [← Nat.card_coe_set_eq]
let f : T → {Q : ClosedDirection k // Q ∉ boundaryDirections k s ∧ directionDegree k Q = δ} :=
fun g ↦ ⟨some ⟨g.1, g.2.1.1, g.2.1.2.1⟩, by
obtain ⟨g, ⟨hm, hi, hd⟩, hx⟩ := g
refine ⟨?_, hd⟩
cases s <;> simp_all [boundaryDirections, infinityDirection, zeroDirection, C]⟩
refine (Nat.card_congr (Equiv.ofBijective f ⟨?_, ?_⟩)).symm
· rintro ⟨g, hg⟩ ⟨g', hg'⟩ h
simp only [f, Subtype.mk.injEq, Option.some.injEq] at h
exact Subtype.ext h
· rintro ⟨Q, hQ, hd⟩
cases Q with
| none => cases s <;> simp [boundaryDirections, infinityDirection] at hQ
| some φ =>
refine ⟨⟨φ.1, ⟨φ.2.1, φ.2.2, hd⟩, fun hc h ↦ hQ ?_⟩, rfl⟩
cases s
· simp [C] at hc
· exact Or.inr (congrArg some (Subtype.ext h))
rw [hcard]
set A : Set (Polynomial k) := {g | g.Monic ∧ Irreducible g ∧ g.natDegree = δ} with hA
have hNA : ((Set.ncard A : ℕ) : ℚ) = (pointCount δ).eval (Nat.card k) := by
rw [← Nat.card_coe_set_eq]; exact hN
by_cases h1 : δ = 1
· subst h1
have hq : ((Set.ncard A : ℕ) : ℚ) = Nat.card k := by rw [hNA, hp1]
cases s with
| single a c =>
have : T = A := by ext g; simp [T, A, C]
rw [this, hq]; simp [availablePoints, Expr.eval]
| crossing a b c h =>
have hTA : T = A \ {Polynomial.X} := by ext g; simp [T, A, C]
have hXA : Polynomial.X ∈ A :=
⟨Polynomial.monic_X, Polynomial.irreducible_X, Polynomial.natDegree_X⟩
have hfin : A.Finite := Set.finite_of_ncard_pos (by
have : (0 : ℚ) < (Set.ncard A : ℕ) := by rw [hq]; exact_mod_cast Nat.card_pos
exact_mod_cast this)
have := Set.ncard_sdiff_singleton_add_one hXA hfin
have h2 : ((Set.ncard (A \ {Polynomial.X}) : ℕ) : ℚ) + 1 = Nat.card k := by
rw [← hq]; exact_mod_cast this
rw [hTA]
simp [availablePoints, Expr.eval]; linarith
· have : T = A := by
ext g
simp only [T, A, Set.mem_ofPred_eq, and_iff_left_iff_imp]
rintro ⟨-, -, hd⟩ - rfl
exact h1 (hd ▸ Polynomial.natDegree_X)
rw [this, hNA]; simp [availablePoints, h1]
section Colorings
variable (k : Type) [Field k]
/-- Every closed direction has positive degree. -/
theorem directionDegree_pos (Q : ClosedDirection k) : 0 < directionDegree k Q := by
cases Q with
| none => simp [directionDegree]
| some φ => exact φ.property.2.natDegree_pos
theorem inf_mem_bdry (s : State) : infinityDirection k ∈ boundaryDirections k s := by
cases s <;> simp [boundaryDirections]
theorem zero_ne_inf : zeroDirection k ≠ infinityDirection k := by
simp [zeroDirection, infinityDirection]
theorem mem_bdry_single (a c : ℕ) (Q : ClosedDirection k) :
Q ∈ boundaryDirections k (State.single a c) ↔ Q = infinityDirection k := by
simp [boundaryDirections]
theorem mem_bdry_crossing (a b c h : ℕ) (Q : ClosedDirection k) :
Q ∈ boundaryDirections k (State.crossing a b c h) ↔
Q = infinityDirection k ∨ Q = zeroDirection k := by
simp [boundaryDirections]
theorem deg_of_mem_bdry (s : State) (Q : ClosedDirection k)
(hQ : Q ∈ boundaryDirections k s) : directionDegree k Q = 1 := by
cases s with
| single a c =>
rw [mem_bdry_single] at hQ
subst hQ; rfl
| crossing a b c h =>
rcases (mem_bdry_crossing k a b c h Q).1 hQ with rfl | rfl
· rfl
· simp [directionDegree, zeroDirection]
/-- Closed directions of bounded degree over a finite field are finite. -/
theorem finite_directionDegree_le [Finite k] (n : ℕ) :
Finite {Q : ClosedDirection k // directionDegree k Q ≤ n} := by
let f : {Q : ClosedDirection k // directionDegree k Q ≤ n} → Option (Fin (n+1) → k) :=
fun Q ↦ Option.map (fun φ : AffineDirection k ↦ fun i : Fin (n+1) ↦ φ.val.coeff i) Q.1
refine Finite.of_injective f ?_
rintro ⟨Q, hQ⟩ ⟨Q', hQ'⟩ h
apply Subtype.ext
simp only [f] at h
cases Q with
| none =>
cases Q' with
| none => rfl
| some _ => simp at h
| some φ =>
cases Q' with
| none => simp at h
| some ψ =>
simp only [Option.map_some, Option.some.injEq] at h
refine congrArg some (Subtype.ext (Polynomial.ext fun i ↦ ?_))
by_cases hi : i < n + 1
· exact congrFun h ⟨i, hi⟩
· have h1 : φ.val.natDegree < i := by simp [directionDegree] at hQ; omega
have h2 : ψ.val.natDegree < i := by simp [directionDegree] at hQ'; omega
rw [Polynomial.coeff_eq_zero_of_natDegree_lt h1,
Polynomial.coeff_eq_zero_of_natDegree_lt h2]
/-- The nonboundary points of degree `i + 1`. -/
abbrev Pt (s : State) (i : Fin s.degree) : Type :=
{Q : ClosedDirection k // Q ∉ boundaryDirections k s ∧ directionDegree k Q = i.val + 1}
/-- Colorings of the degree-`(i + 1)` nonboundary points with the prescribed counts. -/
abbrev Col (s : State) (P : TangentPattern s.degree) (i : Fin s.degree) : Type :=
{f : Pt k s i → Option (Fin s.degree) //
∀ j : Fin s.degree, Nat.card {Q // f Q = some j} = (P.other (i, j)).val}
theorem card_fiber_eq (s : State) (D : ExceptionalDivisor k) (i j : Fin s.degree)
(f : Pt k s i → Option (Fin s.degree))
(hf : ∀ Q : Pt k s i, f Q = some j ↔ D Q.1 = j.val + 1) :
Nat.card {Q : Pt k s i // f Q = some j} =
Nat.card {Q : ClosedDirection k // Q ∉ boundaryDirections k s ∧
directionDegree k Q = i.val + 1 ∧ D Q = j.val + 1} :=
Nat.card_congr
{ toFun := fun Q ↦ ⟨Q.1.1, Q.1.2.1, Q.1.2.2, (hf Q.1).1 Q.2⟩
invFun := fun Q ↦ ⟨⟨Q.1, Q.2.1, Q.2.2.1⟩, (hf _).2 Q.2.2.2⟩
left_inv := fun _ ↦ rfl
right_inv := fun _ ↦ rfl }
theorem deg_mul_mult_le (s : State) (P : TangentPattern s.degree)
(D : patternDivisors k s P) (Q : ClosedDirection k) :
directionDegree k Q * D.1 Q ≤ s.degree := by
have hdeg : exceptionalDegree k D.1 = P.d.val := D.2.1
have h3 : P.d.val ≤ s.degree := Nat.lt_succ_iff.mp P.d.isLt
by_cases hQ : D.1 Q = 0
· simp [hQ]
· have h1 : directionDegree k Q * D.1 Q ≤ exceptionalDegree k D.1 :=
Finset.single_le_sum (f := fun P ↦ directionDegree k P * D.1 P)
(fun _ _ ↦ Nat.zero_le _) (Finsupp.mem_support_iff.mpr hQ)
omega
theorem mult_le (s : State) (P : TangentPattern s.degree) (D : patternDivisors k s P)
(Q : ClosedDirection k) : D.1 Q ≤ s.degree :=
(Nat.le_mul_of_pos_left _ (directionDegree_pos k Q)).trans (deg_mul_mult_le k s P D Q)
def toColFun (s : State) (P : TangentPattern s.degree) (D : patternDivisors k s P)
(i : Fin s.degree) : Pt k s i → Option (Fin s.degree) :=
fun Q ↦ if D.1 Q.1 = 0 then none
else some ⟨D.1 Q.1 - 1, by have := mult_le k s P D Q.1; omega⟩
theorem toColFun_eq_some_iff (s : State) (P : TangentPattern s.degree)
(D : patternDivisors k s P) (i j : Fin s.degree) (Q : Pt k s i) :
toColFun k s P D i Q = some j ↔ D.1 Q.1 = j.val + 1 := by
unfold toColFun
split_ifs with h
· simp only [false_iff]; omega
· simp only [Option.some.injEq, Fin.ext_iff]; omega
def toCol (s : State) (P : TangentPattern s.degree) (D : patternDivisors k s P) :
∀ i : Fin s.degree, Col k s P i :=
fun i ↦ ⟨toColFun k s P D i, fun j ↦ by
rw [card_fiber_eq k s D.1 i j _ (toColFun_eq_some_iff k s P D i j)]
exact D.2.2.2.2 (i, j)⟩
theorem coloring_congr (s : State) (P : TangentPattern s.degree)
(F : ∀ i : Fin s.degree, Col k s P i) (i i' : Fin s.degree) (hii : i = i')
(Q : ClosedDirection k) (hb : Q ∉ boundaryDirections k s)
(h1 : directionDegree k Q = i.val + 1) (h2 : directionDegree k Q = i'.val + 1) :
(F i).1 ⟨Q, hb, h1⟩ = (F i').1 ⟨Q, hb, h2⟩ := by
subst hii; rfl
theorem elim_le (n : ℕ) (o : Option (Fin n)) :
Option.elim o 0 (fun j ↦ j.val + 1) ≤ n := by
cases o with
| none => exact Nat.zero_le _
| some j => exact j.isLt
open scoped Classical in
/-- The multiplicity at `Q` of the divisor attached to a tuple of colorings. -/
noncomputable def mult (s : State) (P : TangentPattern s.degree)
(F : ∀ i : Fin s.degree, Col k s P i) (Q : ClosedDirection k) : ℕ :=
if Q = infinityDirection k then P.rt.val
else if hb : Q ∈ boundaryDirections k s then P.rx.val
else if h : directionDegree k Q ≤ s.degree then
Option.elim ((F ⟨directionDegree k Q - 1, by have := directionDegree_pos k Q; omega⟩).1
⟨Q, hb, (by have := directionDegree_pos k Q; omega :
directionDegree k Q = directionDegree k Q - 1 + 1)⟩) 0 (fun j ↦ j.val + 1)
else 0
theorem mult_inf (s : State) (P : TangentPattern s.degree)
(F : ∀ i : Fin s.degree, Col k s P i) :
mult k s P F (infinityDirection k) = P.rt.val := by
unfold mult; rw [if_pos rfl]
theorem mult_zero_crossing (a b c h : ℕ)
(P : TangentPattern (State.crossing a b c h).degree)
(F : ∀ i : Fin (State.crossing a b c h).degree, Col k (State.crossing a b c h) P i) :
mult k (State.crossing a b c h) P F (zeroDirection k) = P.rx.val := by
unfold mult
rw [if_neg (zero_ne_inf k), dif_pos ((mem_bdry_crossing k a b c h _).2 (Or.inr rfl))]
theorem mult_nonbdry (s : State) (P : TangentPattern s.degree)
(F : ∀ i : Fin s.degree, Col k s P i) (i : Fin s.degree) (Q : Pt k s i) :
mult k s P F Q.1 = Option.elim ((F i).1 Q) 0 (fun j ↦ j.val + 1) := by
obtain ⟨Q, hb, hQ⟩ := Q
have hinf : Q ≠ infinityDirection k := fun h ↦ hb (h ▸ inf_mem_bdry k s)
have hle : directionDegree k Q ≤ s.degree := by omega
have hpos := directionDegree_pos k Q
change mult k s P F Q = Option.elim ((F i).1 ⟨Q, hb, hQ⟩) 0 (fun j ↦ j.val + 1)
unfold mult
rw [if_neg hinf, dif_neg hb, dif_pos hle]
congr 1
exact coloring_congr k s P F ⟨directionDegree k Q - 1, by omega⟩ i
(Fin.ext (by change directionDegree k Q - 1 = i.val; omega)) Q hb
(by omega : directionDegree k Q = directionDegree k Q - 1 + 1) hQ
theorem mult_support_finite [Finite k] (s : State) (P : TangentPattern s.degree)
(F : ∀ i : Fin s.degree, Col k s P i) : (Function.support (mult k s P F)).Finite := by
have hfin : Set.Finite {Q : ClosedDirection k | directionDegree k Q ≤ max 1 s.degree} :=
Set.finite_coe_iff.mp (finite_directionDegree_le k (max 1 s.degree))
refine hfin.subset fun Q hQ ↦ ?_
rw [Function.mem_support] at hQ
change directionDegree k Q ≤ max 1 s.degree
unfold mult at hQ
split_ifs at hQ with h1 h2 h3
· subst h1; exact le_max_left _ _
· rw [deg_of_mem_bdry k s Q h2]; exact le_max_left _ _
· exact le_trans h3 (le_max_right _ _)
· exact absurd rfl hQ
/-- The exceptional divisor attached to a tuple of colorings. -/
noncomputable def toDiv [Finite k] (s : State) (P : TangentPattern s.degree)
(F : ∀ i : Fin s.degree, Col k s P i) : ExceptionalDivisor k :=
Finsupp.ofSupportFinite (mult k s P F) (mult_support_finite k s P F)
theorem toDiv_apply [Finite k] (s : State) (P : TangentPattern s.degree)
(F : ∀ i : Fin s.degree, Col k s P i) (Q : ClosedDirection k) :
toDiv k s P F Q = mult k s P F Q := rfl
theorem toDiv_some_iff [Finite k] (s : State) (P : TangentPattern s.degree)
(F : ∀ i : Fin s.degree, Col k s P i) (i j : Fin s.degree) (Q : Pt k s i) :
(F i).1 Q = some j ↔ toDiv k s P F Q.1 = j.val + 1 := by
rw [toDiv_apply, mult_nonbdry k s P F i Q]
cases (F i).1 Q with
| none => simp
| some j' => simp [Fin.ext_iff]
theorem toDiv_card [Finite k] (s : State) (P : TangentPattern s.degree)
(F : ∀ i : Fin s.degree, Col k s P i) (ij : Fin s.degree × Fin s.degree) :
Nat.card {Q : ClosedDirection k // Q ∉ boundaryDirections k s ∧
directionDegree k Q = ij.1.val + 1 ∧ toDiv k s P F Q = ij.2.val + 1} =
(P.other ij).val := by
rw [← card_fiber_eq k s (toDiv k s P F) ij.1 ij.2 (F ij.1).1 (toDiv_some_iff k s P F ij.1 ij.2)]
exact (F ij.1).2 ij.2
/-- Degree of an exceptional divisor of bounded degrees and multiplicities, split into the
boundary part and the pattern weight of its nonboundary part (the proof of the node
`divisor_degree_pattern_weight`). -/
theorem degree_formula [Finite k] (s : State) (Dv : ExceptionalDivisor k) (n : ℕ)
(hdeg : ∀ Q, 0 < Dv Q → directionDegree k Q ≤ n) (hmult : ∀ Q, Dv Q ≤ n) :
exceptionalDegree k Dv = Dv (infinityDirection k) + (match s with
| State.single _ _ => (0 : ℕ) | State.crossing _ _ _ _ => Dv (zeroDirection k)) +
∑ ij : Fin n × Fin n, (ij.1.val + 1) * (ij.2.val + 1) *
Nat.card {Q : ClosedDirection k // Q ∉ boundaryDirections k s ∧
directionDegree k Q = ij.1.val + 1 ∧ Dv Q = ij.2.val + 1} := by
classical
obtain ⟨B, hB, hBsum⟩ : ∃ B : Finset (ClosedDirection k),
(∀ Q, Q ∈ boundaryDirections k s ↔ Q ∈ B) ∧
∑ Q ∈ B, directionDegree k Q * Dv Q = Dv (infinityDirection k) +
(match s with
| State.single _ _ => (0 : ℕ) | State.crossing _ _ _ _ => Dv (zeroDirection k)) := by
cases s with
| single _ _ =>
exact ⟨{infinityDirection k}, fun Q ↦ by simp [boundaryDirections],
by simp [infinityDirection, directionDegree]⟩
| crossing _ _ _ _ =>
refine ⟨{infinityDirection k, zeroDirection k}, fun Q ↦ by simp [boundaryDirections], ?_⟩
rw [Finset.sum_pair (by simp [infinityDirection, zeroDirection])]
simp [infinityDirection, zeroDirection, directionDegree]
set f : ClosedDirection k → ℕ := fun Q ↦ directionDegree k Q * Dv Q with hf
change ∑ Q ∈ Dv.support, f Q = _
rw [← Finset.sum_filter_add_sum_filter_not Dv.support (fun Q ↦ Q ∈ B)]
congr 1
· rw [← hBsum]
refine Finset.sum_subset (fun Q hQ ↦ (Finset.mem_filter.1 hQ).2) fun Q hQB hQ ↦ ?_
have : Dv Q = 0 := by
by_contra h
exact hQ (Finset.mem_filter.2 ⟨Finsupp.mem_support_iff.2 h, hQB⟩)
simp [f, this]
· rcases n with _ | m
· simp [fun Q ↦ Nat.le_zero.1 (hmult Q)]
· set g : ClosedDirection k → Fin (m+1) × Fin (m+1) :=
fun Q ↦ (⟨(directionDegree k Q - 1) % (m+1), Nat.mod_lt _ (Nat.succ_pos _)⟩,
⟨(Dv Q - 1) % (m+1), Nat.mod_lt _ (Nat.succ_pos _)⟩)
rw [← Finset.sum_fiberwise_of_maps_to (s := Dv.support.filter (fun Q ↦ Q ∉ B))
(t := Finset.univ) (g := g) (fun _ _ ↦ Finset.mem_univ _)]
refine Finset.sum_congr rfl fun ij _ ↦ ?_
have hmem : ∀ Q, Q ∈ (Dv.support.filter (fun Q ↦ Q ∉ B)).filter (fun Q ↦ g Q = ij) ↔
(Q ∉ boundaryDirections k s ∧ directionDegree k Q = ij.1.val + 1 ∧
Dv Q = ij.2.val + 1) := by
intro Q
simp only [Finset.mem_filter, Finsupp.mem_support_iff, hB, g, Prod.ext_iff, Fin.ext_iff]
have h1 := directionDegree_pos k Q
constructor
· rintro ⟨⟨hne, hnb⟩, ha, hb⟩
have hd := hdeg Q (Nat.pos_of_ne_zero hne)
have hm := hmult Q
rw [Nat.mod_eq_of_lt (by omega)] at ha hb
exact ⟨hnb, by omega, by omega⟩
· rintro ⟨hnb, ha, hb⟩
refine ⟨⟨by omega, hnb⟩, ?_, ?_⟩
· rw [ha, Nat.add_sub_cancel, Nat.mod_eq_of_lt ij.1.2]
· rw [hb, Nat.add_sub_cancel, Nat.mod_eq_of_lt ij.2.2]
rw [Nat.card_congr (Equiv.subtypeEquivRight (fun Q ↦ (hmem Q).symm)),
Nat.card_eq_finsetCard,
Finset.sum_congr rfl (g := fun _ ↦ (ij.1.val + 1) * (ij.2.val + 1)),
Finset.sum_const, smul_eq_mul, mul_comm]
intro Q hQ
obtain ⟨_, ha, hb⟩ := (hmem Q).1 hQ
simp [f, ha, hb]
theorem toDiv_hasPattern [Finite k] (s : State) (P : TangentPattern s.degree)
(hP : P.rt.val + P.rx.val + patternWeight P.other = P.d.val)
(hrx : ∀ a c, s = State.single a c → P.rx.val = 0)
(F : ∀ i : Fin s.degree, Col k s P i) : HasPattern k s (toDiv k s P F) P := by
have hdeg : ∀ Q, 0 < toDiv k s P F Q → directionDegree k Q ≤ s.degree := by
intro Q hQ
rw [toDiv_apply] at hQ
unfold mult at hQ
split_ifs at hQ with h1 h2 h3
· subst h1
change 1 ≤ s.degree
have := P.rt.isLt; omega
· rw [deg_of_mem_bdry k s Q h2]; have := P.rx.isLt; omega
· exact h3
· exact absurd hQ (lt_irrefl 0)
have hmult : ∀ Q, toDiv k s P F Q ≤ s.degree := by
intro Q
rw [toDiv_apply]
unfold mult
split_ifs with h1 h2 h3
· exact Nat.lt_succ_iff.mp P.rt.isLt
· exact Nat.lt_succ_iff.mp P.rx.isLt
· exact elim_le _ _
· exact Nat.zero_le _
have hsum : ∑ ij : Fin s.degree × Fin s.degree, (ij.1.val + 1) * (ij.2.val + 1) *
Nat.card {Q : ClosedDirection k // Q ∉ boundaryDirections k s ∧
directionDegree k Q = ij.1.val + 1 ∧ toDiv k s P F Q = ij.2.val + 1} =
patternWeight P.other :=
Finset.sum_congr rfl fun ij _ ↦ by rw [toDiv_card k s P F ij]
refine ⟨?_, mult_inf k s P F, ?_, toDiv_card k s P F⟩
· rw [degree_formula k s (toDiv k s P F) s.degree hdeg hmult, hsum, toDiv_apply, mult_inf]
cases s with
| single a c =>
have := hrx a c rfl
change P.rt.val + 0 + patternWeight P.other = P.d.val
omega
| crossing a b c h =>
change P.rt.val + toDiv k _ P F (zeroDirection k) + patternWeight P.other = P.d.val
rwa [toDiv_apply, mult_zero_crossing]
· cases s with
| single a c => trivial
| crossing a b c h =>
change toDiv k _ P F (zeroDirection k) = P.rx.val
rw [toDiv_apply, mult_zero_crossing]
end Colorings
end TypeDensity