| import OAI.GroupTheory.Thompson.Model |
| import Mathlib.Topology.Homeomorph.Lemmas |
| import Mathlib.Topology.Instances.Real.Lemmas |
| import Mathlib.Algebra.Group.Subgroup.Basic |
|
|
| namespace OAI |
|
|
| /-! |
| # Actual homeomorphisms of the real unit interval |
|
|
| The wrapper supplies the composition group explicitly. In particular, its |
| multiplication is function composition in the order `(h * g) x = h (g x)`. |
| Its carrier is equivalent to the actual interval homeomorphisms, without |
| quotients or an abstract group action. |
| -/ |
|
|
| namespace ThompsonNonamenability |
|
|
| @[simp] theorem coe_unitIntervalZero : (unitIntervalZero : ℝ) = 0 := rfl |
| @[simp] theorem coe_unitIntervalOne : (unitIntervalOne : ℝ) = 1 := rfl |
|
|
| namespace IntervalHomeomorph |
|
|
| @[ext] theorem ext {f g : IntervalHomeomorph} (h : ∀ x, f x = g x) : f = g := by |
| cases f with |
| | mk f => |
| cases g with |
| | mk g => |
| congr 1 |
| exact Homeomorph.ext h |
|
|
| def homeomorphEquiv : IntervalHomeomorph ≃ (UnitInterval ≃ₜ UnitInterval) where |
| toFun := toHomeomorph |
| invFun := IntervalHomeomorph.mk |
| left_inv f := by cases f; rfl |
| right_inv _ := rfl |
|
|
| @[simp] theorem homeomorphEquiv_apply (f : IntervalHomeomorph) : |
| homeomorphEquiv f = f.toHomeomorph := rfl |
|
|
| instance : Group IntervalHomeomorph where |
| one := ⟨Homeomorph.refl UnitInterval⟩ |
| mul f g := ⟨g.toHomeomorph.trans f.toHomeomorph⟩ |
| inv f := ⟨f.toHomeomorph.symm⟩ |
| mul_assoc _ _ _ := ext fun _ => rfl |
| one_mul _ := ext fun _ => rfl |
| mul_one _ := ext fun _ => rfl |
| inv_mul_cancel f := ext f.toHomeomorph.symm_apply_apply |
|
|
| @[simp] theorem one_apply (x : UnitInterval) : (1 : IntervalHomeomorph) x = x := rfl |
|
|
| @[simp] theorem mul_apply (h g : IntervalHomeomorph) (x : UnitInterval) : |
| (h * g) x = h (g x) := rfl |
|
|
| @[simp] theorem inv_apply_apply (f : IntervalHomeomorph) (x : UnitInterval) : |
| f⁻¹ (f x) = x := f.toHomeomorph.symm_apply_apply x |
|
|
| @[simp] theorem apply_inv_apply (f : IntervalHomeomorph) (x : UnitInterval) : |
| f (f⁻¹ x) = x := f.toHomeomorph.apply_symm_apply x |
|
|
| theorem injective (f : IntervalHomeomorph) : Function.Injective f := |
| f.toHomeomorph.injective |
|
|
| theorem surjective (f : IntervalHomeomorph) : Function.Surjective f := |
| f.toHomeomorph.surjective |
|
|
| theorem continuous (f : IntervalHomeomorph) : Continuous f := |
| f.toHomeomorph.continuous |
|
|
| theorem strictMono_inv {f : IntervalHomeomorph} (hf : StrictMono f) : |
| StrictMono (f⁻¹ : IntervalHomeomorph) := by |
| intro x y hxy |
| by_contra h |
| have hyx : f⁻¹ y ≤ f⁻¹ x := le_of_not_gt h |
| have h' := hf.monotone hyx |
| simp only [apply_inv_apply] at h' |
| exact (not_le_of_gt hxy) h' |
| |
| theorem map_zero {f : IntervalHomeomorph} (hf : StrictMono f) : |
| f unitIntervalZero = unitIntervalZero := by |
| apply Subtype.ext |
| apply le_antisymm |
| have hx : unitIntervalZero ≤ f⁻¹ unitIntervalZero := |
| (f⁻¹ unitIntervalZero).property.1 |
| have h := hf.monotone hx |
| simpa only [apply_inv_apply, Subtype.coe_le_coe] using h |
| exact (f unitIntervalZero).property.1 |
| |
| theorem map_one {f : IntervalHomeomorph} (hf : StrictMono f) : |
| f unitIntervalOne = unitIntervalOne := by |
| apply Subtype.ext |
| apply le_antisymm |
| exact (f unitIntervalOne).property.2 |
| have hx : f⁻¹ unitIntervalOne ≤ unitIntervalOne := |
| (f⁻¹ unitIntervalOne).property.2 |
| have h := hf.monotone hx |
| simpa only [apply_inv_apply, Subtype.coe_le_coe] using h |
| |
| def increasingSubgroup : Subgroup IntervalHomeomorph where |
| carrier := {f | StrictMono f} |
| one_mem' := fun _ _ h => h |
| mul_mem' hf hg := hf.comp hg |
| inv_mem' hf := strictMono_inv hf |
|
|
| end IntervalHomeomorph |
|
|
| end ThompsonNonamenability |
|
|
| end OAI |
|
|
