openAI-math-dataset / lean /OAI /GroupTheory /SimpleAmenable /PolygonGeometry /ConcurrentAnchors.lean
| import Mathlib | |
| import OAI.GroupTheory.SimpleAmenable.PolygonGeometry.TangentChartTemplates | |
| import OAI.GroupTheory.SimpleAmenable.Arithmetic.ConcurrentDenominators | |
| namespace OAI | |
| section | |
| section | |
| open scoped symmDiff | |
| namespace SimpleAmenable | |
| open scoped commutatorElement | |
| open scoped commutatorElement | |
| section ConcurrentAnchors | |
| theorem allowable_line_anchor (a : ℕ) (j : Fin 4) (c : CutRing) | |
| (z : ℝ × ℝ) (hz : cutForm a j z=ordinary c) {ε : ℝ} (hε : 0<ε) : | |
| ∃ u : CutRing × CutRing, integralCutForm a j u=c ∧ | |
| dist (ordinary u.1,ordinary u.2) z<ε := by | |
| by_cases hj : j=2 ∨ j=3 | |
| · exact slope_line_anchor a j hj c z hz hε | |
| fin_cases j | |
| · obtain ⟨y,hy,hy'⟩ := exists_cut_between (x := z.2-ε) (y := z.2+ε) (by linarith) | |
| refine ⟨(c,y),by simp [integralCutForm],?_⟩ | |
| have hx : z.1=ordinary c := hz | |
| rw [Prod.dist_eq,Real.dist_eq,Real.dist_eq,← hx,sub_self,abs_zero,max_eq_right (abs_nonneg _)] | |
| exact abs_lt.mpr ⟨by linarith,by linarith⟩ | |
| · obtain ⟨x,hx,hx'⟩ := exists_cut_between (x := z.1-ε) (y := z.1+ε) (by linarith) | |
| refine ⟨(x,c),by simp [integralCutForm],?_⟩ | |
| have hy : z.2=ordinary c := hz | |
| rw [Prod.dist_eq,Real.dist_eq,Real.dist_eq,← hy,sub_self,abs_zero,max_eq_left (abs_nonneg _)] | |
| exact abs_lt.mpr ⟨by linarith,by linarith⟩ | |
| · exact False.elim (hj (Or.inl rfl)) | |
| · exact False.elim (hj (Or.inr rfl)) | |
| abbrev VertexType (D : ℕ) := (Fin D × Fin D) × (Fin D × Fin D) | |
| def AllowableVertexLine (a : ℕ) (z : ℝ × ℝ) (j : Fin 4) : Prop := | |
| ∃ c : CutRing, cutForm a j z=ordinary c | |
| theorem finite_vertex_anchors (a D : ℕ) {ε : ℝ} (hε : 0<ε) : | |
| ∃ U : VertexType D → Fin 4 → CutRing × CutRing, | |
| ∀ t j, AllowableVertexLine a (vertexRepresentative D t) j → | |
| cutForm a j (vertexRepresentative D t)=ordinary (integralCutForm a j (U t j)) ∧ | |
| dist (ordinary (U t j).1,ordinary (U t j).2) (vertexRepresentative D t)<ε := by | |
| classical | |
| have h (t : VertexType D) (j : Fin 4) : ∃ u : CutRing × CutRing, | |
| AllowableVertexLine a (vertexRepresentative D t) j → | |
| cutForm a j (vertexRepresentative D t)=ordinary (integralCutForm a j u) ∧ | |
| dist (ordinary u.1,ordinary u.2) (vertexRepresentative D t)<ε := by | |
| by_cases h : AllowableVertexLine a (vertexRepresentative D t) j | |
| · obtain ⟨c,hc⟩ := h | |
| obtain ⟨u,hu,hd⟩ := allowable_line_anchor a j c _ hc hε | |
| exact ⟨u,fun _ => ⟨by rw [hu]; exact hc,hd⟩⟩ | |
| · exact ⟨0,fun hh => (h hh).elim⟩ | |
| choose U hU using h | |
| exact ⟨U,hU⟩ | |
| theorem representative_line_allowable (a D : ℕ) (t : VertexType D) | |
| (u : CutRing × CutRing) (j : Fin 4) (c : CutRing) (z : ℝ × ℝ) | |
| (hz : z=vertexRepresentative D t+(ordinary u.1,ordinary u.2)) | |
| (hc : cutForm a j z=ordinary c) : AllowableVertexLine a (vertexRepresentative D t) j := by | |
| refine ⟨c-integralCutForm a j u,?_⟩ | |
| rw [hz,cutForm_add,cutForm_ordinary] at hc | |
| rw [map_sub] | |
| linarith | |
| theorem translated_vertex_anchors (a D : ℕ) {ε : ℝ} | |
| (U : VertexType D → Fin 4 → CutRing × CutRing) | |
| (hU : ∀ t j, AllowableVertexLine a (vertexRepresentative D t) j → | |
| cutForm a j (vertexRepresentative D t)=ordinary (integralCutForm a j (U t j)) ∧ | |
| dist (ordinary (U t j).1,ordinary (U t j).2) (vertexRepresentative D t)<ε) | |
| (t : VertexType D) (u : CutRing × CutRing) (j : Fin 4) (c : CutRing) (z : ℝ × ℝ) | |
| (hz : z=vertexRepresentative D t+(ordinary u.1,ordinary u.2)) | |
| (hc : cutForm a j z=ordinary c) : | |
| integralCutForm a j (u+U t j)=c ∧ | |
| dist (ordinary (u+U t j).1,ordinary (u+U t j).2) z<ε := by | |
| obtain ⟨he,hd⟩ := hU t j (representative_line_allowable a D t u j c z hz hc) | |
| constructor | |
| · apply ordinary_injective | |
| rw [← cutForm_ordinary] | |
| have hpair : (ordinary (u+U t j).1,ordinary (u+U t j).2)= | |
| (ordinary (U t j).1,ordinary (U t j).2)+(ordinary u.1,ordinary u.2) := by | |
| ext <;> simp [add_comm] | |
| rw [hpair,cutForm_add,cutForm_ordinary,← he,← cutForm_add,← hz,hc] | |
| · have hpair : (ordinary (u+U t j).1,ordinary (u+U t j).2)= | |
| (ordinary (U t j).1,ordinary (U t j).2)+(ordinary u.1,ordinary u.2) := by | |
| ext <;> simp [add_comm] | |
| rwa [hpair,hz,dist_add_right] | |
| theorem concurrent_chart_tables_eventually {a m D : ℕ} {r : CutRing} {hm : 2 ≤ m} | |
| {ι : Type*} [Finite ι] | |
| (hr : 0 < ordinary r ∧ ordinary r < 1/2) (hm' : 15 ≤ m+1) | |
| (U : VertexType D → Fin 4 → CutRing × CutRing) | |
| (P : VertexType D → ι → Fin 5 × (CutRing × CutRing)) : | |
| ∃ L : ℕ, ∀ M : ℕ, L ≤ M → ∀ B : InitialCoverSystem a r m hm M, | |
| ∀ t u I b hb, B.PrimitiveFamilyLaw I b hb | |
| (translatedTemplate (Sum.elim | |
| (fun j : Fin 4 => (⟨j.val+1,by omega⟩,U t j)) (P t)) u) := by | |
| exact fixedChartTables_eventually hr hm' | |
| (fun t => Sum.elim (fun j : Fin 4 => (⟨j.val+1,by omega⟩,U t j)) (P t)) | |
| end ConcurrentAnchors | |
| section LineIntersectionBounds | |
| theorem real_two_lines_intersect (A B C E c d : ℝ) (h : A*E-C*B ≠ 0) : | |
| ∃ z : ℝ × ℝ, A*z.1+B*z.2=c ∧ C*z.1+E*z.2=d := by | |
| refine ⟨((c*E-d*B)/(A*E-C*B),(A*d-C*c)/(A*E-C*B)),?_,?_⟩ <;> | |
| dsimp only <;> rw [← mul_div_assoc, ← mul_div_assoc, ← add_div] <;> | |
| apply (div_eq_iff h).mpr <;> ring | |
| theorem real_two_lines_distance_bound (A B C E c d : ℝ) (h : A*E-C*B ≠ 0) | |
| (z p : ℝ × ℝ) (hz : A*z.1+B*z.2=c) (hz' : C*z.1+E*z.2=d) | |
| (δ : ℝ) (hδ : 0≤δ) | |
| (hp : |c-(A*p.1+B*p.2)| ≤ δ) (hp' : |d-(C*p.1+E*p.2)| ≤ δ) : | |
| dist z p ≤ ((|A| + |B| + |C| + |E|)/|A*E-C*B|)*δ := by | |
| have hd : 0 < |A*E-C*B| := abs_pos.mpr h | |
| have hx : (A*E-C*B)*(z.1-p.1)=E*(c-(A*p.1+B*p.2))-B*(d-(C*p.1+E*p.2)) := by | |
| linear_combination E*hz-B*hz' | |
| have hy : (A*E-C*B)*(z.2-p.2)=A*(d-(C*p.1+E*p.2))-C*(c-(A*p.1+B*p.2)) := by | |
| linear_combination A*hz'-C*hz | |
| have hx' : |A*E-C*B| * |z.1-p.1| ≤ (|E| + |B|)*δ := by | |
| rw [← abs_mul,hx] | |
| calc | |
| _ ≤ |E*(c-(A*p.1+B*p.2))| + |B*(d-(C*p.1+E*p.2))| := abs_sub _ _ | |
| _ ≤ |E| * δ+|B| * δ := by | |
| rw [abs_mul,abs_mul] | |
| exact add_le_add (mul_le_mul_of_nonneg_left hp (abs_nonneg _)) | |
| (mul_le_mul_of_nonneg_left hp' (abs_nonneg _)) | |
| _ = _ := by ring | |
| have hy' : |A*E-C*B| * |z.2-p.2| ≤ (|A| + |C|)*δ := by | |
| rw [← abs_mul,hy] | |
| calc | |
| _ ≤ |A*(d-(C*p.1+E*p.2))| + |C*(c-(A*p.1+B*p.2))| := abs_sub _ _ | |
| _ ≤ |A| * δ+|C| * δ := by | |
| rw [abs_mul,abs_mul] | |
| exact add_le_add (mul_le_mul_of_nonneg_left hp' (abs_nonneg _)) | |
| (mul_le_mul_of_nonneg_left hp (abs_nonneg _)) | |
| _ = _ := by ring | |
| rw [Prod.dist_eq,Real.dist_eq,Real.dist_eq,max_le_iff] | |
| rw [div_mul_eq_mul_div] | |
| constructor | |
| · apply (le_div_iff₀ hd).mpr | |
| nlinarith [abs_nonneg A,abs_nonneg C] | |
| · apply (le_div_iff₀ hd).mpr | |
| nlinarith [abs_nonneg B,abs_nonneg E] | |
| theorem real_lineDet_ne_zero {a : ℕ} (ha : 0<a) (i j : Fin 4) (hij : i≠j) : | |
| ordinary (lineNormal a i).1*ordinary (lineNormal a j).2- | |
| ordinary (lineNormal a j).1*ordinary (lineNormal a i).2 ≠ 0 := by | |
| have hh := ordinary_injective.ne (lineDet_ne_zero ha i j hij) | |
| simpa only [lineDet,map_sub,map_mul,map_zero] using hh | |
| theorem allowable_lines_intersect {a : ℕ} (ha : 0<a) (i j : Fin 4) (hij : i≠j) | |
| (c d : CutRing) : ∃ z : ℝ × ℝ, cutForm a i z=ordinary c ∧ cutForm a j z=ordinary d := by | |
| obtain ⟨z,hz,hz'⟩ := real_two_lines_intersect _ _ _ _ (ordinary c) (ordinary d) | |
| (real_lineDet_ne_zero ha i j hij) | |
| exact ⟨z,by rwa [cutForm_normal],by rwa [cutForm_normal]⟩ | |
| end LineIntersectionBounds | |
| end SimpleAmenable | |
| end | |
| end | |
| end OAI | |