| import OAI.GroupTheory.Thompson.BasicIntervalNesting |
| import Mathlib.Data.Finset.Preimage |
| import Mathlib.Topology.Order.DenselyOrdered |
| import Mathlib.Topology.Instances.Real.Lemmas |
|
|
| namespace OAI |
|
|
| /-! |
| |
|
|
| Closed cells cover the unit interval; their open interiors are disjoint. |
| Restriction is the actual inverse image of the cell set under affine insertion. |
| -/ |
|
|
| noncomputable section |
|
|
| namespace ThompsonNonamenability |
|
|
| open Set |
|
|
| structure BasicPartition where |
| cells : Finset BasicInterval |
| cover : ∀ x ∈ Set.Icc (0 : ℝ) 1, ∃ I ∈ cells, x ∈ I.carrier |
| disjoint : (cells : Set BasicInterval).Pairwise |
| (fun I J => Disjoint I.interior J.interior) |
|
|
| namespace BasicPartition |
|
|
| @[ext] |
| theorem ext {T U : BasicPartition} (h : T.cells = U.cells) : T = U := by |
| cases T |
| cases U |
| cases h |
| rfl |
|
|
| def cellCount (T : BasicPartition) : ℕ := T.cells.card |
|
|
| /-- The interval is exactly covered by partition cells contained in it. -/ |
| def Respects (T : BasicPartition) (I : BasicInterval) : Prop := |
| ∀ x ∈ I.carrier, ∃ K ∈ T.cells, K.Contained I ∧ x ∈ K.carrier |
|
|
| theorem cellCount_pos (T : BasicPartition) : 0 < T.cellCount := by |
| obtain ⟨I, hI, _⟩ := T.cover 0 ⟨le_rfl, zero_le_one⟩ |
| exact Finset.card_pos.mpr ⟨I, hI⟩ |
|
|
| theorem respects_of_mem (T : BasicPartition) {I : BasicInterval} |
| (hI : I ∈ T.cells) : T.Respects I := by |
| intro x hx |
| exact ⟨I, hI, I.contained_refl, hx⟩ |
|
|
| private theorem interiors_overlap_of_mem_interior_mem_carrier |
| {I J : BasicInterval} {x : ℝ} (hxI : x ∈ I.interior) |
| (hxJ : x ∈ J.carrier) : (I.interior ∩ J.interior).Nonempty := by |
| have h : max I.left J.left < min I.right J.right := by |
| apply lt_min |
| · exact max_lt I.left_lt_right (lt_of_le_of_lt hxJ.1 hxI.2) |
| · exact max_lt (lt_of_lt_of_le hxI.1 hxJ.2) J.left_lt_right |
| obtain ⟨y, hy₁, hy₂⟩ := exists_between h |
| exact ⟨y, ⟨lt_of_le_of_lt (le_max_left _ _) hy₁, |
| lt_of_lt_of_le hy₂ (min_le_left _ _)⟩, |
| ⟨lt_of_le_of_lt (le_max_right _ _) hy₁, |
| lt_of_lt_of_le hy₂ (min_le_right _ _)⟩⟩ |
|
|
| /-- At an interior point, even membership in another closed cell forces equality. -/ |
| theorem eq_of_mem_interior_mem_carrier (T : BasicPartition) |
| {I J : BasicInterval} (hI : I ∈ T.cells) (hJ : J ∈ T.cells) |
| {x : ℝ} (hxI : x ∈ I.interior) (hxJ : x ∈ J.carrier) : I = J := by |
| by_contra hne |
| obtain ⟨y, hyI, hyJ⟩ := interiors_overlap_of_mem_interior_mem_carrier hxI hxJ |
| exact Set.disjoint_left.mp (T.disjoint hI hJ hne) hyI hyJ |
|
|
| /-- Equivalent geometric crossing condition, including the endpoint argument. -/ |
| theorem respects_iff (T : BasicPartition) (I : BasicInterval) : |
| T.Respects I ↔ ∀ K ∈ T.cells, |
| (K.interior ∩ I.interior).Nonempty → K.Contained I := by |
| constructor |
| · intro h K hK ⟨x, hxK, hxI⟩ |
| obtain ⟨L, hL, hLI, hxL⟩ := h x ⟨hxI.1.le, hxI.2.le⟩ |
| exact (T.eq_of_mem_interior_mem_carrier hK hL hxK hxL).symm ▸ hLI |
| · intro h |
| classical |
| let contained := T.cells.filter (fun K => K.Contained I) |
| let covered : Set ℝ := ⋃ K ∈ contained, K.carrier |
| have hclosed : IsClosed covered := by |
| apply isClosed_biUnion_finset |
| intro K hK |
| exact isClosed_Icc |
| have hinterior : I.interior ⊆ covered := by |
| intro x hxI |
| have hxunit : x ∈ Set.Icc (0 : ℝ) 1 := |
| I.carrier_subset_unit ⟨hxI.1.le, hxI.2.le⟩ |
| obtain ⟨K, hK, hxK⟩ := T.cover x hxunit |
| have hmeet : (K.interior ∩ I.interior).Nonempty := by |
| obtain ⟨y, hyI, hyK⟩ := |
| interiors_overlap_of_mem_interior_mem_carrier hxI hxK |
| exact ⟨y, hyK, hyI⟩ |
| have hKI := h K hK hmeet |
| exact Set.mem_iUnion₂.mpr ⟨K, Finset.mem_filter.mpr ⟨hK, hKI⟩, hxK⟩ |
| have hcarrier : I.carrier ⊆ covered := by |
| have hc := closure_minimal hinterior hclosed |
| simpa only [BasicInterval.interior, BasicInterval.carrier, |
| closure_Ioo I.left_lt_right.ne] using hc |
| intro x hx |
| obtain ⟨K, hK, hxK⟩ := Set.mem_iUnion₂.mp (hcarrier hx) |
| exact ⟨K, (Finset.mem_filter.mp hK).1, (Finset.mem_filter.mp hK).2, hxK⟩ |
|
|
| /-- A sufficiently fine actual partition respects the specified basic interval. -/ |
| theorem respects_of_mesh_lt (T : BasicPartition) (I : BasicInterval) |
| (hmesh : ∀ K ∈ T.cells, K.length < I.length) : T.Respects I := by |
| apply (T.respects_iff I).mpr |
| intro K hK hmeet |
| rcases BasicInterval.overlap_interior_nested hmeet with hKI | hIK |
| · exact hKI |
| · have hlen : I.length ≤ K.length := by |
| rw [I.length_eq_right_sub_left, K.length_eq_right_sub_left] |
| exact sub_le_sub hIK.2 hIK.1 |
| exact False.elim (not_lt_of_ge hlen (hmesh K hK)) |
|
|
| /-- Affinely normalized cells. Membership is exactly membership after insertion. -/ |
| def restrictCells (T : BasicPartition) (I : BasicInterval) : Finset BasicInterval := |
| T.cells.preimage I.comp I.comp_left_injective.injOn |
|
|
| @[simp] |
| theorem mem_restrictCells (T : BasicPartition) (I J : BasicInterval) : |
| J ∈ T.restrictCells I ↔ I.comp J ∈ T.cells := |
| Finset.mem_preimage |
|
|
| /-- The genuine partition obtained by restriction and affine normalization. -/ |
| def restrict (T : BasicPartition) (I : BasicInterval) (h : T.Respects I) : |
| BasicPartition where |
| cells := T.restrictCells I |
| cover := by |
| intro x hx |
| have hchart : I.chart x ∈ I.carrier := |
| (I.chart_mem_self_carrier_iff x).mpr hx |
| obtain ⟨K, hK, hKI, hxK⟩ := h (I.chart x) hchart |
| obtain ⟨J, hJ⟩ := BasicInterval.contained_iff_exists_comp.mp hKI |
| refine ⟨J, (T.mem_restrictCells I J).mpr (hJ.symm ▸ hK), ?_⟩ |
| apply (I.chart_mem_carrier_iff J x).mp |
| simpa only [hJ] using hxK |
| disjoint := by |
| intro J hJ K hK hne |
| apply Set.disjoint_left.mpr |
| intro x hxJ hxK |
| have hJK : I.comp J ≠ I.comp K := fun heq => hne (I.comp_left_injective heq) |
| exact Set.disjoint_left.mp |
| (T.disjoint ((T.mem_restrictCells I J).mp hJ) |
| ((T.mem_restrictCells I K).mp hK) hJK) |
| ((I.chart_mem_interior_iff J x).mpr hxJ) |
| ((I.chart_mem_interior_iff K x).mpr hxK) |
|
|
| @[simp] |
| theorem mem_restrict_cells (T : BasicPartition) (I : BasicInterval) |
| (h : T.Respects I) (J : BasicInterval) : |
| J ∈ (T.restrict I h).cells ↔ I.comp J ∈ T.cells := |
| T.mem_restrictCells I J |
|
|
| theorem restrict_proof_irrel (T : BasicPartition) (I : BasicInterval) |
| (h h' : T.Respects I) : T.restrict I h = T.restrict I h' := rfl |
|
|
| open Classical in |
| theorem restrict_cellCount_eq_filter_card (T : BasicPartition) (I : BasicInterval) |
| (h : T.Respects I) : |
| (T.restrict I h).cellCount = (T.cells.filter (fun K => K.Contained I)).card := by |
| classical |
| change (T.cells.preimage I.comp I.comp_left_injective.injOn).card = _ |
| rw [Finset.card_preimage] |
| congr 1 |
| ext K |
| simp only [Finset.mem_filter, Set.mem_range, |
| ← BasicInterval.contained_iff_exists_comp] |
|
|
| theorem restrict_cellCount_lt (T : BasicPartition) (I : BasicInterval) |
| (h : T.Respects I) (hI : I.Internal) : |
| (T.restrict I h).cellCount < T.cellCount := by |
| classical |
| rw [T.restrict_cellCount_eq_filter_card I h] |
| obtain ⟨K, hK, hxK⟩ := T.cover 0 ⟨le_rfl, zero_le_one⟩ |
| have hnot : ¬K.Contained I := by |
| intro hKI |
| have hle : I.left ≤ 0 := le_trans hKI.1 hxK.1 |
| exact (not_le_of_gt hI.1) hle |
| apply Finset.card_lt_card |
| apply Finset.ssubset_iff_subset_ne.mpr |
| refine ⟨Finset.filter_subset _ _, ?_⟩ |
| intro heq |
| have hf : K ∈ T.cells.filter (fun K => K.Contained I) := heq.symm ▸ hK |
| exact hnot (Finset.mem_filter.mp hf).2 |
|
|
| theorem restrict_respects (T : BasicPartition) (I J : BasicInterval) |
| (hI : T.Respects I) (hIJ : T.Respects (I.comp J)) : |
| (T.restrict I hI).Respects J := by |
| intro x hx |
| have hchart : I.chart x ∈ (I.comp J).carrier := |
| (I.chart_mem_carrier_iff J x).mpr hx |
| obtain ⟨K, hK, hKIJ, hxK⟩ := hIJ (I.chart x) hchart |
| have hKI : K.Contained I := |
| ⟨le_trans (I.comp_contained J).1 hKIJ.1, |
| le_trans hKIJ.2 (I.comp_contained J).2⟩ |
| obtain ⟨L, hL⟩ := BasicInterval.contained_iff_exists_comp.mp hKI |
| refine ⟨L, (T.mem_restrict_cells I hI L).mpr (hL.symm ▸ hK), ?_, ?_⟩ |
| · apply (I.comp_contained_iff L J).mp |
| simpa only [hL] using hKIJ |
| · apply (I.chart_mem_carrier_iff L x).mp |
| simpa only [hL] using hxK |
|
|
| theorem restrict_restrict (T : BasicPartition) (I J : BasicInterval) |
| (hI : T.Respects I) (hIJ : T.Respects (I.comp J)) : |
| (T.restrict I hI).restrict J (T.restrict_respects I J hI hIJ) = |
| T.restrict (I.comp J) hIJ := by |
| apply BasicPartition.ext |
| ext K |
| simp only [mem_restrict_cells, BasicInterval.comp_assoc] |
|
|
| end BasicPartition |
|
|
| end ThompsonNonamenability |
|
|
| end |
|
|
| end OAI |
|
|
