math / data /lean /OAI /GroupTheory /Thompson /BasicInterval.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
9.9 kB
import Mathlib.Basic.Real.Basic
import Mathlib.Tactic.FieldSimp
import Mathlib.Tactic.Linarith
import Mathlib.Tactic.NormNum
import Mathlib.Tactic.Positivity
import Mathlib.Tactic.Ring
namespace OAI
/-!
# Basic dyadic intervals
A cell records its actual depth and its index on that dyadic grid. Its
endpoints determine the record uniquely. Composition is the affine image of
one cell inside another; no formal interval identifications are assumed.
-/
noncomputable section
namespace ThompsonNonamenability
structure BasicInterval where
depth : β„•
index : Fin (2 ^ depth)
deriving DecidableEq
namespace BasicInterval
@[ext] theorem ext_depth_index {I J : BasicInterval}
(hd : I.depth = J.depth) (hi : I.index.val = J.index.val) : I = J := by
cases I with
| mk d i =>
cases J with
| mk e j =>
dsimp at hd hi
subst e
have hij : i = j := Fin.ext hi
subst j
rfl
def left (I : BasicInterval) : ℝ := (I.index.val : ℝ) / (2 : ℝ) ^ I.depth
def right (I : BasicInterval) : ℝ := ((I.index.val : ℝ) + 1) / (2 : ℝ) ^ I.depth
def length (I : BasicInterval) : ℝ := ((2 : ℝ) ^ I.depth)⁻¹
def carrier (I : BasicInterval) : Set ℝ := Set.Icc I.left I.right
def interior (I : BasicInterval) : Set ℝ := Set.Ioo I.left I.right
def Internal (I : BasicInterval) : Prop := 0 < I.left ∧ I.right < 1
def Before (I J : BasicInterval) : Prop := I.right < J.left
def Contained (K I : BasicInterval) : Prop := I.left ≀ K.left ∧ K.right ≀ I.right
def chart (I : BasicInterval) (x : ℝ) : ℝ :=
((I.index.val : ℝ) + x) / (2 : ℝ) ^ I.depth
theorem denominator_pos (I : BasicInterval) : 0 < (2 : ℝ) ^ I.depth :=
pow_pos (by norm_num) _
theorem denominator_ne_zero (I : BasicInterval) : (2 : ℝ) ^ I.depth β‰  0 :=
ne_of_gt I.denominator_pos
theorem length_pos (I : BasicInterval) : 0 < I.length :=
inv_pos.mpr I.denominator_pos
theorem length_eq_right_sub_left (I : BasicInterval) :
I.length = I.right - I.left := by
unfold length right left
ring
theorem left_nonneg (I : BasicInterval) : 0 ≀ I.left :=
div_nonneg (Nat.cast_nonneg _) (le_of_lt I.denominator_pos)
theorem right_le_one (I : BasicInterval) : I.right ≀ 1 := by
apply (div_le_one I.denominator_pos).2
exact_mod_cast Nat.succ_le_of_lt I.index.isLt
theorem left_lt_right (I : BasicInterval) : I.left < I.right := by
apply (div_lt_div_iff_of_pos_right I.denominator_pos).2
linarith
theorem carrier_subset_unit (I : BasicInterval) : I.carrier βŠ† Set.Icc (0 : ℝ) 1 := by
intro x hx
exact ⟨I.left_nonneg.trans hx.1, hx.2.trans I.right_le_one⟩
theorem interior_subset_carrier (I : BasicInterval) : I.interior βŠ† I.carrier := by
intro x hx
exact ⟨hx.1.le, hx.2.le⟩
theorem interior_nonempty (I : BasicInterval) : I.interior.Nonempty := by
exact ⟨(I.left + I.right) / 2, by
constructor <;> linarith [I.left_lt_right]⟩
theorem contained_refl (I : BasicInterval) : I.Contained I := ⟨le_rfl, le_rfl⟩
theorem Contained.trans {I J K : BasicInterval}
(hIJ : I.Contained J) (hJK : J.Contained K) : I.Contained K :=
⟨hJK.1.trans hIJ.1, hIJ.2.trans hJK.2⟩
theorem Contained.carrier_subset {I J : BasicInterval}
(h : I.Contained J) : I.carrier βŠ† J.carrier := by
intro x hx
exact ⟨h.1.trans hx.1, hx.2.trans h.2⟩
theorem Contained.interior_subset {I J : BasicInterval}
(h : I.Contained J) : I.interior βŠ† J.interior := by
intro x hx
exact ⟨h.1.trans_lt hx.1, hx.2.trans_le h.2⟩
theorem length_le_of_contained {I J : BasicInterval} (h : I.Contained J) :
I.length ≀ J.length := by
rw [length_eq_right_sub_left, length_eq_right_sub_left]
exact sub_le_sub h.2 h.1
@[simp] theorem chart_zero (I : BasicInterval) : I.chart 0 = I.left := by
simp [chart, left]
@[simp] theorem chart_one (I : BasicInterval) : I.chart 1 = I.right := rfl
theorem chart_eq_left_add_length_mul (I : BasicInterval) (x : ℝ) :
I.chart x = I.left + I.length * x := by
unfold chart left length
ring
theorem chart_strictMono (I : BasicInterval) : StrictMono I.chart := by
intro x y hxy
apply (div_lt_div_iff_of_pos_right I.denominator_pos).2
exact add_lt_add_right hxy _
theorem chart_injective (I : BasicInterval) : Function.Injective I.chart :=
I.chart_strictMono.injective
theorem chart_mem_self_carrier_iff (I : BasicInterval) (x : ℝ) :
I.chart x ∈ I.carrier ↔ x ∈ Set.Icc (0 : ℝ) 1 := by
change I.left ≀ I.chart x ∧ I.chart x ≀ I.right ↔ 0 ≀ x ∧ x ≀ 1
rw [← I.chart_zero, ← I.chart_one]
simp only [I.chart_strictMono.le_iff_le]
theorem chart_mem_self_interior_iff (I : BasicInterval) (x : ℝ) :
I.chart x ∈ I.interior ↔ x ∈ Set.Ioo (0 : ℝ) 1 := by
change I.left < I.chart x ∧ I.chart x < I.right ↔ 0 < x ∧ x < 1
rw [← I.chart_zero, ← I.chart_one]
simp only [I.chart_strictMono.lt_iff_lt]
theorem ext_endpoints {I J : BasicInterval}
(hl : I.left = J.left) (hr : I.right = J.right) : I = J := by
have hlen : I.length = J.length := by
rw [length_eq_right_sub_left, length_eq_right_sub_left, hl, hr]
have hp : (2 : ℝ) ^ I.depth = (2 : ℝ) ^ J.depth := inv_injective hlen
have hd : I.depth = J.depth :=
(pow_right_injβ‚€ (by norm_num : (0 : ℝ) < 2) (by norm_num : (2 : ℝ) β‰  1)).1 hp
apply ext_depth_index hd
have hdiv : (I.index.val : ℝ) / (2 : ℝ) ^ J.depth =
(J.index.val : ℝ) / (2 : ℝ) ^ J.depth := by
simpa only [left, hd] using hl
have hi : (I.index.val : ℝ) = (J.index.val : ℝ) :=
(div_left_inj' J.denominator_ne_zero).1 hdiv
exact_mod_cast hi
def root : BasicInterval := ⟨0, ⟨0, by norm_num⟩⟩
@[simp] theorem root_depth : root.depth = 0 := rfl
@[simp] theorem root_index : root.index.val = 0 := rfl
@[simp] theorem root_left : root.left = 0 := by norm_num [root, left]
@[simp] theorem root_right : root.right = 1 := by norm_num [root, right]
@[simp] theorem root_length : root.length = 1 := by norm_num [root, length]
@[simp] theorem root_chart (x : ℝ) : root.chart x = x := by simp [root, chart]
def comp (I J : BasicInterval) : BasicInterval where
depth := I.depth + J.depth
index := ⟨I.index.val * 2 ^ J.depth + J.index.val, by
have hI : I.index.val + 1 ≀ 2 ^ I.depth := Nat.succ_le_of_lt I.index.isLt
calc
I.index.val * 2 ^ J.depth + J.index.val <
I.index.val * 2 ^ J.depth + 2 ^ J.depth := Nat.add_lt_add_left J.index.isLt _
_ = (I.index.val + 1) * 2 ^ J.depth := by ring
_ ≀ 2 ^ I.depth * 2 ^ J.depth := Nat.mul_le_mul_right _ hI
_ = 2 ^ (I.depth + J.depth) := (pow_add _ _ _).symm⟩
@[simp] theorem comp_depth (I J : BasicInterval) : (I.comp J).depth = I.depth + J.depth := rfl
@[simp] theorem comp_index (I J : BasicInterval) :
(I.comp J).index.val = I.index.val * 2 ^ J.depth + J.index.val := rfl
theorem chart_comp (I J : BasicInterval) (x : ℝ) :
(I.comp J).chart x = I.chart (J.chart x) := by
simp only [chart, comp_depth, comp_index, Nat.cast_add, Nat.cast_mul,
Nat.cast_pow, Nat.cast_ofNat, pow_add]
field_simp
ring
theorem left_comp (I J : BasicInterval) : (I.comp J).left = I.chart J.left := by
rw [← chart_zero, chart_comp, chart_zero]
theorem right_comp (I J : BasicInterval) : (I.comp J).right = I.chart J.right := by
rw [← chart_one, chart_comp, chart_one]
theorem comp_assoc (I J K : BasicInterval) : (I.comp J).comp K = I.comp (J.comp K) := by
apply ext_depth_index
Β· simp only [comp_depth, Nat.add_assoc]
Β· simp only [comp_index, comp_depth, pow_add]
ring
@[simp] theorem comp_root (I : BasicInterval) : I.comp root = I := by
apply ext_depth_index <;> simp
@[simp] theorem root_comp (I : BasicInterval) : root.comp I = I := by
apply ext_depth_index <;> simp
theorem comp_left_injective (I : BasicInterval) : Function.Injective I.comp := by
intro J K h
have hd : J.depth = K.depth := Nat.add_left_cancel (congrArg depth h)
apply ext_depth_index hd
have hi := congrArg (fun C : BasicInterval => C.index.val) h
simp only [comp_index, hd] at hi
exact Nat.add_left_cancel hi
theorem comp_injective (I : BasicInterval) : Function.Injective I.comp :=
comp_left_injective I
theorem comp_contained (I J : BasicInterval) : (I.comp J).Contained I := by
constructor
Β· rw [left_comp, ← I.chart_zero]
exact I.chart_strictMono.monotone J.left_nonneg
Β· rw [right_comp, ← I.chart_one]
exact I.chart_strictMono.monotone J.right_le_one
theorem chart_mem_carrier_iff (I J : BasicInterval) (x : ℝ) :
I.chart x ∈ (I.comp J).carrier ↔ x ∈ J.carrier := by
simp only [carrier, Set.mem_Icc, left_comp, right_comp, I.chart_strictMono.le_iff_le]
theorem chart_mem_interior_iff (I J : BasicInterval) (x : ℝ) :
I.chart x ∈ (I.comp J).interior ↔ x ∈ J.interior := by
simp only [interior, Set.mem_Ioo, left_comp, right_comp, I.chart_strictMono.lt_iff_lt]
theorem comp_contained_iff (I J K : BasicInterval) :
(I.comp J).Contained (I.comp K) ↔ J.Contained K := by
simp only [Contained, left_comp, right_comp, I.chart_strictMono.le_iff_le]
theorem comp_internal_of_internal_right (I J : BasicInterval) (hJ : J.Internal) :
(I.comp J).Internal := by
constructor
Β· rw [left_comp]
have h := I.chart_strictMono hJ.1
rw [chart_zero] at h
exact I.left_nonneg.trans_lt h
Β· rw [right_comp]
have h := I.chart_strictMono hJ.2
rw [chart_one] at h
exact h.trans_le I.right_le_one
theorem comp_internal (I J : BasicInterval) (_hI : I.Internal) (hJ : J.Internal) :
(I.comp J).Internal := comp_internal_of_internal_right I J hJ
theorem comp_before_comp (I : BasicInterval) {J K : BasicInterval} (h : J.Before K) :
(I.comp J).Before (I.comp K) := by
change (I.comp J).right < (I.comp K).left
rw [right_comp, left_comp]
exact I.chart_strictMono h
end BasicInterval
end ThompsonNonamenability
end
end OAI