Survivor states, physical arrival schedules and complete era sequences
DefinitionBianchiIX_PhysicalEraDataFor 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 .
Write , and for its maximal domain. Set , , , and
The six axis frames realize all permutations of the normalized walls and diagonal shears. Write for the frame obtained by swaps followed by the cyclic permutation. The event itinerary has the following meaning. For , the radius of exceeds two, the entry is an upward unit-wall crossing, its core first return is valid, and its endpoint is . For the exit radius exceeds four, and the first positive unit-wall hit in the swapped chart reaches , the reflection of the endpoint at time . The final exit has radius strictly between two and four. In the cycled exit chart its first positive unit-wall hit occurs at , has state and positive event rate. Finally .
For a budget cap define by the conditions on
The selected domain additionally requires ; the budget return is . In a small-budget assertion there exists such that for every , with , and , the stated constants can be chosen.
Let be a budget and core state surviving all selected returns at cap . Its successive digits are , its transported states are , its phases are , and . Put
Frame indices use the chosen composition on the six labels. For restart data , let and let denote the frame with index chosen for , where is the initial frame of label . A restart witness for requires , and a survivor with initial data , full era statistics, and entry .
A physical era sequence consists of complete event blocks on a single constraint-one orbit with the stated statistics, increasing positive times tending to infinity, matching next states, times and frames, and an actual preceding block ending at its first entrance.
import Definitions.Def_BianchiIX_Dynamics_CoreAngle
import Definitions.Def_BianchiIX_EraCodingData
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 Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Function.Floor
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
import Definitions.Def_BianchiIX_Dynamics_Normalized
import Definitions.Def_BianchiIX_Dynamics_AxisMaps
import Definitions.Def_BianchiIX_Dynamics_AxisSymmetry
import Definitions.Def_BianchiIX_AxisAndOrbitData
import Mathlib.Analysis.InnerProductSpace.PiL2
import Definitions.Def_BianchiIX_Dynamics_ProjectiveState
import Definitions.Def_BianchiIX_Dynamics_MaximalFlow
import Definitions.Def_BianchiIX_Statistics_EraStatistics
import Definitions.Def_BianchiIX_Dynamics_CoreEntryDifferential
import Mathlib.Topology.Order.MonotoneConvergence
import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
import Definitions.Def_BianchiIX_TerminalConeData
import Definitions.Def_BianchiIX_EraReturnData
import Mathlib.Order.Interval.Set.Monotone
section
noncomputable section
namespace BianchiIX
open Set MeasureTheory
local instance _root_.BianchiIX.instMeasurableSpaceListPNat_bianchiIX : MeasurableSpace (List ℕ+) := ⊤
namespace EraSurvivor
variable {η σ Bcap : ℝ} {J : ℕ}
def budgetState (p : eraSurvivorDomain η J σ Bcap) (n : ℕ) : ℝ × CoreAngleState :=
eraPrefixState η J (word p n) p.val
def state (p : eraSurvivorDomain η J σ Bcap) (n : ℕ) : CoreAngleState := (budgetState p n).2
end EraSurvivor
end BianchiIX
end
end
section
section
noncomputable section
open BianchiIX
private theorem BianchiIX.axisCycle_shears (x : NormalizedState) :
normalizedShears (axisCycle x) = ![normalizedShears x 1, normalizedShears x 2, normalizedShears x 0] := by
have hs : (Real.sqrt 3) ^ 2 = 3 := Real.sq_sqrt (by norm_num)
ext i
fin_cases i <;> dsimp [normalizedShears, axisCycle] <;> ring_nf <;> norm_num [hs] <;> ring
end
end
section
noncomputable section
open BianchiIX
private theorem BianchiIX.axisSwap_shears (x : NormalizedState) :
normalizedShears (axisSwap x) = ![normalizedShears x 0, normalizedShears x 2, normalizedShears x 1] := by
ext i
fin_cases i <;> dsimp [normalizedShears, axisSwap] <;> ring
end
end
section
noncomputable section
open BianchiIX
private theorem BianchiIX.axisOrder_bijective : ∀ i, Function.Bijective (axisOrder i) := by decide
end
end
section
noncomputable section
open BianchiIX
private theorem BianchiIX.axisFrame_apply (i : Fin 6) (x : NormalizedState) :
(axisFrame i).map x =
![x, axisCycle x, axisCycle (axisCycle x), axisSwap x,
axisSwap (axisCycle x), axisSwap (axisCycle (axisCycle x))] i := by
fin_cases i <;> rfl
end
end
section
noncomputable section
open BianchiIX
private theorem BianchiIX.axisFrame_walls (i : Fin 6) (x : NormalizedState) :
normalizedWalls ((axisFrame i).map x) = fun j => normalizedWalls x (axisOrder i j) := by
rw [axisFrame_apply]
fin_cases i <;> ext j <;> fin_cases j <;> rfl
end
end
section
noncomputable section
open BianchiIX
private theorem BianchiIX.axisFrame_shears (i : Fin 6) (x : NormalizedState) :
normalizedShears ((axisFrame i).map x) = fun j => normalizedShears x (axisOrder i j) := by
rw [axisFrame_apply]
fin_cases i
· ext j
fin_cases j <;> rfl
· change normalizedShears (axisCycle x) = _
rw [axisCycle_shears]
ext j
fin_cases j <;> rfl
· change normalizedShears (axisCycle (axisCycle x)) = _
simp only [axisCycle_shears]
ext j
fin_cases j <;> rfl
· change normalizedShears (axisSwap x) = _
rw [axisSwap_shears]
ext j
fin_cases j <;> rfl
· change normalizedShears (axisSwap (axisCycle x)) = _
simp only [axisSwap_shears, axisCycle_shears]
ext j
fin_cases j <;> rfl
· change normalizedShears (axisSwap (axisCycle (axisCycle x))) = _
simp only [axisSwap_shears, axisCycle_shears]
ext j
fin_cases j <;> rfl
end
end
section
noncomputable section
open BianchiIX
private theorem BianchiIX.normalizedState_ext_shears_walls {x y : NormalizedState}
(hs : normalizedShears x = normalizedShears y) (hw : normalizedWalls x = normalizedWalls y) : x = y := by
have h₀ := congrFun hs 0
have h₁ := congrFun hs 1
change -2 * x 0 = -2 * y 0 at h₀
change x 0 - Real.sqrt 3 * x 1 = y 0 - Real.sqrt 3 * y 1 at h₁
have hx₀ : x 0 = y 0 := by linarith
have hx₁ : x 1 = y 1 := mul_left_cancel₀ (Real.sqrt_ne_zero'.mpr (by norm_num : (0 : ℝ) < 3))
(by linarith : Real.sqrt 3 * x 1 = Real.sqrt 3 * y 1)
ext i
fin_cases i
· exact hx₀
· exact hx₁
· exact congrFun hw 0
· exact congrFun hw 1
· exact congrFun hw 2
end
end
section
noncomputable section
open BianchiIX
private theorem BianchiIX.axisFrame_comp (i j : Fin 6) :
∃ k : Fin 6, ∀ x : NormalizedState,
(axisFrame i).map ((axisFrame j).map x) = (axisFrame k).map x := by
let σ : Equiv.Perm (Fin 3) := Equiv.ofBijective (axisOrder i) (axisOrder_bijective i)
let τ : Equiv.Perm (Fin 3) := Equiv.ofBijective (axisOrder j) (axisOrder_bijective j)
obtain ⟨k, hk⟩ := axisOrder_covers (σ.trans τ)
refine ⟨k, fun x => normalizedState_ext_shears_walls ?_ ?_⟩
· ext l
simp only [axisFrame_shears, hk]
rfl
· ext l
simp only [axisFrame_walls, hk]
rfl
end
end
noncomputable section
namespace BianchiIX
namespace EraSurvivor
variable {η σ Bcap : ℝ} {J : ℕ}
def duration (p : eraSurvivorDomain η J σ Bcap) (n : ℕ) : ℝ :=
eraReturnTime η J (digits p n).natPred (state p n)
def elapsedTime (p : eraSurvivorDomain η J σ Bcap) (n : ℕ) : ℝ :=
∑ j ∈ Finset.range n, duration p j
def frame (p : eraSurvivorDomain η J σ Bcap) : ℕ → Fin 6
| 0 => 0
| n + 1 => (axisFrame_comp (eraReturnFrame (digits p n).natPred) (frame p n)).choose
end EraSurvivor
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
/-- Physical frame, elapsed time, budget, and actual core state. -/
abbrev CoreRestartData := (Fin 6 × ℝ) × (ℝ × CoreAngleState)
def CoreRestartWitness (η : ℝ) (J : ℕ) (σ Bcap : ℝ) (x : NormalizedState)
(w : CoreRestartData) : Prop :=
0 < w.1.2 ∧ w.1.2 ∈ normalizedMaxDomain x 0 ∧
∃ p : eraSurvivorDomain η J σ Bcap, p.val = w.2 ∧
EraStatistics (EraSurvivor.digits p) (EraSurvivor.phase p) ∧
coreRadiusEntry p.val.2 = toProjectiveState ((axisFrame w.1.1).map (normalizedMaxCurve x 0 w.1.2))
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Filter
open scoped Topology
namespace EraSurvivor
variable {η σ Bcap : ℝ} {J : ℕ}
def physicalTime (w : CoreRestartData) (p : eraSurvivorDomain η J σ Bcap) (n : ℕ) : ℝ :=
elapsedTime p n + w.1.2
def physicalFrame (w : CoreRestartData) (p : eraSurvivorDomain η J σ Bcap) (n : ℕ) : Fin 6 :=
(axisFrame_comp (frame p n) w.1.1).choose
end EraSurvivor
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Set Filter
open scoped Topology
/-- Complete eras on one original physical trajectory, including the terminal connection before the first era. -/
structure PhysicalEraSequence (η : ℝ) (J : ℕ) (x : NormalizedState)
(K : ℕ → ℕ+) (Y : ℕ → CoreAngleState) (t : ℕ → ℝ) (a : ℕ → Fin 6) : Prop where
constraint : stateConstraint x = 1
statistics : EraStatistics K (fun n => 2 / Y n 0)
time_positive : ∀ n, 0 < t n
time_strictMono : StrictMono t
time_unbounded : Tendsto t atTop atTop
entrance : ∀ n, fromProjectiveState (coreRadiusEntry (Y n)) =
(axisFrame (a n)).map (normalizedMaxCurve x 0 (t n))
block : ∀ n, EraEventItinerary η J (K n).natPred (Y n)
next_state : ∀ n, coreRadiusEntry (Y (n + 1)) = terminalNaturalState η J
(eraCoreExit (K n).natPred (Y n))
next_time : ∀ n, t (n + 1) = eraReturnTime η J (K n).natPred (Y n) + t n
next_frame : ∀ n z, (axisFrame (a (n + 1))).map z =
(axisFrame (eraReturnFrame (K n).natPred)).map ((axisFrame (a n)).map z)
preceding_terminal : ∃ m X s i, EraEventItinerary η J m X ∧ 0 < s ∧ s < t 0 ∧
fromProjectiveState (coreRadiusEntry X) = (axisFrame i).map (normalizedMaxCurve x 0 s) ∧
t 0 = eraReturnTime η J m X + s ∧
coreRadiusEntry (Y 0) = terminalNaturalState η J (eraCoreExit m X) ∧
∀ z, (axisFrame (a 0)).map z = (axisFrame (eraReturnFrame m)).map ((axisFrame i).map z)
namespace EraSurvivor
end EraSurvivor
namespace PhysicalEraSequence
end PhysicalEraSequence
end BianchiIX
end
end