| import Mathlib |
| import OAI.GroupTheory.SimpleAmenable.Amenability.BarrierLineGeometry |
| |
| namespace OAI |
|
|
| section |
| section |
| open scoped symmDiff |
| namespace SimpleAmenable |
| open scoped commutatorElement |
| open scoped commutatorElement |
| section BarrierAlgorithm |
| open Classical Set |
|
|
| noncomputable def barrierSitePoint {a m D : ℕ} {v : ℝ×ℝ} (z : FlagSite a m D v) : ℝ×ℝ := |
| z.val.2.val |
|
|
| theorem flagSite_eq_of_track_point {a m D : ℕ} {v : ℝ×ℝ} |
| {z w : FlagSite a m D v} (ht : z.val.1=w.val.1) |
| (hp : barrierSitePoint z=barrierSitePoint w) : z=w := by |
| apply Subtype.ext |
| exact Prod.ext ht (Subtype.ext hp) |
|
|
| noncomputable def barrierMarkedParameters {a m : ℕ} (ha : 0<a) (i : Fin m) |
| (j : Fin 4) (c : CutRing) |
| (M : Finset (FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j))) : Finset ℝ := |
| (M.filter (fun z => z.val.1=i ∧ barrierSitePoint z∈squareInterior ∧ |
| cutForm a j (barrierSitePoint z)=ordinary c)).image |
| (fun z => barrierLineParameter j (barrierSitePoint z)) |
|
|
| noncomputable def barrierSubdivision {a m : ℕ} (ha : 0<a) (i : Fin m) |
| (j : Fin 4) (c : CutRing) |
| (M : Finset (FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j))) : Finset ℝ := |
| {barrierLineLower a j c,barrierLineUpper a j c} ∪ barrierMarkedParameters ha i j c M |
|
|
| noncomputable def barrierActivation {a m : ℕ} (ha : 0<a) (i : Fin m) |
| (j : Fin 4) (c : CutRing) |
| (b : FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j) → Bool) |
| (s : ℝ) : Bool := decide (∃z,z.val.1=i ∧ |
| barrierSitePoint z=barrierLinePoint a j c s ∧ b z=true) |
|
|
| def ConsecutiveSubdivision (E : Finset ℝ) (s t : ℝ) : Prop := |
| s∈E ∧ t∈E ∧ s<t ∧ ∀r∈E,s<r → t≤r |
|
|
| noncomputable def barrierActiveIntervals {a m : ℕ} (ha : 0<a) (i : Fin m) |
| (j : Fin 4) (c : CutRing) |
| (M : Finset (FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j))) |
| (b : FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j) → Bool) : |
| Finset (ℝ×ℝ) := |
| ((barrierSubdivision ha i j c M) ×ˢ (barrierSubdivision ha i j c M)).filter |
| (fun st => ConsecutiveSubdivision (barrierSubdivision ha i j c M) st.1 st.2 ∧ |
| barrierActivation ha i j c b st.1=true) |
|
|
| theorem barrierActivation_at_site {a m : ℕ} (ha : 0<a) (i : Fin m) |
| (j : Fin 4) (c : CutRing) |
| (b : FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j) → Bool) |
| (s : ℝ) (z : FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j)) |
| (ht : z.val.1=i) (hp : barrierSitePoint z=barrierLinePoint a j c s) : |
| barrierActivation ha i j c b s=b z := by |
| apply Bool.eq_iff_iff.mpr |
| simp only [barrierActivation,decide_eq_true_eq] |
| constructor |
| · rintro ⟨w,hw,hwp,hb⟩ |
| have he : w=z := flagSite_eq_of_track_point (hw.trans ht.symm) (hwp.trans hp.symm) |
| simpa [he] using hb |
| · intro hb |
| exact ⟨z,ht,hp,hb⟩ |
|
|
| theorem mem_barrierSubdivision_bounds {a m : ℕ} (ha : 0<a) (i : Fin m) |
| {j : Fin 4} {N : ℝ} {c : CutRing} (hc : c∈barrierCandidate a j N) |
| (M : Finset (FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j))) |
| {s : ℝ} (hs : s∈barrierSubdivision ha i j c M) : |
| s∈Icc (barrierLineLower a j c) (barrierLineUpper a j c) := by |
| have hgap := (barrierLineLower_lt_upper hc).le |
| simp only [barrierSubdivision,Finset.mem_union,Finset.mem_insert,Finset.mem_singleton] at hs |
| rcases hs with (rfl | rfl) | hs |
| · exact ⟨le_rfl,hgap⟩ |
| · exact ⟨hgap,le_rfl⟩ |
| · obtain ⟨z,hz,rfl⟩ := Finset.mem_image.mp hs |
| obtain ⟨_,hzt,hzp,hzc⟩ := Finset.mem_filter.mp hz |
| have hp : barrierLinePoint a j c (barrierLineParameter j (barrierSitePoint z))∈squareInterior := by |
| rwa [barrierLinePoint_parameter hzc] |
| exact ⟨((barrierLinePoint_interior_iff hc _).mp hp).1.le, |
| ((barrierLinePoint_interior_iff hc _).mp hp).2.le⟩ |
|
|
| theorem barrierSubdivision_start_site {a m : ℕ} (ha : 0<a) (i : Fin m) |
| {j : Fin 4} {N : ℝ} {c : CutRing} (hc : c∈barrierCandidate a j N) |
| (M : Finset (FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j))) |
| {s t : ℝ} (h : ConsecutiveSubdivision (barrierSubdivision ha i j c M) s t) : |
| ∃z : FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j), |
| z.val.1=i ∧ barrierSitePoint z=barrierLinePoint a j c s ∧ |
| (s=barrierLineLower a j c ∨ z∈M) := by |
| have hs := h.1 |
| have ht := mem_barrierSubdivision_bounds ha i hc M h.2.1 |
| simp only [barrierSubdivision,Finset.mem_union,Finset.mem_insert,Finset.mem_singleton] at hs |
| rcases hs with (rfl | rfl) | hs |
| · exact ⟨barrierIncomingSite ha i hc,rfl,rfl,Or.inl rfl⟩ |
| · exact False.elim (not_lt_of_ge ht.2 h.2.2.1) |
| · obtain ⟨z,hz,rfl⟩ := Finset.mem_image.mp hs |
| obtain ⟨hzM,hzt,hzp,hzc⟩ := Finset.mem_filter.mp hz |
| exact ⟨z,hzt,(barrierLinePoint_parameter hzc).symm,Or.inr hzM⟩ |
|
|
| def BarrierLineIndex (a : ℕ) (N : ℝ) := Σj : Fin 4,{c : CutRing // c∈barrierCandidate a j N} |
|
|
| @[instance_reducible] noncomputable def barrierLineIndexFintype (a : ℕ) {N : ℝ} (hN : 0<N) : |
| Fintype (BarrierLineIndex a N) := by |
| letI (j : Fin 4) : Fintype {c : CutRing // c∈barrierCandidate a j N} := |
| (barrierCandidate_finite a j hN).fintype |
| exact inferInstanceAs (Fintype (Σj : Fin 4,{c : CutRing // c∈barrierCandidate a j N})) |
|
|
| noncomputable def sampledBarriers {a m : ℕ} (ha : 0<a) (i : Fin m) (N : ℝ) |
| (M : ∀j,Finset (FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j))) |
| (b : ∀j,FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j) → Bool) : |
| Set (ℝ×ℝ) := |
| {p | ∃l : BarrierLineIndex a N,∃st∈barrierActiveIntervals ha i l.1 l.2.val (M l.1) (b l.1), |
| p∈barrierLinePoint a l.1 l.2.val '' Icc st.1 st.2} |
| |
| theorem sampledBarriers_supported {a m : ℕ} (ha : 0<a) (i : Fin m) (N : ℝ) |
| (M : ∀j,Finset (FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j))) |
| (b : ∀j,FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j) → Bool) : |
| SupportedBarriers a (fun l : BarrierLineIndex a N => l.1) (fun l => l.2.val) |
| (sampledBarriers ha i N M b) := by |
| rintro p ⟨l,st,hst,t,ht,rfl⟩ |
| exact ⟨l,cutForm_barrierLinePoint a l.1 l.2.val t⟩ |
| |
| noncomputable def sampledPolygonPartition {a m : ℕ} (ha : 0<a) (i : Fin m) |
| {N : ℝ} (hN : 0<N) |
| (M : ∀j,Finset (FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j))) |
| (b : ∀j,FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j) → Bool) : |
| FinitePolygonPartition a := by |
| letI := barrierLineIndexFintype a hN |
| exact finiteBarrierPartition (sampledBarriers_supported ha i N M b) |
| |
| theorem barrierLinePoint_continuous (a : ℕ) (j : Fin 4) (c : CutRing) : |
| Continuous (barrierLinePoint a j c) := by |
| change Continuous (fun t => barrierLinePoint a j c t) |
| fin_cases j <;> simp only [barrierLinePoint] <;> fun_prop |
| |
| theorem sampledBarriers_closed {a m : ℕ} (ha : 0<a) (i : Fin m) {N : ℝ} (hN : 0<N) |
| (M : ∀j,Finset (FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j))) |
| (b : ∀j,FlagSite a m (commonVertexDenominator a) (barrierFlagDirection ha j) → Bool) : |
| IsClosed (sampledBarriers ha i N M b) := by |
| let := barrierLineIndexFintype a hN |
| have he : sampledBarriers ha i N M b=⋃l : BarrierLineIndex a N, |
| ⋃st∈barrierActiveIntervals ha i l.1 l.2.val (M l.1) (b l.1), |
| barrierLinePoint a l.1 l.2.val '' Icc st.1 st.2 := by |
| ext p; simp [sampledBarriers] |
| rw [he] |
| apply isClosed_iUnion_of_finite |
| intro l |
| apply isClosed_biUnion_finset |
| intro st hst |
| exact (isCompact_Icc.image (barrierLinePoint_continuous a l.1 l.2.val)).isClosed |
| |
| end BarrierAlgorithm |
| |
| end SimpleAmenable |
| end |
| end |
| |
| end OAI |
| |
