lean/OAI/GroupTheory/Thompson/BasicInterval.lean

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