Exact era inverse trees, survivors and a common typical domain
DefinitionBianchiIX_EraCodingDataFor real variables , set
The shear components and wall rates are
These functions define the normalized vacuum Bianchi IX vector field . For , define
and .
For , put
For , set and
Write for the normalized vector field and for its constraint.
The normalized and projective state spaces are and with their finite-product norms. The maps act on these state spaces.
Define the core radius, angle, and clock factor by
For , write , , and . All quotients use the total convention .
The core state space is with coordinates . Define
For fixed put , , , and define
For real , put and define
Write , , and let be the maximal solution of with initial value at and domain . Put
Write , , and . Define
The entrance parametrization and radial exit factor are
For projective initial data , put
Coordinates of three-vectors are indexed by ; projective coordinates are indexed by .
For , put , , and
The infimum uses the total real-order convention. Write when is the least element of , every lies in with , the active wall is strictly above one for , and
All vector and operator norms below use the finite-product supremum norm. For real variables , set
The shear components and wall rates are
These functions define the normalized vacuum Bianchi IX vector field . For , define
and .
For , put
For , set and
Write for the normalized vector field and for its constraint.
The normalized and projective state spaces are and with their finite-product norms. The maps act on these state spaces.
The projective vector field in normalized time is
Write , , and let be the maximal solution of with initial value at and domain . Put
Put , , , , and .
Define
For a normalized trajectory write
For , set , , and
Let mean that this infimum is a least element, the full interval lies in the maximal domain with positive , the growing wall is below one before the endpoint, and its normalized-time derivative is strictly positive at the endpoint. The infimum has its total real-order meaning.
Write , , , and . The physical connection coordinates are
Below denotes the canonical core return time from and its radial and wall coordinates. Let , , , and . A cone direction at has , , . For a map with positive output walls, its positive cone property means has positive radial component and for . For real variables , set
The shear components and wall rates are
These functions define the normalized vacuum Bianchi IX vector field . For , define
and .
For , put
For , set and
Write for the normalized vector field and for its constraint.
The normalized and projective state spaces are and with their finite-product norms. The maps act on these state spaces.
The projective vector field in normalized time is
Write , , and let be the maximal solution of with initial value at and domain . Put
For , define
For any real height , put
The infimum uses the total real-order convention. Let mean that is the least element of , and, writing , that
All vector and operator norms use the finite-product supremum norms.
For , put ,
Let mean that this infimum is a least element, the full interval lies in the maximal domain with , the active wall is below one before the endpoint, and its normalized-time derivative is strictly positive throughout the interval. The infimum has its total real-order meaning.
For define the cyclic chart by
Its normalized symmetry is
Put and
Write and .
In the era formulas below, denotes the core return map and its composition with reflection. For use the natural height and define , , and . The complete era maps are
For a graph write , , , , . Let denote Lean's total choice inverse . For , , define
Write for the Gauss inverse branch. The retained phase set is .
A curve is admissible at budget if, for every , , , both functions are at , and , . For an arbitrary graph, define its successor walls by
where is the canonical amplitude extension after composing with the choice inverse of , with slope or . The one-step property at consists of the following. Put , , . One has . For every , is strictly decreasing on , and for ,
The successor is admissible at budget and, with , satisfies , , . The retained branch intervals are pairwise disjoint and . For and , define
where the outer power is the real power.
For a state let . Its selected domain is defined by
For positive-digit words define to be the whole state space and . The survivor domain is . For , choose its compatible words and digits with . Let and let be the continued-fraction code. The common typical domain is
where is the set of points with all Gauss cylinder frequencies. For a curve of budget , set . The curve family begins at and uses its successor for retained digits; other descendants use the constant pair . At a word of length , its inverse branch for digit is , with , on if , and has empty domain otherwise. These branches and supplied one-step properties define an inverse tree. Its realization states that each branch edge agrees with and that its image is exactly the selected domain on that curve.
Finite prefix states are the ordered compositions of the selected forward maps. Finite prefix domains impose selection at each step. The survivor digits are chosen from the unique compatible prefix words. The code, phase sequence, common typical domain and its pullback to each admissible curve use these same choices.
import Definitions.Def_BianchiIX_Statistics_GaussInverse
import Definitions.Def_BianchiIX_Analysis_AmplitudeSequence
import Definitions.Def_BianchiIX_EraReturnData
import Definitions.Def_BianchiIX_Statistics_BranchTree
import Mathlib.Analysis.Calculus.ParametricIntervalIntegral
import Mathlib.Analysis.Calculus.ContDiff.Operations
import Mathlib.Topology.Order.Compact
import Mathlib.MeasureTheory.Integral.DominatedConvergence
import Mathlib.Data.Fin.VecNotation
import Mathlib.Analysis.Calculus.Deriv.Pi
import Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus
import Mathlib.Analysis.Calculus.ImplicitContDiff
import Mathlib.Tactic.NormNum
import Mathlib.Analysis.Calculus.Deriv.Pow
import Mathlib.Analysis.Calculus.Deriv.Mul
import Mathlib.Analysis.Calculus.Deriv.Add
import Mathlib.Analysis.Real.Sqrt
import Mathlib.Tactic.Linarith
import Mathlib.Tactic.Ring
import Mathlib.Analysis.Calculus.Deriv.Prod
import Mathlib.Analysis.Calculus.MeanValue
import Mathlib.Tactic.FinCases
import Mathlib.Tactic.FunProp
import Mathlib.Analysis.SpecialFunctions.Pow.Deriv
import Mathlib.Tactic.FieldSimp
import Mathlib.Analysis.SpecialFunctions.Integrals.Basic
import Mathlib.Analysis.ODE.ExistUnique
import Mathlib.Analysis.Calculus.FDeriv.Partial
import Mathlib.Topology.Order.IntermediateValue
import Mathlib.Topology.Instances.Real.Lemmas
import Mathlib.Analysis.Calculus.FDeriv.Symmetric
import Mathlib.Analysis.Calculus.Deriv.Inv
import Mathlib.Tactic.LinearCombination
import Mathlib.Analysis.SpecialFunctions.Arcosh
import Mathlib.Analysis.Calculus.InverseFunctionTheorem.Deriv
import Mathlib.Analysis.Calculus.Deriv.MeanValue
import Mathlib.Tactic.Module
import Mathlib.Analysis.SpecialFunctions.Arsinh
import Mathlib.Analysis.SpecialFunctions.Sqrt
import Mathlib.Data.Matrix.Mul
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Data.Real.Basic
import Mathlib.Analysis.ODE.Gronwall
import Mathlib.Analysis.SpecialFunctions.Trigonometric.ArctanDeriv
import Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp
import Mathlib.Analysis.SpecialFunctions.Log.Basic
import Mathlib.MeasureTheory.Integral.IntervalIntegral.DistLEIntegral
import Mathlib.Tactic.GCongr
import Mathlib.Analysis.Calculus.Deriv.Slope
import Mathlib.Topology.Order.OrderClosed
import Mathlib.Tactic.Positivity
import Mathlib.MeasureTheory.Integral.IntervalIntegral.IntegrationByParts
import Mathlib.Topology.MetricSpace.Thickening
import Mathlib.Analysis.Normed.Module.FiniteDimension
import Mathlib.LinearAlgebra.Determinant
import Mathlib.Topology.Instances.Matrix
import Mathlib.LinearAlgebra.Matrix.Trace
import Mathlib.Analysis.Calculus.FDeriv.Analytic
import Mathlib.Topology.Algebra.Module.Determinant
import Mathlib.Analysis.SpecialFunctions.Log.Deriv
import Mathlib.Analysis.SpecialFunctions.ExpDeriv
import Mathlib.Topology.Order.ProjIcc
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Analysis.Normed.Operator.Basic
import Mathlib.LinearAlgebra.Matrix.Notation
import Mathlib.Analysis.Calculus.ContDiff.Deriv
import Mathlib.Analysis.SpecialFunctions.Pow.Continuity
import Mathlib.Topology.MetricSpace.Cauchy
import Mathlib.Analysis.Calculus.ContDiff.Comp
import Mathlib.Analysis.Calculus.Deriv.Comp
import Mathlib.Analysis.Calculus.UniformLimitsDeriv
import Mathlib.Analysis.Calculus.InverseFunctionTheorem.ContDiff
import Mathlib.Analysis.SpecialFunctions.ImproperIntegrals
import Mathlib.Analysis.Calculus.ParametricIntegral
import Mathlib.MeasureTheory.Integral.Bochner.ContinuousLinearMap
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Analysis.Calculus.FDeriv.Comp
import Mathlib.Algebra.Order.Floor.Ring
import Mathlib.Analysis.Calculus.FDeriv.Mul
import Mathlib.LinearAlgebra.Matrix.ToLin
import Mathlib.Data.List.Induction
import Mathlib.Algebra.BigOperators.Ring.Finset
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.Algebra.Order.Floor.Semiring
import Mathlib.MeasureTheory.Constructions.BorelSpace.Metrizable
import Mathlib.Topology.Algebra.InfiniteSum.Order
import Mathlib.Data.PNat.Basic
import Mathlib.Data.Rat.Floor
import Mathlib.NumberTheory.Real.Irrational
import Mathlib.Order.OrderIsoNat
import Mathlib.MeasureTheory.Group.MeasurableEquiv
import Mathlib.MeasureTheory.Measure.Regular
import Mathlib.MeasureTheory.Function.JacobianOneDim
import Definitions.Def_BianchiIX_Dynamics_CoreAngle
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Function.Floor
import Definitions.Def_BianchiIX_Statistics_GaussCoding
import Definitions.Def_BianchiIX_Statistics_GaussTypical
import Mathlib.Dynamics.Ergodic.Ergodic
import Mathlib.Dynamics.BirkhoffSum.Average
import Mathlib.MeasureTheory.Integral.Bochner.Basic
import Mathlib.MeasureTheory.Measure.WithDensity
import Mathlib.Dynamics.Ergodic.MeasurePreserving
import Mathlib.Analysis.Asymptotics.SpecificAsymptotics
import Mathlib.Topology.UniformSpace.HeineCantor
import Mathlib.Dynamics.BirkhoffSum.NormedSpace
import Mathlib.MeasureTheory.Integral.Bochner.Set
import Mathlib.Analysis.Normed.Group.Tannery
import Mathlib.MeasureTheory.Function.LocallyIntegrable
section
section
noncomputable section
open BianchiIX
open Set MeasureTheory
open scoped ENNReal
open EraCurve
private theorem BianchiIX.EraCurve.StepEstimates.branch_image_open {Γ : EraCurve} {η σ B C : ℝ} {J : ℕ}
(H : Γ.StepEstimates η J σ B C) (m : ℕ) (hm : m < ⌊1 / B ^ σ⌋₊) :
eraInverseBranch η J m (B ^ σ) Γ.U Γ.W '' Ioo (2 * B ^ σ) (1 - 2 * B ^ σ) =
Ioo (eraInverseBranch η J m (B ^ σ) Γ.U Γ.W (1 - 2 * B ^ σ))
(eraInverseBranch η J m (B ^ σ) Γ.U Γ.W (2 * B ^ σ)) := by
have hc : ContinuousOn (eraInverseBranch η J m (B ^ σ) Γ.U Γ.W)
(Icc (2 * B ^ σ) (1 - 2 * B ^ σ)) :=
fun y hy => ((H.branch m hm).2 y hy).2.2.1.continuousAt.continuousWithinAt
exact hc.image_Ioo_of_strictAntiOn (by linarith [H.beta_small]) (H.branch m hm).1
end
end
noncomputable section
namespace BianchiIX
open Set MeasureTheory
open scoped ENNReal
def eraTreeDomain (σ B : ℝ) (w : List ℕ+) (a : ℕ+) : Set ℝ :=
if a.natPred < ⌊1 / (eraAmplitude B w.length) ^ σ⌋₊ then
Ioo (2 * (eraAmplitude B w.length) ^ σ) (1 - 2 * (eraAmplitude B w.length) ^ σ)
else ∅
theorem mem_eraTreeDomain {σ B y : ℝ} {w : List ℕ+} {a : ℕ+} :
y ∈ eraTreeDomain σ B w a ↔ a.natPred < ⌊1 / (eraAmplitude B w.length) ^ σ⌋₊ ∧
y ∈ Ioo (2 * (eraAmplitude B w.length) ^ σ) (1 - 2 * (eraAmplitude B w.length) ^ σ) := by
unfold eraTreeDomain
split_ifs <;> simp_all
namespace EraCurve
def treeBranch (Γ : EraCurve) (η : ℝ) (J : ℕ) (σ B : ℝ) (w : List ℕ+) (a : ℕ+) : ℝ → ℝ :=
eraInverseBranch η J a.natPred ((eraAmplitude B w.length) ^ σ)
(Γ.family η J σ B w).U (Γ.family η J σ B w).W
theorem treeBranch_image_of_retained {Γ : EraCurve} {η σ B C : ℝ} {J : ℕ} {w : List ℕ+}
(H : (Γ.family η J σ B w).StepEstimates η J σ (eraAmplitude B w.length) C)
(a : ℕ+) (ha : a.natPred < ⌊1 / (eraAmplitude B w.length) ^ σ⌋₊) :
Γ.treeBranch η J σ B w a '' eraTreeDomain σ B w a =
Ioo (Γ.treeBranch η J σ B w a (1 - 2 * (eraAmplitude B w.length) ^ σ))
(Γ.treeBranch η J σ B w a (2 * (eraAmplitude B w.length) ^ σ)) := by
rw [eraTreeDomain, if_pos ha]
exact H.branch_image_open a.natPred ha
def inverseTree (Γ : EraCurve) (η : ℝ) (J : ℕ) (σ B C : ℝ)
(H : ∀ w : List ℕ+, (Γ.family η J σ B w).StepEstimates η J σ (eraAmplitude B w.length) C) :
InverseBranchTree where
root := Ioo 0 1
branch := Γ.treeBranch η J σ B
domain := eraTreeDomain σ B
root_open := isOpen_Ioo
domain_open := by intro w a; unfold eraTreeDomain; split_ifs <;> first | exact isOpen_Ioo | exact isOpen_empty
branch_continuous := by
intro w a y hy
obtain ⟨ha, hy⟩ := mem_eraTreeDomain.mp hy
exact (((H w).branch a.natPred ha).2 y ⟨hy.1.le, hy.2.le⟩).2.2.1.continuousAt.continuousWithinAt
branch_injective := by
intro w a x hx y hy hxy
obtain ⟨ha, hx⟩ := mem_eraTreeDomain.mp hx
obtain ⟨_, hy⟩ := mem_eraTreeDomain.mp hy
exact ((H w).branch a.natPred ha).1.injOn ⟨hx.1.le, hx.2.le⟩ ⟨hy.1.le, hy.2.le⟩ hxy
branch_disjoint := by
intro w a b hab
by_cases ha : a.natPred < ⌊1 / (eraAmplitude B w.length) ^ σ⌋₊
· by_cases hb : b.natPred < ⌊1 / (eraAmplitude B w.length) ^ σ⌋₊
· rw [treeBranch_image_of_retained (H w) a ha, treeBranch_image_of_retained (H w) b hb]
exact (H w).branch_disjoint (Finset.mem_range.mpr ha) (Finset.mem_range.mpr hb)
(fun he => hab (PNat.natPred_injective he))
· have hd : eraTreeDomain σ B w b = ∅ := by rw [eraTreeDomain, if_neg hb]
rw [hd, image_empty]
simp
· have hd : eraTreeDomain σ B w a = ∅ := by rw [eraTreeDomain, if_neg ha]
rw [hd, image_empty]
simp
end EraCurve
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Set
def eraPrefixState (η : ℝ) (J : ℕ) : List ℕ+ → (ℝ × CoreAngleState) → ℝ × CoreAngleState
| [] => id
| a :: w => eraPrefixState η J w ∘ eraBudgetReturn η J a.natPred
def eraPrefixDomain (η : ℝ) (J : ℕ) (σ Bstar : ℝ) : List ℕ+ → Set (ℝ × CoreAngleState)
| [] => univ
| a :: w => eraSelectedInputs η J σ Bstar a.natPred ∩
eraBudgetReturn η J a.natPred ⁻¹' eraPrefixDomain η J σ Bstar w
def eraSurvivorDomain (η : ℝ) (J : ℕ) (σ Bstar : ℝ) : Set (ℝ × CoreAngleState) :=
⋂ n : ℕ, ⋃ w : {w : List ℕ+ // w.length = n}, eraPrefixDomain η J σ Bstar w.val
end BianchiIX
end
end
section
section
noncomputable section
open BianchiIX
open Set
private theorem BianchiIX.eraInputSelection_disjoint {σ Bstar : ℝ} {m n : ℕ} (hmn : m ≠ n) :
Disjoint (eraInputSelection σ Bstar m) (eraInputSelection σ Bstar n) := by
apply disjoint_left.mpr
intro p hm hn
have hβ : 0 < p.1 ^ σ := Real.rpow_pos_of_pos hm.1.1 _
have hrm := hm.2.2.2.2.2
have hrn := hn.2.2.2.2.2
rcases lt_or_gt_of_ne hmn with h | h
· have hcast : (m : ℝ) + 1 ≤ n := by exact_mod_cast (Nat.succ_le_of_lt h)
linarith [hrm.2, hrn.1]
· have hcast : (n : ℝ) + 1 ≤ m := by exact_mod_cast (Nat.succ_le_of_lt h)
linarith [hrn.2, hrm.1]
end
end
section
noncomputable section
open BianchiIX
open Set
private theorem BianchiIX.eraSelectedInputs_disjoint (η : ℝ) (J : ℕ) (σ Bstar : ℝ) {m n : ℕ} (hmn : m ≠ n) :
Disjoint (eraSelectedInputs η J σ Bstar m) (eraSelectedInputs η J σ Bstar n) :=
(eraInputSelection_disjoint hmn).mono (fun _ h => h.1) (fun _ h => h.1)
end
end
section
noncomputable section
open BianchiIX
open Set
private theorem BianchiIX.mem_eraPrefixDomain_append (η : ℝ) (J : ℕ) (σ Bstar : ℝ)
(v w : List ℕ+) (p : ℝ × CoreAngleState) :
p ∈ eraPrefixDomain η J σ Bstar (v ++ w) ↔
p ∈ eraPrefixDomain η J σ Bstar v ∧ eraPrefixState η J v p ∈ eraPrefixDomain η J σ Bstar w := by
induction v generalizing p with
| nil => simp [eraPrefixDomain, eraPrefixState]
| cons a v ih =>
simp only [List.cons_append, eraPrefixDomain, mem_inter_iff, mem_preimage, eraPrefixState,
Function.comp_apply, ih]
exact and_assoc.symm
end
end
section
noncomputable section
open BianchiIX
open Set
private theorem BianchiIX.eraPrefixDomain_unique (η : ℝ) (J : ℕ) (σ Bstar : ℝ) {v w : List ℕ+}
(hlen : v.length = w.length) {p : ℝ × CoreAngleState}
(hv : p ∈ eraPrefixDomain η J σ Bstar v) (hw : p ∈ eraPrefixDomain η J σ Bstar w) : v = w := by
induction v generalizing w p with
| nil => exact (List.length_eq_zero_iff.mp hlen.symm).symm
| cons a v ih =>
cases w with
| nil => simp at hlen
| cons b w =>
have hab : a = b := by
by_contra hne
have hd := eraSelectedInputs_disjoint η J σ Bstar
(fun he => hne (PNat.natPred_injective he))
exact Set.disjoint_left.mp hd hv.1 hw.1
subst b
exact congrArg (List.cons a) (ih (Nat.succ.inj hlen) hv.2 hw.2)
end
end
noncomputable section
namespace BianchiIX
open Set
namespace EraSurvivor
variable {η σ Bstar : ℝ} {J : ℕ}
private theorem exists_word (p : eraSurvivorDomain η J σ Bstar) (n : ℕ) :
∃ w : List ℕ+, w.length = n ∧ p.val ∈ eraPrefixDomain η J σ Bstar w := by
obtain ⟨w, hw⟩ := mem_iUnion.mp (mem_iInter.mp p.property n)
exact ⟨w.val, w.property, hw⟩
def word (p : eraSurvivorDomain η J σ Bstar) (n : ℕ) : List ℕ+ := (exists_word p n).choose
theorem word_length (p : eraSurvivorDomain η J σ Bstar) (n : ℕ) : (word p n).length = n :=
(exists_word p n).choose_spec.1
theorem mem_word_domain (p : eraSurvivorDomain η J σ Bstar) (n : ℕ) :
p.val ∈ eraPrefixDomain η J σ Bstar (word p n) := (exists_word p n).choose_spec.2
private theorem exists_next_digit (p : eraSurvivorDomain η J σ Bstar) (n : ℕ) :
∃ a : ℕ+, word p (n + 1) = word p n ++ [a] := by
have hl := word_length p (n + 1)
have hp := mem_word_domain p (n + 1)
generalize word p (n + 1) = w at hl hp ⊢
induction w using List.reverseRecOn with
| nil => simp at hl
| append_singleton w a _ =>
have hw : w = word p n := eraPrefixDomain_unique η J σ Bstar
(by simpa [word_length] using hl)
((mem_eraPrefixDomain_append η J σ Bstar w [a] p.val).mp hp).1 (mem_word_domain p n)
exact ⟨a, congrArg (fun v => v ++ [a]) hw⟩
def digits (p : eraSurvivorDomain η J σ Bstar) (n : ℕ) : ℕ+ := (exists_next_digit p n).choose
def code (p : eraSurvivorDomain η J σ Bstar) : ℝ := gaussCode (digits p)
def typicalDomain (η : ℝ) (J : ℕ) (σ Bstar : ℝ) : Set (ℝ × CoreAngleState) :=
Subtype.val '' {p : eraSurvivorDomain η J σ Bstar | code p ∈ gaussCylinderTypicalSet}
end EraSurvivor
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Set
namespace EraCurve
def treeState (Γ : EraCurve) (η : ℝ) (J : ℕ) (σ B : ℝ) (w : List ℕ+) (x : ℝ) : ℝ × CoreAngleState :=
(eraAmplitude B w.length, (Γ.family η J σ B w).state (2 / x))
/-- Agreement of the selected forward return with every edge of an inverse tree. -/
structure Realization (Γ : EraCurve) (η : ℝ) (J : ℕ) (σ B Bcap : ℝ) (T : InverseBranchTree) : Prop where
root : T.root = Ioo 0 1
step : ∀ w a y, y ∈ T.domain w a →
eraBudgetReturn η J a.natPred (Γ.treeState η J σ B w (T.branch w a y)) =
Γ.treeState η J σ B (w ++ [a]) y
selected : ∀ w a x, Γ.treeState η J σ B w x ∈ eraSelectedInputs η J σ Bcap a.natPred ↔
x ∈ T.branch w a '' T.domain w a
namespace Realization
end Realization
end EraCurve
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Set
namespace EraSurvivor
def phase {η σ Bcap : ℝ} {J : ℕ} (p : eraSurvivorDomain η J σ Bcap) (n : ℕ) : ℝ :=
2 / (eraPrefixState η J (word p n) p.val).2 0
def curveTypicalSet (Γ : EraCurve) (η : ℝ) (J : ℕ) (σ B Bcap : ℝ) : Set ℝ :=
Ioo 0 1 ∩ (fun x => (B, Γ.state (2 / x))) ⁻¹' typicalDomain η J σ Bcap
end EraSurvivor
namespace EraCurve.Realization
end EraCurve.Realization
end BianchiIX
end
end