| import Mathlib |
| import OAI.GroupTheory.SimpleAmenable.Arithmetic.ConcurrentDenominators |
| import OAI.GroupTheory.SimpleAmenable.PolygonGeometry.FlagSites |
| import OAI.GroupTheory.SimpleAmenable.Arithmetic.QuadraticRectangleCounts |
| import OAI.GroupTheory.SimpleAmenable.Amenability.BarrierCells |
|
|
| namespace OAI |
|
|
| section |
| section |
| open scoped symmDiff |
| namespace SimpleAmenable |
| open scoped commutatorElement |
| open scoped commutatorElement |
| section BarrierLineGeometry |
| open Classical Set |
|
|
| noncomputable def barrierLinePoint (a : ℕ) (j : Fin 4) (c : CutRing) (t : ℝ) : ℝ×ℝ := |
| ![(ordinary c,t),(t,ordinary c),(t,ordinary c+Real.goldenRatio^a*t), |
| (ordinary c+Real.goldenRatio^a*t,t)] j |
|
|
| noncomputable def barrierLineParameter (j : Fin 4) (p : ℝ×ℝ) : ℝ := |
| ![p.2,p.1,p.1,p.2] j |
|
|
| noncomputable def barrierLineLower (a : ℕ) (j : Fin 4) (c : CutRing) : ℝ := |
| ![0,0,max 0 (-ordinary c/Real.goldenRatio^a),max 0 (-ordinary c/Real.goldenRatio^a)] j |
|
|
| noncomputable def barrierLineUpper (a : ℕ) (j : Fin 4) (c : CutRing) : ℝ := |
| ![1,1,min 1 ((1-ordinary c)/Real.goldenRatio^a),min 1 ((1-ordinary c)/Real.goldenRatio^a)] j |
|
|
| theorem cutForm_barrierLinePoint (a : ℕ) (j : Fin 4) (c : CutRing) (t : ℝ) : |
| cutForm a j (barrierLinePoint a j c t)=ordinary c := by |
| fin_cases j <;> simp [cutForm,barrierLinePoint] |
|
|
| theorem barrierLineParameter_point (a : ℕ) (j : Fin 4) (c : CutRing) (t : ℝ) : |
| barrierLineParameter j (barrierLinePoint a j c t)=t := by |
| fin_cases j <;> simp [barrierLineParameter,barrierLinePoint] |
|
|
| theorem barrierLinePoint_parameter {a : ℕ} {j : Fin 4} {c : CutRing} {p : ℝ×ℝ} |
| (hp : cutForm a j p=ordinary c) : barrierLinePoint a j c (barrierLineParameter j p)=p := by |
| fin_cases j <;> simp [cutForm] at hp <;> |
| apply Prod.ext <;> simp [barrierLinePoint,barrierLineParameter] <;> linarith |
|
|
| noncomputable def barrierCandidate (a : ℕ) (j : Fin 4) (N : ℝ) : Set CutRing := |
| {c | |conjugate c|≤4*N ∧ ∃p∈squareInterior,cutForm a j p=ordinary c} |
|
|
| theorem squareInterior_cutForm_bound {a : ℕ} {p : ℝ×ℝ} (hp : p∈squareInterior) (j : Fin 4) : |
| |cutForm a j p|≤1+Real.goldenRatio^a := by |
| have ht : 0<Real.goldenRatio^a := pow_pos Real.goldenRatio_pos a |
| rcases hp with ⟨⟨hx₀,hx₁⟩,⟨hy₀,hy₁⟩⟩ |
| apply abs_le.mpr |
| fin_cases j <;> simp [cutForm] <;> constructor <;> nlinarith |
|
|
| theorem barrierCandidate_finite (a : ℕ) (j : Fin 4) {N : ℝ} (hN : 0<N) : |
| (barrierCandidate a j N).Finite := by |
| apply (cutRectangle_finite (-(1+Real.goldenRatio^a)) (-4*N) |
| (2*(1+Real.goldenRatio^a)) (8*N) (by positivity)).subset |
| rintro c ⟨hc,p,hp,hpc⟩ |
| have hbound := squareInterior_cutForm_bound (a:=a) hp j |
| rw [hpc] at hbound |
| have ho := abs_le.mp hbound |
| have hb := abs_le.mp hc |
| exact ⟨⟨ho.1,by linarith [ho.2]⟩,⟨by linarith [hb.1],by linarith [hb.2]⟩⟩ |
|
|
| theorem barrierCandidate_coordinate {a : ℕ} {j : Fin 4} {N : ℝ} {c : CutRing} |
| (hc : c∈barrierCandidate a j N) (hj : j=0 ∨ j=1) : ordinary c∈Ioo (0:ℝ) 1 := by |
| obtain ⟨p,hp,hpc⟩ := hc.2 |
| rcases hj with rfl | rfl |
| · have he : p.1=ordinary c := by simpa [cutForm] using hpc |
| exact he ▸ hp.1 |
| · have he : p.2=ordinary c := by simpa [cutForm] using hpc |
| exact he ▸ hp.2 |
|
|
| theorem barrierLinePoint_interior_iff {a : ℕ} {j : Fin 4} {N : ℝ} {c : CutRing} |
| (hc : c∈barrierCandidate a j N) (t : ℝ) : |
| barrierLinePoint a j c t∈squareInterior ↔ |
| t∈Ioo (barrierLineLower a j c) (barrierLineUpper a j c) := by |
| have ht : 0<Real.goldenRatio^a := pow_pos Real.goldenRatio_pos a |
| fin_cases j <;> simp [barrierLinePoint,barrierLineLower,barrierLineUpper, |
| squareInterior,Set.mem_prod,Set.mem_Ioo] |
| · have hz := barrierCandidate_coordinate hc (Or.inl rfl) |
| exact fun _ _ => hz |
| · have hz := barrierCandidate_coordinate hc (Or.inr rfl) |
| exact fun _ _ => hz |
| · rw [div_lt_iff₀ ht,lt_div_iff₀ ht] |
| constructor <;> intro h <;> constructor <;> constructor <;> linarith [h.1.1,h.1.2,h.2.1,h.2.2] |
| · rw [div_lt_iff₀ ht,lt_div_iff₀ ht] |
| constructor <;> intro h <;> constructor <;> constructor <;> linarith [h.1.1,h.1.2,h.2.1,h.2.2] |
|
|
| end BarrierLineGeometry |
|
|
| section BarrierFlags |
| open Classical |
|
|
| noncomputable def barrierTangent (a : ℕ) (j : Fin 4) : ℝ×ℝ := |
| ![(0,1),(1,0),(1,Real.goldenRatio^a),(Real.goldenRatio^a,1)] j |
|
|
| theorem barrierLinePoint_sub (a : ℕ) (j : Fin 4) (c : CutRing) (s t : ℝ) : |
| barrierLinePoint a j c s-barrierLinePoint a j c t=(s-t) • barrierTangent a j := by |
| fin_cases j <;> apply Prod.ext <;> simp [barrierLinePoint,barrierTangent] <;> ring |
|
|
| theorem barrierTangent_cut (a : ℕ) (j : Fin 4) : cutForm a j (barrierTangent a j)=0 := by |
| fin_cases j <;> simp [barrierTangent,cutForm] |
|
|
| theorem positiveDiagonal_transverse {a : ℕ} (ha : 0<a) : TransverseDirection a (1,1) := by |
| have ht : 1<Real.goldenRatio^a := one_lt_pow₀ Real.one_lt_goldenRatio (by omega) |
| intro j |
| fin_cases j <;> simp [cutForm] <;> linarith |
|
|
| theorem exists_barrierFlagDirection {a : ℕ} (ha : 0<a) (j : Fin 4) : |
| ∃d : ℝ×ℝ,TransverseDirection a d ∧ 0<d.1 ∧ 0<d.2 ∧ ∀k, |
| (cutForm a k d<0 ↔ if cutForm a k (barrierTangent a j)=0 then |
| cutForm a k (1,1)<0 else cutForm a k (barrierTangent a j)<0) := by |
| obtain ⟨d,hd,he⟩ := flagDirections_sector |
| (show FlagDirections a (barrierTangent a j) (1,1) from |
| fun k => Or.inr (positiveDiagonal_transverse ha k)) |
| have ht : 0<Real.goldenRatio^a := pow_pos Real.goldenRatio_pos a |
| have hpos₁ : 0<d.1 := by |
| have hn : d.1≠0 := by simpa [cutForm] using hd 0 |
| have hh := he 0 |
| have hnot : ¬d.1<0 := by |
| fin_cases j <;> norm_num [cutForm,barrierTangent,ne_of_gt ht,not_lt_of_gt ht] at hh ⊢ <;> exact hh |
| exact lt_of_le_of_ne (le_of_not_gt hnot) hn.symm |
| have hpos₂ : 0<d.2 := by |
| have hn : d.2≠0 := by simpa [cutForm] using hd 1 |
| have hh := he 1 |
| have hnot : ¬d.2<0 := by |
| fin_cases j <;> norm_num [cutForm,barrierTangent,ne_of_gt ht,not_lt_of_gt ht] at hh ⊢ <;> exact hh |
| exact lt_of_le_of_ne (le_of_not_gt hnot) hn.symm |
| exact ⟨d,hd,hpos₁,hpos₂,he⟩ |
|
|
| noncomputable def barrierFlagDirection {a : ℕ} (ha : 0<a) (j : Fin 4) : ℝ×ℝ := |
| (exists_barrierFlagDirection ha j).choose |
|
|
| theorem barrierFlagDirection_spec {a : ℕ} (ha : 0<a) (j : Fin 4) : |
| TransverseDirection a (barrierFlagDirection ha j) ∧ |
| 0<(barrierFlagDirection ha j).1 ∧ 0<(barrierFlagDirection ha j).2 ∧ ∀k, |
| (cutForm a k (barrierFlagDirection ha j)<0 ↔ |
| if cutForm a k (barrierTangent a j)=0 then cutForm a k (1,1)<0 |
| else cutForm a k (barrierTangent a j)<0) := |
| (exists_barrierFlagDirection ha j).choose_spec |
|
|
| end BarrierFlags |
|
|
| section BarrierEndpoints |
| open Classical Set |
|
|
| noncomputable def barrierIncoming (a : ℕ) (j : Fin 4) (c : CutRing) : ℝ×ℝ := |
| barrierLinePoint a j c (barrierLineLower a j c) |
|
|
| theorem barrierLineLower_lt_upper {a : ℕ} {j : Fin 4} {N : ℝ} {c : CutRing} |
| (hc : c∈barrierCandidate a j N) : barrierLineLower a j c<barrierLineUpper a j c := by |
| obtain ⟨p,hp,hpc⟩ := hc.2 |
| have hh : barrierLinePoint a j c (barrierLineParameter j p)∈squareInterior := by |
| rwa [barrierLinePoint_parameter hpc] |
| exact lt_trans ((barrierLinePoint_interior_iff hc _).mp hh).1 |
| ((barrierLinePoint_interior_iff hc _).mp hh).2 |
|
|
| theorem barrierIncoming_bounds {a : ℕ} {j : Fin 4} {N : ℝ} {c : CutRing} |
| (hc : c∈barrierCandidate a j N) : |
| (barrierIncoming a j c).1∈Ico (0:ℝ) 1 ∧ (barrierIncoming a j c).2∈Ico (0:ℝ) 1 ∧ |
| ((barrierIncoming a j c).1=0 ∨ (barrierIncoming a j c).2=0) := by |
| have ht : 0<Real.goldenRatio^a := pow_pos Real.goldenRatio_pos a |
| have hgap := barrierLineLower_lt_upper hc |
| fin_cases j |
| · have hz := barrierCandidate_coordinate hc (Or.inl rfl) |
| simpa [barrierIncoming,barrierLinePoint,barrierLineLower] using |
| (show (0≤ordinary c ∧ ordinary c<1) from ⟨le_of_lt hz.1,hz.2⟩) |
| · have hz := barrierCandidate_coordinate hc (Or.inr rfl) |
| simpa [barrierIncoming,barrierLinePoint,barrierLineLower] using |
| (show (0≤ordinary c ∧ ordinary c<1) from ⟨le_of_lt hz.1,hz.2⟩) |
| · by_cases h : 0≤ordinary c |
| · have hm : max 0 (-ordinary c/Real.goldenRatio^a)=0 := |
| max_eq_left (div_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr h) ht.le) |
| simp [barrierLineLower,barrierLineUpper,hm] at hgap |
| have hb : ordinary c<1 := by |
| have := (div_pos_iff_of_pos_right ht).mp hgap |
| linarith |
| simp [barrierIncoming,barrierLinePoint,barrierLineLower,hm,h,hb] |
| · have hneg : ordinary c<0 := lt_of_not_ge h |
| have hm : max 0 (-ordinary c/Real.goldenRatio^a)= -ordinary c/Real.goldenRatio^a := |
| max_eq_right (div_nonneg (neg_nonneg.mpr hneg.le) ht.le) |
| simp [barrierLineLower,barrierLineUpper,hm] at hgap |
| have he : ordinary c+Real.goldenRatio^a*(-ordinary c/Real.goldenRatio^a)=0 := by |
| field_simp; ring |
| simp [barrierIncoming,barrierLinePoint,barrierLineLower,he, |
| div_nonneg (neg_nonneg.mpr hneg.le) ht.le,hgap.1] |
| · by_cases h : 0≤ordinary c |
| · have hm : max 0 (-ordinary c/Real.goldenRatio^a)=0 := |
| max_eq_left (div_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr h) ht.le) |
| simp [barrierLineLower,barrierLineUpper,hm] at hgap |
| have hb : ordinary c<1 := by |
| have := (div_pos_iff_of_pos_right ht).mp hgap |
| linarith |
| simp [barrierIncoming,barrierLinePoint,barrierLineLower,hm,h,hb] |
| · have hneg : ordinary c<0 := lt_of_not_ge h |
| have hm : max 0 (-ordinary c/Real.goldenRatio^a)= -ordinary c/Real.goldenRatio^a := |
| max_eq_right (div_nonneg (neg_nonneg.mpr hneg.le) ht.le) |
| simp [barrierLineLower,barrierLineUpper,hm] at hgap |
| have he : ordinary c+Real.goldenRatio^a*(-ordinary c/Real.goldenRatio^a)=0 := by |
| field_simp; ring |
| simp [barrierIncoming,barrierLinePoint,barrierLineLower,he, |
| div_nonneg (neg_nonneg.mpr hneg.le) ht.le,hgap.1] |
|
|
| theorem barrierIncoming_boundary {a : ℕ} (ha : 0<a) {j : Fin 4} {N : ℝ} {c : CutRing} |
| (hc : c∈barrierCandidate a j N) : |
| SquareBoundary (barrierFlagDirection ha j) (barrierIncoming a j c) := by |
| obtain ⟨hx,hy,_⟩ := barrierIncoming_bounds hc |
| have hd := barrierFlagDirection_spec ha j |
| exact ⟨⟨hx.1,hx.2.le⟩,⟨hy.1,hy.2.le⟩,fun _ => hd.2.1, |
| fun h => False.elim ((ne_of_lt hx.2) h),fun _ => hd.2.2.1, |
| fun h => False.elim ((ne_of_lt hy.2) h)⟩ |
|
|
| theorem barrierIncoming_edge {a : ℕ} {j : Fin 4} {N : ℝ} {c : CutRing} |
| (hc : c∈barrierCandidate a j N) : ∃k : Fin 4,k≠j ∧ |
| cutForm a k (barrierIncoming a j c)=ordinary (0:CutRing) := by |
| obtain ⟨hx,hy,hzero⟩ := barrierIncoming_bounds hc |
| have hj := cutForm_barrierLinePoint a j c (barrierLineLower a j c) |
| change cutForm a j (barrierIncoming a j c)=ordinary c at hj |
| by_cases hj₀ : j=0 |
| · subst j |
| refine ⟨1,by decide,?_⟩ |
| have hcpos := (barrierCandidate_coordinate hc (Or.inl rfl)).1 |
| have hxne : (barrierIncoming a 0 c).1≠0 := by |
| simp [cutForm] at hj |
| rw [hj]; exact ne_of_gt hcpos |
| simpa [cutForm] using hzero.resolve_left hxne |
| · rcases hzero with hzero | hzero |
| · exact ⟨0,Ne.symm hj₀,by simpa [cutForm] using hzero⟩ |
| · refine ⟨1,?_,by simpa [cutForm] using hzero⟩ |
| intro he |
| subst j |
| have hcpos := (barrierCandidate_coordinate hc (Or.inr rfl)).1 |
| simp [cutForm] at hj |
| linarith |
|
|
| theorem barrierIncoming_lattice {a : ℕ} (ha : 0<a) {j : Fin 4} {N : ℝ} {c : CutRing} |
| (hc : c∈barrierCandidate a j N) : |
| InFlagLattice (commonVertexDenominator a) (barrierIncoming a j c) := by |
| obtain ⟨k,hkj,hk⟩ := barrierIncoming_edge hc |
| obtain ⟨u,v,hu,hv⟩ := all_intersections_common_denominator ha j k hkj.symm c 0 |
| (barrierIncoming a j c) (cutForm_barrierLinePoint a j c _) hk |
| refine ⟨(u,v),Prod.ext ?_ ?_⟩ <;> simp only [scaledOrdinary] |
| · rw [hu,mul_div_cancel_left₀ _ (by exact_mod_cast Nat.ne_of_gt (commonVertexDenominator_pos ha))] |
| · rw [hv,mul_div_cancel_left₀ _ (by exact_mod_cast Nat.ne_of_gt (commonVertexDenominator_pos ha))] |
|
|
| noncomputable def barrierIncomingSite {a m : ℕ} (ha : 0<a) (i : Fin m) |
| {j : Fin 4} {N : ℝ} {c : CutRing} (hc : c∈barrierCandidate a j N) : |
| FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j) := |
| ⟨(i,⟨barrierIncoming a j c,(barrierFlagDirection_spec ha j).1,barrierIncoming_boundary ha hc⟩), |
| barrierIncoming_lattice ha hc⟩ |
|
|
| end BarrierEndpoints |
|
|
| end SimpleAmenable |
| end |
| end |
|
|
| end OAI |
|
|
