| import OAI.GroupTheory.Thompson.Model |
| import Mathlib.Basic.Real.Basic |
| import Mathlib.Data.Finset.Basic |
| import Mathlib.Tactic.FieldSimp |
| import Mathlib.Tactic.NormNum |
| import Mathlib.Tactic.Ring |
|
|
| namespace OAI |
|
|
| /-! |
| # Real dyadic arithmetic |
|
|
| Dyadic numbers are represented by an integer numerator and a nonnegative |
| power of two denominator. In particular, the grid denominator below is an |
| actual common denominator, not an assumption about the input finite set. |
| -/ |
|
|
| universe uα |
|
|
| namespace ThompsonNonamenability |
|
|
| theorem isDyadic_div_pow (k : ℤ) (n : ℕ) : |
| IsDyadic ((k : ℝ) / (2 : ℝ) ^ n) := |
| ⟨k, n, rfl⟩ |
|
|
| theorem isDyadic_intCast (k : ℤ) : IsDyadic (k : ℝ) := by |
| exact ⟨k, 0, by simp⟩ |
|
|
| theorem isDyadic_natCast (k : ℕ) : IsDyadic (k : ℝ) := by |
| simpa only [Int.cast_natCast] using isDyadic_intCast (k : ℤ) |
|
|
| @[simp] theorem isDyadic_zero : IsDyadic (0 : ℝ) := by |
| simpa using isDyadic_intCast 0 |
|
|
| @[simp] theorem isDyadic_one : IsDyadic (1 : ℝ) := by |
| simpa using isDyadic_intCast 1 |
|
|
| theorem IsDyadic.neg {x : ℝ} (hx : IsDyadic x) : IsDyadic (-x) := by |
| rcases hx with ⟨k, n, rfl⟩ |
| exact ⟨-k, n, by simp only [Int.cast_neg, neg_div]⟩ |
|
|
| theorem IsDyadic.mul {x y : ℝ} (hx : IsDyadic x) (hy : IsDyadic y) : |
| IsDyadic (x * y) := by |
| rcases hx with ⟨k, n, rfl⟩ |
| rcases hy with ⟨l, m, rfl⟩ |
| refine ⟨k * l, n + m, ?_⟩ |
| simp only [Int.cast_mul, pow_add, div_mul_div_comm] |
|
|
| theorem IsDyadic.add {x y : ℝ} (hx : IsDyadic x) (hy : IsDyadic y) : |
| IsDyadic (x + y) := by |
| rcases hx with ⟨k, n, rfl⟩ |
| rcases hy with ⟨l, m, rfl⟩ |
| refine ⟨k * 2 ^ m + l * 2 ^ n, n + m, ?_⟩ |
| push_cast |
| rw [pow_add] |
| field_simp |
|
|
| theorem IsDyadic.sub {x y : ℝ} (hx : IsDyadic x) (hy : IsDyadic y) : |
| IsDyadic (x - y) := by |
| simpa only [sub_eq_add_neg] using hx.add hy.neg |
|
|
| theorem isDyadic_zpow (q : ℤ) : IsDyadic ((2 : ℝ) ^ q) := by |
| cases q with |
| | ofNat n => |
| simpa only [Int.ofNat_eq_natCast, zpow_natCast, Int.cast_pow, Int.cast_ofNat] using |
| isDyadic_intCast ((2 : ℤ) ^ n) |
| | negSucc n => |
| exact ⟨1, n + 1, by simp [zpow_negSucc, one_div]⟩ |
|
|
| theorem IsDyadic.mul_zpow {x : ℝ} (hx : IsDyadic x) (q : ℤ) : |
| IsDyadic (x * (2 : ℝ) ^ q) := |
| hx.mul (isDyadic_zpow q) |
|
|
| theorem IsDyadic.zpow_mul {x : ℝ} (hx : IsDyadic x) (q : ℤ) : |
| IsDyadic ((2 : ℝ) ^ q * x) := |
| (isDyadic_zpow q).mul hx |
|
|
| theorem IsDyadic.div_zpow {x : ℝ} (hx : IsDyadic x) (q : ℤ) : |
| IsDyadic (x / (2 : ℝ) ^ q) := by |
| simpa only [div_eq_mul_inv, zpow_neg] using hx.mul_zpow (-q) |
|
|
| / |
| theorem dyadic_raise_denominator {x : ℝ} {n : ℕ} |
| (hx : ∃ k : ℤ, x = (k : ℝ) / (2 : ℝ) ^ n) (m : ℕ) : |
| ∃ k : ℤ, x = (k : ℝ) / (2 : ℝ) ^ (n + m) := by |
| rcases hx with ⟨k, rfl⟩ |
| refine ⟨k * 2 ^ m, ?_⟩ |
| push_cast |
| rw [pow_add] |
| field_simp |
|
|
| theorem dyadic_denominator_mono {x : ℝ} {n N : ℕ} |
| (hx : ∃ k : ℤ, x = (k : ℝ) / (2 : ℝ) ^ n) (hn : n ≤ N) : |
| ∃ k : ℤ, x = (k : ℝ) / (2 : ℝ) ^ N := by |
| obtain ⟨m, rfl⟩ := Nat.exists_eq_add_of_le hn |
| exact dyadic_raise_denominator hx m |
|
|
| / |
| theorem dyadic_common_denominator_finset {α : Type uα} (s : Finset α) (f : α → ℝ) |
| (hs : ∀ a ∈ s, IsDyadic (f a)) : |
| ∃ n : ℕ, ∀ a ∈ s, ∃ k : ℤ, f a = (k : ℝ) / (2 : ℝ) ^ n := by |
| classical |
| induction s using Finset.induction_on with |
| | empty => |
| exact ⟨0, by simp⟩ |
| | @insert a s ha ih => |
| obtain ⟨k, n, hn⟩ := hs a (Finset.mem_insert_self a s) |
| obtain ⟨m, hm⟩ := ih (fun b hb => hs b (Finset.mem_insert_of_mem hb)) |
| refine ⟨n + m, ?_⟩ |
| intro b hb |
| rcases Finset.mem_insert.mp hb with rfl | hb |
| · exact dyadic_raise_denominator ⟨k, hn⟩ m |
| · simpa only [Nat.add_comm m n] using dyadic_raise_denominator (hm b hb) n |
|
|
| theorem dyadic_common_denominator (s : Finset ℝ) |
| (hs : ∀ x ∈ s, IsDyadic x) : |
| ∃ n : ℕ, ∀ x ∈ s, ∃ k : ℤ, x = (k : ℝ) / (2 : ℝ) ^ n := |
| dyadic_common_denominator_finset s id hs |
|
|
| / |
| theorem dyadic_nat_numerator {x : ℝ} {k : ℤ} {n : ℕ} |
| (hx : x = (k : ℝ) / (2 : ℝ) ^ n) (h0 : 0 ≤ x) (h1 : x ≤ 1) : |
| ∃ j : ℕ, j ≤ 2 ^ n ∧ x = (j : ℝ) / (2 : ℝ) ^ n := by |
| have hden : (0 : ℝ) < (2 : ℝ) ^ n := pow_pos (by norm_num) n |
| have hk0r : (0 : ℝ) ≤ (k : ℝ) := by |
| have hh := (le_div_iff₀ hden).1 (hx ▸ h0) |
| simpa only [zero_mul] using hh |
| have hk0 : (0 : ℤ) ≤ k := by exact_mod_cast hk0r |
| have hkr : (k : ℝ) ≤ (2 : ℝ) ^ n := (div_le_one hden).1 (hx ▸ h1) |
| have hcast : (k.toNat : ℝ) = (k : ℝ) := by |
| exact_mod_cast Int.toNat_of_nonneg hk0 |
| refine ⟨k.toNat, ?_, ?_⟩ |
| · have hj : (k.toNat : ℝ) ≤ (2 : ℝ) ^ n := by |
| simpa only [hcast] using hkr |
| exact_mod_cast hj |
| · simpa only [hcast] using hx |
|
|
| theorem IsDyadic.exists_nat_grid {x : ℝ} (hx : IsDyadic x) |
| (h0 : 0 ≤ x) (h1 : x ≤ 1) : |
| ∃ (n j : ℕ), j ≤ 2 ^ n ∧ x = (j : ℝ) / (2 : ℝ) ^ n := by |
| obtain ⟨k, n, hk⟩ := hx |
| obtain ⟨j, hj, hrepr⟩ := dyadic_nat_numerator hk h0 h1 |
| exact ⟨n, j, hj, hrepr⟩ |
|
|
| / |
| theorem dyadic_common_nat_grid {α : Type uα} (s : Finset α) (f : α → ℝ) |
| (hd : ∀ a ∈ s, IsDyadic (f a)) |
| (h0 : ∀ a ∈ s, 0 ≤ f a) (h1 : ∀ a ∈ s, f a ≤ 1) : |
| ∃ n : ℕ, ∀ a ∈ s, ∃ j : ℕ, j ≤ 2 ^ n ∧ f a = (j : ℝ) / (2 : ℝ) ^ n := by |
| obtain ⟨n, hn⟩ := dyadic_common_denominator_finset s f hd |
| refine ⟨n, ?_⟩ |
| intro a ha |
| obtain ⟨k, hk⟩ := hn a ha |
| exact dyadic_nat_numerator hk (h0 a ha) (h1 a ha) |
|
|
| end ThompsonNonamenability |
|
|
| end OAI |
|
|
