Digit coding of surviving branch-tree points
DefinitionBianchiIX_Statistics_TreeCodingbianchi-ix-era-statisticsdynamical-systems
Let be an inverse-branch tree with open root . For every finite positive-digit word and digit , let be open and let be continuous and injective on . For fixed , assume the images are pairwise disjoint. Define
Here denotes appending the digit to .
Let be the surviving set. For , denote its unique length- cell word by and define by . Let and , with the empty composition the identity. The code is
For a Borel measure on , write for its pullback to the measurable subtype by the inclusion into .
The finite words and their next digits are defined by choice from the corresponding existence proofs. The existence proofs and the word length and cell membership properties needed by the digit definition are included.
Definition code
import Definitions.Def_BianchiIX_Statistics_GaussCoding
import Definitions.Def_BianchiIX_Statistics_StoppedMass
import Definitions.Def_BianchiIX_Statistics_BranchTree
import Mathlib.Analysis.Calculus.Deriv.Inv
import Mathlib.Analysis.Calculus.Deriv.Add
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Data.List.Induction
import Mathlib.Tactic.FieldSimp
import Mathlib.Tactic.Linarith
import Mathlib.Tactic.Ring
import Mathlib.Data.PNat.Basic
import Mathlib.MeasureTheory.Constructions.BorelSpace.Metrizable
import Mathlib.Data.Rat.Floor
import Mathlib.NumberTheory.Real.Irrational
import Mathlib.Order.OrderIsoNat
import Mathlib.Analysis.SpecialFunctions.Log.Deriv
import Mathlib.MeasureTheory.Group.MeasurableEquiv
import Mathlib.MeasureTheory.Measure.Regular
import Mathlib.MeasureTheory.Function.JacobianOneDim
section
open Set MeasureTheory
open BianchiIX
open BianchiIX.InverseBranchTree
variable (T : InverseBranchTree)
@[simp] private theorem BianchiIX.InverseBranchTree.terminal_nil : T.terminal [] = T.root := by
simp [terminal, List.reverseRecOn]
end
section
open Set MeasureTheory
open BianchiIX
open BianchiIX.InverseBranchTree
variable (T : InverseBranchTree)
@[simp] private theorem BianchiIX.InverseBranchTree.terminal_append (w : List ℕ+) (a : ℕ+) :
T.terminal (w ++ [a]) = T.domain w a ∩ T.branch w a ⁻¹' T.terminal w := by
simp [terminal, List.reverseRecOn]
end
section
open Set MeasureTheory
open BianchiIX
open BianchiIX.InverseBranchTree
variable (T : InverseBranchTree)
@[simp] private theorem BianchiIX.InverseBranchTree.toRoot_nil : T.toRoot [] = id := by
simp [toRoot, List.reverseRecOn]
end
section
open Set MeasureTheory
open BianchiIX
open BianchiIX.InverseBranchTree
variable (T : InverseBranchTree)
@[simp] private theorem BianchiIX.InverseBranchTree.toRoot_append (w : List ℕ+) (a : ℕ+) :
T.toRoot (w ++ [a]) = T.toRoot w ∘ T.branch w a := by
simp [toRoot, List.reverseRecOn]
end
section
open Set MeasureTheory
open BianchiIX
open BianchiIX.InverseBranchTree
variable (T : InverseBranchTree)
private theorem BianchiIX.InverseBranchTree.toRoot_injective (w : List ℕ+) : InjOn (T.toRoot w) (T.terminal w) := by
induction w using List.reverseRecOn with
| nil => simp
| append_singleton w a ih =>
rw [toRoot_append, terminal_append]
intro x hx y hy hxy
exact T.branch_injective w a hx.1 hy.1 (ih hx.2 hy.2 hxy)
end
section
open Set MeasureTheory
open BianchiIX
open BianchiIX.InverseBranchTree
variable (T : InverseBranchTree)
private theorem BianchiIX.InverseBranchTree.cell_append (w : List ℕ+) (a : ℕ+) :
T.cell (w ++ [a]) = T.toRoot w ''
(T.terminal w ∩ T.branch w a '' T.domain w a) := by
ext x
simp only [cell, toRoot_append, terminal_append, mem_image, mem_inter_iff,
mem_preimage, Function.comp_apply]
constructor
· rintro ⟨y, ⟨hy, hK⟩, rfl⟩
exact ⟨T.branch w a y, ⟨hK, y, hy, rfl⟩, rfl⟩
· rintro ⟨_, ⟨hK, y, hy, rfl⟩, rfl⟩
exact ⟨y, ⟨hy, hK⟩, rfl⟩
end
section
open Set MeasureTheory
open BianchiIX
open BianchiIX.InverseBranchTree
variable (T : InverseBranchTree)
private theorem BianchiIX.InverseBranchTree.cell_child_subset (w : List ℕ+) (a : ℕ+) : T.cell (w ++ [a]) ⊆ T.cell w := by
rw [cell_append]
exact image_mono inter_subset_left
end
section
open Set MeasureTheory
open BianchiIX
open BianchiIX.InverseBranchTree
variable (T : InverseBranchTree)
private theorem BianchiIX.InverseBranchTree.cell_siblings_disjoint (w : List ℕ+) :
Pairwise (fun a b => Disjoint (T.cell (w ++ [a])) (T.cell (w ++ [b]))) := by
intro a b hab
rw [T.cell_append, T.cell_append, Set.disjoint_left]
rintro x ⟨u, ⟨hu, ha⟩, hux⟩ ⟨v, ⟨hv, hb⟩, hvx⟩
have huv := T.toRoot_injective w hu hv (hux.trans hvx.symm)
exact Set.disjoint_left.mp (T.branch_disjoint w hab) ha (huv ▸ hb)
end
section
open Set MeasureTheory
open BianchiIX
open BianchiIX.InverseBranchTree
variable (T : InverseBranchTree)
private theorem BianchiIX.InverseBranchTree.cell_unique {v w : List ℕ+} (hlen : v.length = w.length)
{x : ℝ} (hv : x ∈ T.cell v) (hw : x ∈ T.cell w) : v = w := by
induction v using List.reverseRecOn generalizing w with
| nil =>
have : w = [] := List.length_eq_zero_iff.mp hlen.symm
exact this.symm
| append_singleton v a ih =>
induction w using List.reverseRecOn with
| nil => simp at hlen
| append_singleton w b _ =>
have hvw : v = w := ih (by simpa using hlen)
(T.cell_child_subset v a hv) (T.cell_child_subset w b hw)
subst w
have hab : a = b := by
by_contra h
exact Set.disjoint_left.mp (T.cell_siblings_disjoint v h) hv hw
exact congrArg (fun c => v ++ [c]) hab
end
section
open Set MeasureTheory
open BianchiIX
open BianchiIX.InverseBranchTree
variable (T : InverseBranchTree)
private theorem BianchiIX.InverseBranchTree.mem_level {n : ℕ} {x : ℝ} :
x ∈ T.level n ↔ ∃ w : List ℕ+, w.length = n ∧ x ∈ T.cell w := by
simp [level]
end
/-! Measurable symbolic coding of the surviving points of an actual inverse-branch tree. -/
open Set MeasureTheory
open scoped NNReal ENNReal
namespace BianchiIX
namespace InverseBranchTree
variable (T : InverseBranchTree)
def survivors : Set ℝ := survivingSet T.level
private theorem exists_word (x : T.survivors) (n : ℕ) :
∃ w : List ℕ+, w.length = n ∧ x.val ∈ T.cell w :=
T.mem_level.mp (mem_iInter.mp x.property n)
noncomputable def word (x : T.survivors) (n : ℕ) : List ℕ+ :=
(T.exists_word x n).choose
theorem word_length (x : T.survivors) (n : ℕ) : (T.word x n).length = n :=
(T.exists_word x n).choose_spec.1
theorem mem_word_cell (x : T.survivors) (n : ℕ) : x.val ∈ T.cell (T.word x n) :=
(T.exists_word x n).choose_spec.2
private theorem exists_next_digit (x : T.survivors) (n : ℕ) :
∃ a : ℕ+, T.word x (n + 1) = T.word x n ++ [a] := by
have hl := T.word_length x (n + 1)
have hx := T.mem_word_cell x (n + 1)
generalize T.word x (n + 1) = w at hl hx ⊢
induction w using List.reverseRecOn with
| nil => simp at hl
| append_singleton w a _ =>
have hw : w = T.word x n := T.cell_unique (by simpa [T.word_length] using hl)
(T.cell_child_subset w a hx) (T.mem_word_cell x n)
exact ⟨a, congrArg (fun v => v ++ [a]) hw⟩
noncomputable def digits (x : T.survivors) (n : ℕ) : ℕ+ :=
(T.exists_next_digit x n).choose
noncomputable def code (x : T.survivors) : ℝ := gaussCode (T.digits x)
end InverseBranchTree
end BianchiIX
Source