openAI-math-dataset / lean /OAI /GroupTheory /SimpleAmenable /PolygonGeometry /FlagArrangementControl.lean
| import Mathlib | |
| import OAI.GroupTheory.SimpleAmenable.PolygonGeometry.FlagSites | |
| import OAI.GroupTheory.SimpleAmenable.RandomFields.UniformThresholdCDF | |
| namespace OAI | |
| section | |
| section | |
| open scoped symmDiff | |
| namespace SimpleAmenable | |
| open scoped commutatorElement | |
| open scoped commutatorElement | |
| section FlagArrangementControl | |
| open Classical MeasureTheory | |
| theorem flagValue_arrangement {a : ℕ} {v : ℝ×ℝ} {K : Type*} | |
| (f : GenericSquare a → K) (S : Finset PlaneCut) | |
| (hS : ∀p q,(∀l∈S,squareSign l p=squareSign l q) → f p=f q) | |
| (z w : SquareFlag a v) | |
| (hs : ∀l∈S,¬ FlagSeparates l.1 l.2 z w) : | |
| flagValue f ⟨S,hS⟩ z=flagValue f ⟨S,hS⟩ w := by | |
| obtain ⟨N,hN,hz,hf⟩ := flagValue_spec f ⟨S,hS⟩ z | |
| obtain ⟨M,hM,hw,hg⟩ := flagValue_spec f ⟨S,hS⟩ w | |
| obtain ⟨p,hp,hpv⟩ := squareSector_generic z (hN.inter (arrangementNeighborhood_open a S z.val)) | |
| ⟨hz,self_mem_arrangementNeighborhood a S z.val⟩ | |
| obtain ⟨q,hq,hqv⟩ := squareSector_generic w (hM.inter (arrangementNeighborhood_open a S w.val)) | |
| ⟨hw,self_mem_arrangementNeighborhood a S w.val⟩ | |
| rw [← hf p hp.1 hpv,← hg q hq.1 hqv] | |
| apply hS p q | |
| intro l hl | |
| have h₁ := planeSign_neighborhood (p:=⟨p.val,p.property.2.2⟩) hp.2 hpv hl | |
| have h₂ := planeSign_neighborhood (p:=⟨q.val,q.property.2.2⟩) hq.2 hqv hl | |
| change squareSign l p=_ at h₁ | |
| change squareSign l q=_ at h₂ | |
| rw [h₁,h₂] | |
| apply decide_eq_decide.mpr | |
| have h := not_not.mp (hs l hl) | |
| simpa only [flagMem_halfPlane] using h | |
| theorem flagMem_arrangement {a : ℕ} {v : ℝ×ℝ} (U : polygonAlgebra a) : | |
| ∃S : Finset PlaneCut,∀z w : SquareFlag a v, | |
| (∀l∈S,¬ FlagSeparates l.1 l.2 z w) → (flagMem U z ↔ flagMem U w) := by | |
| obtain ⟨S,hS⟩ := polygon_hasSquareArrangement U.property | |
| refine ⟨S,fun z w h => ?_⟩ | |
| unfold flagMem | |
| rw [flagValue_arrangement (fun p => decide (p∈U.val)) S hS z w h] | |
| theorem separatorMatrix_zero_of_cut {a : ℕ} {v : ℝ×ℝ} | |
| {s κ : ℝ} (hs : 0 < s) (hκ : 0 < κ) (z w : SquareFlag a v) | |
| (j : Fin 4) (c : CutRing) (hc : FlagSeparates j c z w) | |
| (hcut : |conjugate c| ≤ κ/s) : | |
| separatorMatrix (thresholdLaw s κ) z w=0 := by | |
| obtain ⟨d,hd,hdmin⟩ := flagSeparates_exists_min j z w ⟨c,hc⟩ | |
| have h : κ/s < 2*κ/s := (div_lt_div_iff_of_pos_right hs).mpr (by linarith) | |
| have hd' : |conjugate d| ≤ κ/s := (hdmin c hc).trans hcut | |
| have hp : directionNoCutProbability s κ j z w=0 := by | |
| rw [directionNoCutProbability,directionNoCut_of_min j z w d hd hdmin, | |
| uniformInterval_Iio h,intervalCDF] | |
| rw [max_eq_right (by linarith [min_le_right (2*κ/s) |conjugate d|]),zero_div] | |
| rw [separatorMatrix_product hs hκ] | |
| exact Finset.prod_eq_zero (Finset.mem_univ j) hp | |
| theorem separatorMatrix_ne_zero_signs {a : ℕ} {v : ℝ×ℝ} | |
| {s κ : ℝ} (hs : 0 < s) (hκ : 0 < κ) (S : Finset PlaneCut) | |
| (hS : ∀l∈S,|conjugate l.2| ≤ κ/s) (z w : SquareFlag a v) | |
| (hp : separatorMatrix (thresholdLaw s κ) z w ≠ 0) : | |
| ∀l∈S,¬ FlagSeparates l.1 l.2 z w := by | |
| intro l hl hsep | |
| exact hp (separatorMatrix_zero_of_cut hs hκ z w l.1 l.2 hsep (hS l hl)) | |
| theorem separatorMatrix_controls_step {a : ℕ} {v : ℝ×ℝ} {K : Type*} | |
| (f : GenericSquare a → K) (hf : HasSquareArrangement f) : | |
| ∃R : ℝ, 0 ≤ R ∧ ∀(s κ : ℝ),0 < s → 0 < κ → R ≤ κ/s → | |
| ∀z w : SquareFlag a v,separatorMatrix (thresholdLaw s κ) z w ≠ 0 → | |
| flagValue f hf z=flagValue f hf w := by | |
| obtain ⟨S,hS⟩ := hf | |
| let R := ∑l∈S,|conjugate l.2| | |
| have hR : 0 ≤ R := Finset.sum_nonneg (fun _ _ => abs_nonneg _) | |
| refine ⟨R,hR,fun s κ hs hκ hRs z w hp => ?_⟩ | |
| apply flagValue_arrangement f S hS z w | |
| apply separatorMatrix_ne_zero_signs hs hκ S _ z w hp | |
| intro l hl | |
| exact (Finset.single_le_sum (fun _ _ => abs_nonneg _) hl).trans hRs | |
| end FlagArrangementControl | |
| section SquareAffineCharts | |
| open Classical | |
| theorem floor_add_unit {x : ℝ} (hx₀ : 0 ≤ x) (hx₁ : x < 1) (y : ℝ) : | |
| ⌊x+y⌋ = ⌊y⌋ + if x < 1-Int.fract y then 0 else 1 := by | |
| have hy₀ := Int.floor_le y | |
| have hy₁ := Int.lt_floor_add_one y | |
| by_cases h : x < 1-Int.fract y | |
| · rw [ite_eq_left h,add_zero] | |
| simp only [Int.fract] at h | |
| apply Int.floor_eq_iff.mpr | |
| constructor <;> linarith | |
| · rw [ite_eq_right h] | |
| simp only [Int.fract] at h | |
| apply Int.floor_eq_iff.mpr | |
| push_cast | |
| constructor <;> linarith | |
| noncomputable def squareTranslationPeriod {a : ℕ} (u : CutRing×CutRing) | |
| (p : GenericSquare a) : ℤ×ℤ := | |
| (⌊p.val.1+ordinary u.1⌋,⌊p.val.2+ordinary u.2⌋) | |
| theorem squareTranslationPeriod_arrangement {a : ℕ} (u : CutRing×CutRing) : | |
| HasSquareArrangement (squareTranslationPeriod (a:=a) u) := by | |
| let c₁ : CutRing := (⌊ordinary u.1⌋:CutRing)+1-u.1 | |
| let c₂ : CutRing := (⌊ordinary u.2⌋:CutRing)+1-u.2 | |
| have hc₁ : ordinary c₁=1-Int.fract (ordinary u.1) := by simp only [c₁,map_sub,map_add,map_intCast,map_one,Int.fract]; ring | |
| have hc₂ : ordinary c₂=1-Int.fract (ordinary u.2) := by simp only [c₂,map_sub,map_add,map_intCast,map_one,Int.fract]; ring | |
| refine ⟨{(0,c₁),(1,c₂)},fun p q h => ?_⟩ | |
| have h₁ := decide_eq_decide.mp (h (0,c₁) (by simp)) | |
| have h₂ := decide_eq_decide.mp (h (1,c₂) (by simp)) | |
| change (p.val.1<ordinary c₁ ↔ q.val.1<ordinary c₁) at h₁ | |
| change (p.val.2<ordinary c₂ ↔ q.val.2<ordinary c₂) at h₂ | |
| rw [hc₁] at h₁ | |
| rw [hc₂] at h₂ | |
| apply Prod.ext | |
| · change ⌊p.val.1+ordinary u.1⌋=⌊q.val.1+ordinary u.1⌋ | |
| rw [floor_add_unit p.property.1.1 p.property.1.2,floor_add_unit q.property.1.1 q.property.1.2] | |
| simp only [h₁] | |
| · change ⌊p.val.2+ordinary u.2⌋=⌊q.val.2+ordinary u.2⌋ | |
| rw [floor_add_unit p.property.2.1.1 p.property.2.1.2,floor_add_unit q.property.2.1.1 q.property.2.1.2] | |
| simp only [h₂] | |
| theorem squareTranslationPeriod_germ {a : ℕ} {v : ℝ×ℝ} | |
| (u : CutRing×CutRing) (z : SquareFlag a v) : | |
| IsSquareGerm (squareTranslationPeriod u) z (flagShiftPeriod u z) := by | |
| let k := flagShiftPeriod u z | |
| let t := u-SquareStep.intPair k | |
| let b : ℝ×ℝ := (ordinary t.1,ordinary t.2) | |
| have hbase : (flagTranslate u z).val=z.val+b := by | |
| apply Prod.ext <;> simp only [flagTranslate_val,flagFract_eq,b,t,k,flagShiftPeriod,SquareStep.intPair, | |
| Prod.fst_sub,Prod.snd_sub,Prod.fst_add,Prod.snd_add,map_sub,map_intCast] <;> ring | |
| let M : Set (ℝ×ℝ) := (fun p => p+b) ⁻¹' arrangementNeighborhood a SquareStep.squareEdgeCuts (flagTranslate u z).val | |
| refine ⟨M,(arrangementNeighborhood_open _ _ _).preimage (continuous_id.add continuous_const),?_,fun p hp hpv => ?_⟩ | |
| · change z.val+b ∈ arrangementNeighborhood a SquareStep.squareEdgeCuts (flagTranslate u z).val | |
| rw [← hbase] | |
| exact self_mem_arrangementNeighborhood _ _ _ | |
| · let q : GenericPlane a := GenericPlane.shift t ⟨p.val,p.property.2.2⟩ | |
| have hqv : q.val ∈ planeSector a (flagTranslate u z).val v := by | |
| rw [hbase] | |
| exact (planeSector_add_iff z.val v b p.val).mpr hpv | |
| have hpq : q.val ∈ arrangementNeighborhood a SquareStep.squareEdgeCuts (flagTranslate u z).val := hp | |
| have hqs := sector_enters_square (flagTranslate u z).property.2 hpq hqv | |
| have hx : 0 ≤ p.val.1+ordinary u.1-(k.1:ℝ) ∧ p.val.1+ordinary u.1-(k.1:ℝ) < 1 := by | |
| simpa only [q,GenericPlane.shift,t,SquareStep.intPair,Prod.fst_add,Prod.fst_sub,map_sub,map_intCast,← add_sub_assoc,Set.mem_Ico] using hqs.1 | |
| have hy : 0 ≤ p.val.2+ordinary u.2-(k.2:ℝ) ∧ p.val.2+ordinary u.2-(k.2:ℝ) < 1 := by | |
| simpa only [q,GenericPlane.shift,t,SquareStep.intPair,Prod.snd_add,Prod.snd_sub,map_sub,map_intCast,← add_sub_assoc,Set.mem_Ico] using hqs.2 | |
| apply Prod.ext | |
| · exact Int.floor_eq_iff.mpr ⟨by linarith [hx.1],by linarith [hx.2]⟩ | |
| · exact Int.floor_eq_iff.mpr ⟨by linarith [hy.1],by linarith [hy.2]⟩ | |
| theorem squareTranslationPeriod_flagValue {a : ℕ} {v : ℝ×ℝ} | |
| (u : CutRing×CutRing) (z : SquareFlag a v) : | |
| flagValue (squareTranslationPeriod u) (squareTranslationPeriod_arrangement u) z=flagShiftPeriod u z := | |
| flagValue_eq _ _ _ (squareTranslationPeriod_germ u z) | |
| theorem squareArrangement_pair {a : ℕ} {K J : Type*} {f : GenericSquare a → K} {g : GenericSquare a → J} | |
| (hf : HasSquareArrangement f) (hg : HasSquareArrangement g) : | |
| HasSquareArrangement (fun p => (f p,g p)) := by | |
| obtain ⟨S,hS⟩ := hf | |
| obtain ⟨T,hT⟩ := hg | |
| refine ⟨S∪T,fun p q h => Prod.ext (hS p q (fun l hl => h l (Finset.mem_union_left _ hl))) | |
| (hT p q (fun l hl => h l (Finset.mem_union_right _ hl)))⟩ | |
| theorem squareArrangement_finite_family {a : ℕ} {ι K : Type*} [Finite ι] | |
| (f : ι → GenericSquare a → K) (hf : ∀i,HasSquareArrangement (f i)) : | |
| HasSquareArrangement (fun p i => f i p) := by | |
| let := Fintype.ofFinite ι | |
| choose S hS using hf | |
| refine ⟨Finset.univ.biUnion S,fun p q h => funext (fun i => hS i p q (fun l hl => ?_))⟩ | |
| exact h l (Finset.mem_biUnion.mpr ⟨i,Finset.mem_univ _,hl⟩) | |
| end SquareAffineCharts | |
| end SimpleAmenable | |
| end | |
| end | |
| end OAI | |