Physical axis charts, core flight times and the Brehm attractor input
DefinitionBianchiIX_AxisAndOrbitDataFor real variables , set
The shear components and wall rates are
These functions define the normalized vacuum Bianchi IX vector field .
Let with coordinates and the sup norm. Write
and let .
Write , , and . For initial data , let be the union of all open convex domains of solutions with these initial data, and let be their compatible curve. A solution has such a domain , a curve , and .
Let be the continuous linear operators on and set
For a fixed initial time , put
Write for the constraint differential.
For , define
Write for the matrix of a continuous linear operator in the standard basis. Set ,
A normalized symmetry is a continuous linear equivalence satisfying
These symmetries include the identity, composition, inverse, and the two maps
Transforming a solution replaces its curve by and keeps its time domain.
Write , with domain , and . For and a wall height , put
For a normalized axis symmetry , the chart is , with coordinates . At its flux density and measure are
Write for the signed section flux and for the corrected divergence. The three primary frames interchange axis zero with the chosen dominant axis.
Let be the union, over primary frames, of the subspaces where the transverse shear and the difference of the other two walls both vanish. Set . The Brehm attractor input used here is the following proposition: for each and ,
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.
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 .
These data include the positive constraint phase space, the Euclidean distances to the three Taub points, their invariant subspaces, and the pairwise wall products. In the primary frame the squared transverse radius is ; its weighted form multiplies this by . Orbit saturation is the union of the existing flow images at all times. The frame changes, wall charts, actual arrival branches and core flight times specify the events of each finite era.
import Definitions.Def_BianchiIX_Algebra_Flow
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.Tactic.LinearCombination
import Definitions.Def_BianchiIX_Algebra_Flux
import Mathlib.Analysis.SpecialFunctions.Pow.Deriv
import Mathlib.Tactic.FieldSimp
import Definitions.Def_BianchiIX_Dynamics_Normalized
import Mathlib.Analysis.Calculus.ContDiff.Operations
import Mathlib.Analysis.Calculus.Deriv.Prod
import Mathlib.Analysis.Calculus.MeanValue
import Mathlib.Data.Fin.VecNotation
import Mathlib.Tactic.FinCases
import Mathlib.Tactic.FunProp
import Mathlib.Analysis.SpecialFunctions.ExpDeriv
import Mathlib.Analysis.Calculus.Deriv.MeanValue
import Mathlib.Analysis.SpecialFunctions.Integrals.Basic
import Mathlib.Analysis.ODE.ExistUnique
import Mathlib.Analysis.Calculus.FDeriv.Partial
import Mathlib.Analysis.SpecialFunctions.Sqrt
import Mathlib.Analysis.SpecialFunctions.Log.Deriv
import Definitions.Def_BianchiIX_Dynamics_MaximalFlow
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.Calculus.Deriv.Pi
import Mathlib.LinearAlgebra.Determinant
import Mathlib.Data.Real.Basic
import Mathlib.LinearAlgebra.Alternating.Curry
import Definitions.Def_BianchiIX_Dynamics_AxisSymmetry
import Mathlib.Analysis.Normed.Module.FiniteDimension
import Mathlib.Analysis.Calculus.Deriv.Slope
import Mathlib.Topology.Compactness.Compact
import Mathlib.Analysis.Calculus.ImplicitContDiff
import Mathlib.Analysis.Calculus.InverseFunctionTheorem.ContDiff
import Mathlib.Topology.Compactness.Lindelof
import Mathlib.MeasureTheory.Function.Jacobian
import Mathlib.MeasureTheory.Measure.WithDensity
import Mathlib.Analysis.Calculus.FDeriv.Symmetric
import Mathlib.Tactic.NormNum
import Mathlib.Tactic.Module
import Mathlib.Analysis.SpecialFunctions.Arsinh
import Mathlib.Analysis.Calculus.Deriv.Inv
import Mathlib.Analysis.SpecialFunctions.Arcosh
import Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus
import Mathlib.Analysis.Calculus.InverseFunctionTheorem.Deriv
import Mathlib.Data.Matrix.Mul
import Mathlib.Algebra.BigOperators.Fin
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.Topology.Instances.Real.Lemmas
import Mathlib.MeasureTheory.Integral.IntervalIntegral.DistLEIntegral
import Mathlib.Tactic.GCongr
import Mathlib.Topology.Order.OrderClosed
import Mathlib.Topology.Order.IntermediateValue
import Mathlib.Analysis.InnerProductSpace.PiL2
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Analysis.Calculus.ParametricIntervalIntegral
import Mathlib.Topology.Order.Compact
import Mathlib.MeasureTheory.Integral.DominatedConvergence
import Mathlib.Tactic.Positivity
import Mathlib.MeasureTheory.Integral.IntervalIntegral.IntegrationByParts
import Mathlib.Topology.MetricSpace.Thickening
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.SpecialFunctions.ImproperIntegrals
import Mathlib.Analysis.Calculus.ParametricIntegral
import Mathlib.MeasureTheory.Integral.Bochner.ContinuousLinearMap
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Topology.Order.MonotoneConvergence
import Definitions.Def_BianchiIX_Dynamics_AxisMaps
import Definitions.Def_BianchiIX_Dynamics_CoreAngle
import Definitions.Def_BianchiIX_Dynamics_CompactCoreReturn
import Definitions.Def_BianchiIX_EraReturnData
import Mathlib.Analysis.Calculus.FDeriv.Comp
import Mathlib.Algebra.Order.Floor.Ring
import Mathlib.Analysis.Calculus.FDeriv.Mul
import Mathlib.LinearAlgebra.Matrix.ToLin
import Definitions.Def_BianchiIX_Dynamics_ProjectiveState
import Definitions.Def_BianchiIX_Dynamics_ProjectiveRegularity
import Definitions.Def_BianchiIX_Dynamics_Events
import Definitions.Def_BianchiIX_Dynamics_ProjectiveFlowVariation
import Definitions.Def_BianchiIX_Dynamics_ProjectiveReflection
import Definitions.Def_BianchiIX_Dynamics_CoreEntryDifferential
import Definitions.Def_BianchiIX_Dynamics_CoreTail
import Definitions.Def_BianchiIX_Dynamics_CoreReturnDifferential
import Definitions.Def_BianchiIX_TerminalConeData
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.MeasureTheory.Function.Floor
import Definitions.Def_BianchiIX_Dynamics_WallEvolution
import Mathlib.Topology.Order.Basic
import Mathlib.Topology.ContinuousOn
import Mathlib.Tactic.ByContra
import Mathlib.Topology.Order.Lattice
section
noncomputable section
namespace BianchiIX
def taubRadiusSq (s b c : ℝ) : ℝ := s ^ 2 + (b - c) ^ 2
def taubRadiusHalfRate (p s n b c : ℝ) : ℝ :=
s * shearMinus s n b c + (b - c) * (rateTwo p s * b - rateThree p s * c)
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
def sectionFluxDensity (p s : ℝ) : ℝ := (shearSq p s - 2 * p) / (2 * |p|)
def correctedSectionFluxDensity (p s a b c : ℝ) : ℝ :=
sectionFluxDensity p s / (1 + 4 * wallAmplitude a b c)
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Set
def normalizedTaubRadiusSq (x : NormalizedState) : ℝ := taubRadiusSq (x 1) (x 3) (x 4)
def weightedTaubRadiusSq (x : NormalizedState) : ℝ :=
normalizedTaubRadiusSq x * Real.exp (-8 * x 2)
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Set Filter
open scoped Topology
abbrev SectionCoordinates := Fin 3 → ℝ
def mainWallRadicand (h : ℝ) (y : SectionCoordinates) : ℝ :=
1 - y 0 ^ 2 - curvature h (Real.exp (-y 1)) (Real.exp (-y 2))
def mainWallChartDomain (h : ℝ) : Set SectionCoordinates := {y | 0 < mainWallRadicand h y}
def mainWallChart (h : ℝ) (y : SectionCoordinates) : NormalizedState :=
![-Real.sqrt (mainWallRadicand h y), y 0, h, Real.exp (-y 1), Real.exp (-y 2)]
def mainWallCoordinates (x : NormalizedState) : SectionCoordinates :=
![x 1, -Real.log (x 3), -Real.log (x 4)]
def mainWallChartDifferential (h : ℝ) (y : SectionCoordinates) : SectionCoordinates →L[ℝ] NormalizedState :=
fderiv ℝ (mainWallChart h) y
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Set
def normalizedOrbitSaturation (S : Set NormalizedState) : Set NormalizedState :=
{x | ∃ z ∈ S, ∃ t ∈ normalizedMaxDomain z 0, normalizedMaxCurve z 0 t = x}
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
def mainWallChartFrame (h : ℝ) (y : SectionCoordinates) : Fin 3 → NormalizedState :=
fun i => mainWallChartDifferential h y (Pi.single i 1)
def mainWallChartDensity (h : ℝ) (y : SectionCoordinates) : ℝ :=
correctedSectionFluxDensity (mainWallChart h y 0) (y 0) h (Real.exp (-y 1)) (Real.exp (-y 2))
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
def normalizedShears (x : NormalizedState) : Fin 3 → ℝ :=
![-2 * x 0, x 0 - Real.sqrt 3 * x 1, x 0 + Real.sqrt 3 * x 1]
def normalizedWalls (x : NormalizedState) : Fin 3 → ℝ := ![x 2, x 3, x 4]
open NormalizedSymmetry in
def axisFrame (i : Fin 6) : NormalizedSymmetry :=
![refl, cycle, cycle.trans cycle, swap, cycle.trans swap, (cycle.trans cycle).trans swap] i
def axisOrder (i : Fin 6) : Fin 3 → Fin 3 :=
![![0, 1, 2], ![1, 2, 0], ![2, 0, 1], ![0, 2, 1], ![1, 0, 2], ![2, 1, 0]] i
theorem axisOrder_covers : ∀ σ : Equiv.Perm (Fin 3), ∃ i, ∀ j, axisOrder i j = σ j := by decide
/-- Each permutation acts on walls and diagonal shear by exactly the same permutation. -/
def axisPermutation (σ : Equiv.Perm (Fin 3)) : NormalizedSymmetry :=
axisFrame (axisOrder_covers σ).choose
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Set Filter
open scoped Topology
def axisWallChart (A : NormalizedSymmetry) (h : ℝ) (y : SectionCoordinates) : NormalizedState :=
A.map.symm (mainWallChart h y)
def axisWallCoordinates (A : NormalizedSymmetry) (x : NormalizedState) : SectionCoordinates :=
mainWallCoordinates (A.map x)
def axisWallChartDifferential (A : NormalizedSymmetry) (h : ℝ) (y : SectionCoordinates) :
SectionCoordinates →L[ℝ] NormalizedState := fderiv ℝ (axisWallChart A h) y
def axisWallChartFrame (A : NormalizedSymmetry) (h : ℝ) (y : SectionCoordinates) : Fin 3 → NormalizedState :=
fun i => axisWallChartDifferential A h y (Pi.single i 1)
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Set
def axisSectionTimes (A : NormalizedSymmetry) (h ε : ℝ) (x : NormalizedState) (t₀ T : ℝ) : Set ℝ :=
{t ∈ Icc t₀ T | A.map (normalizedMaxCurve x t₀ t) 2 = h ∧
A.map (normalizedMaxCurve x t₀ t) 0 ≤ -ε}
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Set Filter
open scoped Topology
def axisWallFlowDomain (A : NormalizedSymmetry) (h : ℝ) : Set (SectionCoordinates × ℝ) :=
{p | p.1 ∈ mainWallChartDomain h ∧ p.2 ∈ normalizedMaxDomain (axisWallChart A h p.1) 0}
def axisWallFlowMap (A : NormalizedSymmetry) (h : ℝ) (p : SectionCoordinates × ℝ) : NormalizedState :=
normalizedMaxCurve (axisWallChart A h p.1) 0 p.2
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Set Filter
open scoped Topology
/-- An injective local arrival of the exact flow between two independently chosen axis charts. -/
structure AxisWallArrival (A B : NormalizedSymmetry) (h k t₀ : ℝ) where
source : Set SectionCoordinates
time : NormalizedState → ℝ
map : SectionCoordinates → SectionCoordinates
isOpen_source : IsOpen source
source_chart : source ⊆ mainWallChartDomain h
target_chart : MapsTo map source (mainWallChartDomain k)
time_mem : ∀ y ∈ source, time (axisWallChart A h y) ∈ normalizedMaxDomain (axisWallChart A h y) t₀
time_regular : ∀ y ∈ source, ContDiffAt ℝ 1 time (axisWallChart A h y)
map_regular : ∀ y ∈ source, ContDiffAt ℝ 1 map y
arrival : ∀ y ∈ source,
axisWallChart B k (map y) = normalizedMaxCurve (axisWallChart A h y) t₀ (time (axisWallChart A h y))
injOn : InjOn map source
namespace AxisWallArrival
variable {A B : NormalizedSymmetry} {h k t₀ : ℝ} (P : AxisWallArrival A B h k t₀)
def jacobian (y : SectionCoordinates) : ℝ :=
mainWallChartDensity k (P.map y) * |(fderiv ℝ P.map y).det| / mainWallChartDensity h y
end AxisWallArrival
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Set Filter
open scoped Topology
def axisWallArrivalRelation (A B : NormalizedSymmetry) (h k t₀ : ℝ) : Set (SectionCoordinates × ℝ) :=
{z | z.1 ∈ mainWallChartDomain h ∧ z.2 ∈ normalizedMaxDomain (axisWallChart A h z.1) t₀ ∧
B.map (normalizedMaxCurve (axisWallChart A h z.1) t₀ z.2) 2 = k ∧
B.map (normalizedMaxCurve (axisWallChart A h z.1) t₀ z.2) 0 < 0}
def AxisWallArrival.empty (A B : NormalizedSymmetry) (h k t₀ : ℝ) : AxisWallArrival A B h k t₀ where
source := ∅
time := fun _ => t₀
map := id
isOpen_source := isOpen_empty
source_chart := empty_subset _
target_chart := fun _ hy => hy.elim
time_mem := fun _ hy => hy.elim
time_regular := fun _ hy => hy.elim
map_regular := fun _ hy => hy.elim
arrival := fun _ hy => hy.elim
injOn := injOn_empty _
/-- The countable branches cover the actual crossing relation, including every admissible time. -/
structure AxisWallArrivalAtlas (A B : NormalizedSymmetry) (h k t₀ : ℝ) where
branch : ℕ → AxisWallArrival A B h k t₀
covers : ∀ z ∈ axisWallArrivalRelation A B h k t₀,
∃ n, z.1 ∈ (branch n).source ∧ (branch n).time (axisWallChart A h z.1) = z.2
namespace AxisWallArrival
variable {A B : NormalizedSymmetry} {h k t₀ : ℝ} (P : AxisWallArrival A B h k t₀)
def coordinateTime (y : SectionCoordinates) : ℝ := P.time (axisWallChart A h y)
end AxisWallArrival
abbrev AxisWallAtlasFamily {ι : Type*} (A : NormalizedSymmetry) (B : ι → NormalizedSymmetry)
(h : ℝ) (k : ι → ℝ) (t₀ : ℝ) := ∀ i, AxisWallArrivalAtlas A (B i) h (k i) t₀
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Set MeasureTheory
def axisFamilyChart {ι : Type*} (B : ι → NormalizedSymmetry) (k : ι → ℝ)
(z : ι × SectionCoordinates) : NormalizedState := axisWallChart (B z.1) (k z.1) z.2
def axisFamilySection {ι : Type*} (E : ι → Set SectionCoordinates) : Set (ι × SectionCoordinates) :=
{z | z.2 ∈ E z.1}
def dominantWallChartDomain (h : ℝ) : Set SectionCoordinates :=
{y | y ∈ mainWallChartDomain h ∧ Real.exp (-y 1) < h ∧ Real.exp (-y 2) < h}
/-- One verified frame for each possible dominant physical axis. -/
def primaryAxisFrame (i : Fin 3) : NormalizedSymmetry := axisPermutation (Equiv.swap 0 i)
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
/-- The physical Euclidean distance, distinct from the sup norm on `NormalizedState`. -/
def normalizedEuclideanDistance (x y : NormalizedState) : ℝ :=
dist (WithLp.toLp 2 x : EuclideanSpace ℝ (Fin 5)) (WithLp.toLp 2 y)
def taubPoint (i : Fin 3) : NormalizedState :=
![![-1, 0, 0, 0, 0], ![1 / 2, -Real.sqrt 3 / 2, 0, 0, 0],
![1 / 2, Real.sqrt 3 / 2, 0, 0, 0]] i
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Set Filter MeasureTheory
open scoped Topology
def physicalPhaseSpace : Set NormalizedState :=
{x | positiveWalls x ∧ stateConstraint x = 1}
def taubSubspaces : Set NormalizedState :=
{x | ∃ i : Fin 3, normalizedTaubRadiusSq ((primaryAxisFrame i).map x) = 0}
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
/-- The entire forward exact orbit stays at least `ε` from all three Taub points. -/
def normalizedTaubAvoidance (ε : ℝ) (x : NormalizedState) : Prop :=
∀ t, 0 ≤ t → t ∈ normalizedMaxDomain x 0 →
∀ i, ε ≤ normalizedEuclideanDistance (normalizedMaxCurve x 0 t) (taubPoint i)
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Set Filter
open scoped Topology
def normalizedWallProduct (x : NormalizedState) : ℝ := x 2 * x 3 * x 4
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
/-- Original time spent in the first `m` nonterminal core-reflection passages. -/
def corePrefixTime (m : ℕ) (X : CoreAngleState) : ℝ :=
∑ j ∈ Finset.range m, coreReflectionTime ((coreReflectionState coreRadiusReturnTime)^[j] X)
def corePrefixFrame : ℕ → Fin 6
| 0 => 0
| m + 1 => (axisFrame_comp 3 (corePrefixFrame m)).choose
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
/-- The full original time includes every reflection, the last downward core, and the terminal connection. -/
def eraReturnTime (η : ℝ) (J m : ℕ) (X : CoreAngleState) : ℝ :=
terminalNaturalTime η J (eraCoreExit m X) +
(coreRadiusReturnTime ((coreReflectionState coreRadiusReturnTime)^[m] X) + corePrefixTime m X)
def eraReturnFrame (m : ℕ) : Fin 6 := (axisFrame_comp 1 (corePrefixFrame m)).choose
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Set
/-- A finite block of actual first core returns, followed by its first terminal connection. -/
structure EraEventItinerary (η : ℝ) (J m : ℕ) (X : CoreAngleState) : Prop where
core : ∀ j ≤ m,
let Y := (coreReflectionState coreRadiusReturnTime)^[j] X
2 < Y 0 ∧
(projectiveActiveWall (fromProjectiveState (coreRadiusEntry Y)) = 1 ∧
0 < normalizedEventRate projectiveActiveWall (fromProjectiveState (coreRadiusEntry Y)) 0 0) ∧
coreRadiusReturnValid Y ∧
coreTailEntry (coreReturnState coreRadiusReturnTime Y) =
projectiveOriginalFlow (coreRadiusEntry Y) 0 (coreRadiusReturnTime Y)
reflection : ∀ j < m,
let Y := (coreReflectionState coreRadiusReturnTime)^[j] X
let Z := coreReturnState coreRadiusReturnTime Y
let x := axisSwap (fromProjectiveState (coreTailEntry Z))
4 < Z 0 ∧
IsLeast {t : ℝ | 0 < t ∧ t ∈ normalizedMaxDomain x 0 ∧
projectiveActiveWall (normalizedMaxCurve x 0 t) = 1} (reflectionReturnTime Z) ∧
toProjectiveState (normalizedMaxCurve x 0 (reflectionReturnTime Z)) =
coreRadiusEntry ((coreReflectionState coreRadiusReturnTime)^[j + 1] X) ∧
coreRadiusEntry ((coreReflectionState coreRadiusReturnTime)^[j + 1] X) =
projectiveReflection (projectiveOriginalFlow (coreRadiusEntry Y) 0 (coreReflectionTime Y))
terminal :
let Z := eraCoreExit m X
let x := axisCycle (fromProjectiveState (coreTailEntry Z))
let T := terminalNaturalTime η J Z
(2 < Z 0 ∧ Z 0 < 4) ∧
IsLeast {t : ℝ | 0 < t ∧ t ∈ normalizedMaxDomain x 0 ∧
projectiveActiveWall (normalizedMaxCurve x 0 t) = 1} T ∧
toProjectiveState (normalizedMaxCurve x 0 T) = terminalNaturalState η J Z ∧
terminalNaturalState η J Z 2 = 1 ∧
0 < normalizedEventRate projectiveActiveWall x 0 T
count : Nat.floor (X 0 / 2) = m + 1
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Set Filter
open scoped Topology
def WallProductDecay (x : NormalizedState) : Prop :=
∀ i j : Fin 3, i ≠ j → Tendsto
(fun t => wallValue i (normalizedMaxCurve x 0 t) * wallValue j (normalizedMaxCurve x 0 t))
atTop (𝓝 0)
end BianchiIX
end
end
section
noncomputable section
namespace BianchiIX
open Filter
open scoped Topology
/-- Brehm's delta for the complementary wall pair. -/
def brehmPairDelta (x : NormalizedState) (i j : Fin 3) : ℝ :=
2 * Real.sqrt |wallValue i x * wallValue j x|
/-- The delta-decay consequence of Brehm's Section 6 local and Bianchi IX global
attractor theorems (2016, arXiv:1606.08058). The source uses the same coordinates
and singularity-directed time as `normalizedField`; see its unpacked
Wainwright-Hsu equations and the definitions of the Taub spaces in Section 2.
For positive walls, the excluded spaces are exactly `taubSubspaces`.
This proposition is an explicit literature parameter, not a project axiom.
It asserts no era coding, statistical conclusion, or transverse nullity. -/
def Literature.BrehmIXAttractorInput : Prop :=
∀ x : NormalizedState, x ∈ physicalPhaseSpace → x ∉ taubSubspaces →
∀ i j : Fin 3, i ≠ j → Tendsto
(fun t => brehmPairDelta (normalizedMaxCurve x 0 t) i j) atTop (𝓝 0)
end BianchiIX
end
end