File size: 4,828 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
import OAI.NumberTheory.PiExponent.Geometry.CurveCenters
import OAI.NumberTheory.PiExponent.Geometry.WeightedCurveRigidity

namespace OAI

noncomputable section
namespace PiExponent.CurveFieldRigidity

open scoped BigOperators
open PiExponentApprox PersistentWeightComparison CurveCenters CurveValuationCenter

variable {E : Type*} [Field E] [Algebra β„‚ E]

def coordinateKernel {n : β„•} (x : Fin n β†’ E) : Ideal (MvPolynomial (Fin n) β„‚) :=
  RingHom.ker (MvPolynomial.aeval x).toRingHom

instance coordinateKernel_isPrime {n : β„•} (x : Fin n β†’ E) : (coordinateKernel x).IsPrime :=
  RingHom.ker_isPrime _

@[simp] theorem mem_coordinateKernel {n : β„•} (x : Fin n β†’ E)
    (p : MvPolynomial (Fin n) β„‚) : p ∈ coordinateKernel x ↔ MvPolynomial.aeval x p = 0 :=
  Iff.rfl

theorem logarithmic_coordinate_eq_one {m : β„•}
    (x : Fin (m+1) β†’ E) (a : Fin (m+1) β†’ β„‚) (ha : a 0 = 1)
    (p : NormalizedPlace β„‚ E) (hp : Centered x a p)
    (hheight : (coordinateKernel x).height ≀ m)
    (rho : Fin (m+1) β†’ β„š) (hrho : βˆ€ i, 0 < rho i)
    (cost : Fin (m+1) β†’ ℝ) (hcost : βˆ€ i, 0 < cost i)
    (sigma N : ℝ) (hsigma : 0 < sigma) (hN : 0 < N)
    (hrect : UniformRectangles (m+1) cost (sigma / ((m : ℝ)+2)) N)
    (F : FramePolynomial m) (hF0 : F β‰  0)
    (hF : HasWeightedDegreeLE (fun i => (rho i : ℝ)) N F)
    (hvanish : βˆ€ word : List (Fin (m+1)), frameWordCost cost word ≀ sigma*N β†’
      MvPolynomial.aeval x (polynomialFrameWord m word F) = 0)
    (hseparated : βˆ€ A B : Finset (Fin (m+1)), A.card = B.card β†’
      βˆ€ i, i β‰  0 β†’ i ∈ A β†’ i βˆ‰ B β†’
      (βˆ€ j, i < j β†’ (j ∈ A ↔ j ∈ B)) β†’
      comparisonConstant m sigma * (∏ j ∈ B, cost j) < ∏ j ∈ A, (rho j : ℝ)) :
    x 0 = 1 := by
  have hx0 : x 0 β‰  0 := by
    intro hz
    have hc := hp.constant_coordinate 0 0 (by simpa using hz)
    rw [ha] at hc
    exact zero_ne_one hc
  have hY : MvPolynomial.X (0 : Fin (m+1)) βˆ‰ coordinateKernel x := by
    simpa only [mem_coordinateKernel, MvPolynomial.aeval_X] using hx0
  have hepsilon : 0 < sigma / ((m : ℝ)+2) := by positivity
  have hbound : ((m : ℝ)+2) * ((sigma / ((m : ℝ)+2))*N) = sigma*N := by
    have hm : (m : ℝ)+2 β‰  0 := by positivity
    field_simp
  obtain ⟨c, hc⟩ := CurveComponentRigidity.coordinate_constant_of_persistent_comparison
    (fun i => (rho i : ℝ)) cost (comparisonConstant m sigma)
    ((sigma / ((m : ℝ)+2))*N) (fun i => (hcost i).le) (by positivity)
    F hF0 (coordinateKernel x) inferInstance hheight hY
    (fun word hword => hvanish word (by simpa only [hbound] using hword))
    (logarithmic_persistent_comparison rho hrho cost hcost sigma N hsigma hN hrect
      F hF (coordinateKernel x) hY) hseparated
  have hxc : x 0 = algebraMap β„‚ E c := by
    simpa only [mem_coordinateKernel, map_sub, MvPolynomial.aeval_X,
      MvPolynomial.aeval_C, sub_eq_zero] using hc
  have hc1 := hp.constant_coordinate 0 c hxc
  rw [ha] at hc1
  simpa only [hc1, map_one] using hxc

theorem ordinary_coordinate_constant {m n : β„•} (hn : n ≀ m+2)
    (x : Fin n β†’ E) (d : β„•) (hd : d ≀ m)
    (hheight : (coordinateKernel x).height ≀ d)
    (rho : Fin n β†’ β„š) (hrho : βˆ€ i, 0 < rho i)
    (cost : Fin n β†’ ℝ) (hcost : βˆ€ i, 0 < cost i)
    (sigma N : ℝ) (hsigma : 0 < sigma) (hN : 0 < N)
    (hrect : UniformRectangles n cost (sigma / ((m : ℝ)+2)) N)
    (F : OrdinaryDerivatives.Polynomial n) (hF0 : F β‰  0)
    (hF : WeightedSliceDegree.SupportBound (fun i => (rho i : ℝ)) N F)
    (hvanish : βˆ€ word : List (Fin n), DerivativeIdeals.wordCost cost word ≀ sigma*N β†’
      MvPolynomial.aeval x (OrdinaryDerivatives.word n word F) = 0)
    (hseparated : βˆ€ A B : Finset (Fin n), A.card = B.card β†’
      βˆ€ i, i ∈ A β†’ i βˆ‰ B β†’ (βˆ€ j, i < j β†’ (j ∈ A ↔ j ∈ B)) β†’
      comparisonConstant m sigma * (∏ j ∈ B, cost j) < ∏ j ∈ A, (rho j : ℝ)) :
    βˆƒ i : Fin n, βˆƒ c : β„‚, x i = algebraMap β„‚ E c := by
  obtain ⟨i,c,hc⟩ := WeightedCurveRigidity.ordinary_coordinate_constant hn
    rho hrho cost hcost sigma N hsigma hN hrect F hF0 hF d hd
    (coordinateKernel x) inferInstance hheight hvanish hseparated
  refine ⟨i,c,?_⟩
  simpa only [mem_coordinateKernel, map_sub, MvPolynomial.aeval_X,
    MvPolynomial.aeval_C, sub_eq_zero] using hc

theorem fibre_generates {m : β„•} (x : Fin m β†’ E)
    (hx : IntermediateField.adjoin β„‚
      (Set.range (Fin.cases (1 : E) x : Fin (m+1) β†’ E)) = ⊀) :
    IntermediateField.adjoin β„‚ (Set.range x) = ⊀ := by
  apply top_unique
  rw [← hx]
  apply IntermediateField.adjoin_le_iff.mpr
  rintro _ ⟨i, rfl⟩
  cases i using Fin.cases with
  | zero => exact one_mem _
  | succ i => exact IntermediateField.subset_adjoin β„‚ _ ⟨i,rfl⟩

end PiExponent.CurveFieldRigidity
end

end OAI