Exact field bookkeeping for one correction cycle

The residuals in this file are the differentiated nonlinear fields in (32). In particular, changing the wave covariance and changing a mean velocity are not treated as independent black-box state transitions. Every old/new cross term is retained in the displayed residual differences.

@[reducible, inline]

abbrev NavierStokes.CorrectionStep.ScalarField (D : Type) : Type

Scalar field: an abbreviation for MeanIncrementBounds.Field D.

Equations

• NavierStokes.CorrectionStep.ScalarField D = NavierStokes.MeanIncrementBounds.Field D

@[reducible, inline]

abbrev NavierStokes.CorrectionStep.Tensor (D : Type) : Type

Tensor: an abbreviation for Fin 3 → Fin 3 → ScalarField D.

Equations

• NavierStokes.CorrectionStep.Tensor D = (Fin 3 → Fin 3 → NavierStokes.CorrectionStep.ScalarField D)

noncomputable def NavierStokes.CorrectionStep.thetaCovarianceChange {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (o : MeanIncrementBounds.Operators D) (X : Tensor D) : ScalarField D

These are changes of the literal covariance terms in (32).

Equations

• NavierStokes.CorrectionStep.thetaCovarianceChange o X = o.radialDiv 2 (X 0 1) + o.dz (X 2 1)

noncomputable def NavierStokes.CorrectionStep.axialCovarianceChange {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (o : MeanIncrementBounds.Operators D) (X : Tensor D) : ScalarField D

Axial covariance change, given by o.radialDiv 1 (X 0 2) + o.dz (X 2 2).

Equations

• NavierStokes.CorrectionStep.axialCovarianceChange o X = o.radialDiv 1 (X 0 2) + o.dz (X 2 2)

noncomputable def NavierStokes.CorrectionStep.radialCovarianceChange {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (o : MeanIncrementBounds.Operators D) (X : Tensor D) : ScalarField D

Radial covariance change, given by -o.radialDiv 1 (X 0 0) - o.dz (X 2 0) + o.invRadius * X 1 1.

Equations

• NavierStokes.CorrectionStep.radialCovarianceChange o X = -o.radialDiv 1 (X 0 0) - o.dz (X 2 0) + o.invRadius * X 1 1

theorem NavierStokes.CorrectionStep.smooth_updated {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} {m h : MeanIncrementBounds.Triple D} (hm : MeanIncrementBounds.SmoothTriple U m) (hh : MeanIncrementBounds.SmoothTriple U h) : MeanIncrementBounds.SmoothTriple U (MeanIncrementBounds.updated m h)

theorem NavierStokes.CorrectionStep.thetaResidual_covariance_change {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} (hU : IsOpen U) (o : MeanIncrementBounds.Operators D) {b m : MeanIncrementBounds.Triple D} (hb : MeanIncrementBounds.SmoothTriple U b) (hm : MeanIncrementBounds.SmoothTriple U m) (W X : Tensor D) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (W i j)) (hX : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (X i j)) (T : ScalarField D) : MeanIncrementBounds.Agree U (MeanIncrementBounds.thetaResidual o b m (W + X) T - MeanIncrementBounds.thetaResidual o b m W T) (thetaCovarianceChange o X)

theorem NavierStokes.CorrectionStep.axialResidual_covariance_change {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} (hU : IsOpen U) (o : MeanIncrementBounds.Operators D) {b m : MeanIncrementBounds.Triple D} (hb : MeanIncrementBounds.SmoothTriple U b) (hm : MeanIncrementBounds.SmoothTriple U m) (W X : Tensor D) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (W i j)) (hX : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (X i j)) (p T : ScalarField D) (hp : MeanIncrementBounds.SmoothOn U p) : MeanIncrementBounds.Agree U (MeanIncrementBounds.axialResidual o b m (W + X) p T - MeanIncrementBounds.axialResidual o b m W p T) (axialCovarianceChange o X)

theorem NavierStokes.CorrectionStep.gr_covariance_change {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} (hU : IsOpen U) (o : MeanIncrementBounds.Operators D) {b m : MeanIncrementBounds.Triple D} (hb : MeanIncrementBounds.SmoothTriple U b) (hm : MeanIncrementBounds.SmoothTriple U m) (W X : Tensor D) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (W i j)) (hX : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (X i j)) : MeanIncrementBounds.Agree U (MeanIncrementBounds.gr o b m (W + X) - MeanIncrementBounds.gr o b m W) (radialCovarianceChange o X)

theorem NavierStokes.CorrectionStep.thetaResidual_joint_change {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} (hU : IsOpen U) (o : MeanIncrementBounds.Operators D) (ha : ContDiffOn ℝ (↑⊤) o.radialProfile U) {b m h : MeanIncrementBounds.Triple D} (hb : MeanIncrementBounds.SmoothTriple U b) (hm : MeanIncrementBounds.SmoothTriple U m) (hh : MeanIncrementBounds.SmoothTriple U h) (W X : Tensor D) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (W i j)) (hX : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (X i j)) (T : ScalarField D) : MeanIncrementBounds.Agree U (MeanIncrementBounds.thetaResidual o b (MeanIncrementBounds.updated m h) (W + X) T - MeanIncrementBounds.thetaResidual o b m W T) (o.fastTime h.angular + MeanIncrementBounds.thetaRemainder o b m h + thetaCovarianceChange o X)

theorem NavierStokes.CorrectionStep.axialResidual_joint_change {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} (hU : IsOpen U) (o : MeanIncrementBounds.Operators D) (ha : ContDiffOn ℝ (↑⊤) o.radialProfile U) {b m h : MeanIncrementBounds.Triple D} (hb : MeanIncrementBounds.SmoothTriple U b) (hm : MeanIncrementBounds.SmoothTriple U m) (hh : MeanIncrementBounds.SmoothTriple U h) (W X : Tensor D) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (W i j)) (hX : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (X i j)) (p δp T : ScalarField D) (hp : MeanIncrementBounds.SmoothOn U p) (hδp : MeanIncrementBounds.SmoothOn U δp) : MeanIncrementBounds.Agree U (MeanIncrementBounds.axialResidual o b (MeanIncrementBounds.updated m h) (W + X) (p + δp) T - MeanIncrementBounds.axialResidual o b m W p T) (o.fastTime h.axial + MeanIncrementBounds.axialRemainder o b m h δp + axialCovarianceChange o X)

theorem NavierStokes.CorrectionStep.gr_joint_change {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} (hU : IsOpen U) (o : MeanIncrementBounds.Operators D) (ha : ContDiffOn ℝ (↑⊤) o.radialProfile U) {b m h : MeanIncrementBounds.Triple D} (hb : MeanIncrementBounds.SmoothTriple U b) (hm : MeanIncrementBounds.SmoothTriple U m) (hh : MeanIncrementBounds.SmoothTriple U h) (W X : Tensor D) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (W i j)) (hX : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (X i j)) : MeanIncrementBounds.Agree U (MeanIncrementBounds.gr o b (MeanIncrementBounds.updated m h) (W + X) - MeanIncrementBounds.gr o b m W) (MeanIncrementBounds.leadingRadial o b h + MeanIncrementBounds.radialRemainder o b m h + radialCovarianceChange o X)

def NavierStokes.CorrectionStep.TensorClass {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (s : WeightedClasses.StripData D) (α : ℝ) (X : Tensor D) : Prop

A bound on each actual tensor entry. It is not a bound on the resulting residual and contains no update-preservation assertion.

Equations

• NavierStokes.CorrectionStep.TensorClass s α X = ∀ (i j : Fin 3), NavierStokes.WeightedClasses.MeanClass s α (X i j)

theorem NavierStokes.CorrectionStep.thetaCovarianceChange_mem {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {o : MeanIncrementBounds.Operators D} {κ α : ℝ} (ho : MeanIncrementBounds.OperatorBounds s o κ) {X : Tensor D} (hX : TensorClass s α X) : WeightedClasses.MeanClass s (α - κ) (thetaCovarianceChange o X)

theorem NavierStokes.CorrectionStep.axialCovarianceChange_mem {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {o : MeanIncrementBounds.Operators D} {κ α : ℝ} (ho : MeanIncrementBounds.OperatorBounds s o κ) {X : Tensor D} (hX : TensorClass s α X) : WeightedClasses.MeanClass s (α - κ) (axialCovarianceChange o X)

theorem NavierStokes.CorrectionStep.radialCovarianceChange_mem {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {o : MeanIncrementBounds.Operators D} {κ α : ℝ} (ho : MeanIncrementBounds.OperatorBounds s o κ) {X : Tensor D} (hX : TensorClass s α X) : WeightedClasses.MeanClass s (α - κ) (radialCovarianceChange o X)

The full differential residual, before angular averaging

theorem NavierStokes.CorrectionStep.angularGenerator_add (a b : HarmonicCalculus.ComplexVector) : HarmonicCalculus.angularGenerator (a + b) = HarmonicCalculus.angularGenerator a + HarmonicCalculus.angularGenerator b

theorem NavierStokes.CorrectionStep.transport_add_left {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (R : D → ℝ) (Vr Vθ Vz : D → D) (a b v : D → HarmonicCalculus.ComplexVector) (x : D) : LinearWaveResidual.transport R Vr Vθ Vz (a + b) v x = LinearWaveResidual.transport R Vr Vθ Vz a v x + LinearWaveResidual.transport R Vr Vθ Vz b v x

theorem NavierStokes.CorrectionStep.transport_add_right {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (R : D → ℝ) (Vr Vθ Vz : D → D) (u a b : D → HarmonicCalculus.ComplexVector) {x : D} (ha : ∀ (i : Fin 3), DifferentiableAt ℝ (fun (y : D) => a y i) x) (hb : ∀ (i : Fin 3), DifferentiableAt ℝ (fun (y : D) => b y i) x) : LinearWaveResidual.transport R Vr Vθ Vz u (a + b) x = LinearWaveResidual.transport R Vr Vθ Vz u a x + LinearWaveResidual.transport R Vr Vθ Vz u b x

theorem NavierStokes.CorrectionStep.twiceAlong_add {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} (hU : IsOpen U) {V : D → D} (hV : ContDiffOn ℝ (↑⊤) V U) {f g : D → ℂ} (hf : ContDiffOn ℝ (↑⊤) f U) (hg : ContDiffOn ℝ (↑⊤) g U) {x : D} (hx : x ∈ U) : HarmonicCalculus.along V (HarmonicCalculus.along V (f + g)) x = HarmonicCalculus.along V (HarmonicCalculus.along V f) x + HarmonicCalculus.along V (HarmonicCalculus.along V g) x

theorem NavierStokes.CorrectionStep.cylindricalLaplacian_add {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} (hU : IsOpen U) (R : D → ℝ) {Vr Vθ Vz : D → D} (hr : ContDiffOn ℝ (↑⊤) Vr U) (hθ : ContDiffOn ℝ (↑⊤) Vθ U) (hz : ContDiffOn ℝ (↑⊤) Vz U) {f g : D → ℂ} (hf : ContDiffOn ℝ (↑⊤) f U) (hg : ContDiffOn ℝ (↑⊤) g U) {x : D} (hx : x ∈ U) : HarmonicCalculus.cylindricalLaplacian R Vr Vθ Vz (f + g) x = HarmonicCalculus.cylindricalLaplacian R Vr Vθ Vz f x + HarmonicCalculus.cylindricalLaplacian R Vr Vθ Vz g x

theorem NavierStokes.CorrectionStep.cylindricalVectorLaplacian_add {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} (hU : IsOpen U) (R : D → ℝ) {Vr Vθ Vz : D → D} (hr : ContDiffOn ℝ (↑⊤) Vr U) (hθ : ContDiffOn ℝ (↑⊤) Vθ U) (hz : ContDiffOn ℝ (↑⊤) Vz U) {a b : D → HarmonicCalculus.ComplexVector} (ha : ∀ (i : Fin 3), ContDiffOn ℝ (↑⊤) (fun (y : D) => a y i) U) (hb : ∀ (i : Fin 3), ContDiffOn ℝ (↑⊤) (fun (y : D) => b y i) U) {x : D} (hx : x ∈ U) : HarmonicCalculus.cylindricalVectorLaplacian R Vr Vθ Vz (a + b) x = HarmonicCalculus.cylindricalVectorLaplacian R Vr Vθ Vz a x + HarmonicCalculus.cylindricalVectorLaplacian R Vr Vθ Vz b x

theorem NavierStokes.CorrectionStep.gradient_add {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (R : D → ℝ) (Vr Vθ Vz : D → D) {p q : D → ℂ} {x : D} (hp : DifferentiableAt ℝ p x) (hq : DifferentiableAt ℝ q x) : LinearWaveResidual.gradient R Vr Vθ Vz (p + q) x = LinearWaveResidual.gradient R Vr Vθ Vz p x + LinearWaveResidual.gradient R Vr Vθ Vz q x

theorem NavierStokes.CorrectionStep.linearResidual_add {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} (hU : IsOpen U) (ε : ℝ) (R : D → ℝ) {Vr Vθ Vz : D → D} (Vt : D → D) (hr : ContDiffOn ℝ (↑⊤) Vr U) (hθ : ContDiffOn ℝ (↑⊤) Vθ U) (hz : ContDiffOn ℝ (↑⊤) Vz U) (B a b : D → HarmonicCalculus.ComplexVector) (p q : D → ℂ) (ha : ∀ (i : Fin 3), ContDiffOn ℝ (↑⊤) (fun (y : D) => a y i) U) (hb : ∀ (i : Fin 3), ContDiffOn ℝ (↑⊤) (fun (y : D) => b y i) U) (hp : ContDiffOn ℝ (↑⊤) p U) (hq : ContDiffOn ℝ (↑⊤) q U) {x : D} (hx : x ∈ U) : LinearWaveResidual.linearResidual ε R Vr Vθ Vz Vt B (a + b) (p + q) x = LinearWaveResidual.linearResidual ε R Vr Vθ Vz Vt B a p x + LinearWaveResidual.linearResidual ε R Vr Vθ Vz Vt B b q x

noncomputable def NavierStokes.CorrectionStep.nonlinearResidual {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (ε : ℝ) (R : D → ℝ) (Vr Vθ Vz Vt : D → D) (B a : D → HarmonicCalculus.ComplexVector) (p : D → ℂ) (x : D) : HarmonicCalculus.ComplexVector

Exact residual of a perturbation of a fixed base, before the virtual stress and the separately retained base residual are added.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.nonlinearResidual_add_sub {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} (hU : IsOpen U) (ε : ℝ) (R : D → ℝ) {Vr Vθ Vz : D → D} (Vt : D → D) (hr : ContDiffOn ℝ (↑⊤) Vr U) (hθ : ContDiffOn ℝ (↑⊤) Vθ U) (hz : ContDiffOn ℝ (↑⊤) Vz U) (B a b : D → HarmonicCalculus.ComplexVector) (p q : D → ℂ) (ha : ∀ (i : Fin 3), ContDiffOn ℝ (↑⊤) (fun (y : D) => a y i) U) (hb : ∀ (i : Fin 3), ContDiffOn ℝ (↑⊤) (fun (y : D) => b y i) U) (hp : ContDiffOn ℝ (↑⊤) p U) (hq : ContDiffOn ℝ (↑⊤) q U) {x : D} (hx : x ∈ U) : nonlinearResidual ε R Vr Vθ Vz Vt B (a + b) (p + q) x - nonlinearResidual ε R Vr Vθ Vz Vt B a p x = LinearWaveResidual.linearResidual ε R Vr Vθ Vz Vt B b q x + LinearWaveResidual.transport R Vr Vθ Vz a b x + LinearWaveResidual.transport R Vr Vθ Vz b a x + LinearWaveResidual.transport R Vr Vθ Vz b b x

noncomputable def NavierStokes.CorrectionStep.radialDirection {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (n : ℕ) (x : D × ℝ) : D × ℝ

Radial direction, given by (c.operators.eR + (c.operators.radialFrequency n * c.operators.radialProfile x.1) • c.operators.vR, 0).

Equations

• NavierStokes.CorrectionStep.radialDirection c n x = (c.operators.eR + (c.operators.radialFrequency n * c.operators.radialProfile x.1) • c.operators.vR, 0)

noncomputable def NavierStokes.CorrectionStep.axialDirection {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (n : ℕ) (_x : D × ℝ) : D × ℝ

Axial direction, given by (c.operators.epsilon n • c.operators.eZ, 0).

Equations

• NavierStokes.CorrectionStep.axialDirection c n _x = (c.operators.epsilon n • c.operators.eZ, 0)

noncomputable def NavierStokes.CorrectionStep.angularDirection {D : Type} [NormedAddCommGroup D] (_x : D × ℝ) : D × ℝ

Angular direction, given by (0, 1).

Equations

• NavierStokes.CorrectionStep.angularDirection _x = (0, 1)

noncomputable def NavierStokes.CorrectionStep.timeDirection {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (n : ℕ) (_x : D × ℝ) : D × ℝ

Time direction, given by (c.operators.fastCoefficient n • c.operators.vT - c.operators.epsilon n • c.operators.eT, 0).

Equations

• NavierStokes.CorrectionStep.timeDirection c n _x = (c.operators.fastCoefficient n • c.operators.vT - c.operators.epsilon n • c.operators.eT, 0)

noncomputable def NavierStokes.CorrectionStep.complexBase {D : Type} (c : CorrectionState.Context D) (n : ℕ) (x : D × ℝ) : HarmonicCalculus.ComplexVector

Complex base, given by ![(c.base.radial n x.1 : ℂ), (c.base.angular n x.1 : ℂ), (c.base.axial n x.1 : ℂ)].

Equations

• NavierStokes.CorrectionStep.complexBase c n x = ![↑(c.base.radial n x.1), ↑(c.base.angular n x.1), ↑(c.base.axial n x.1)]

noncomputable def NavierStokes.CorrectionStep.complexPerturbation {D : Type} (u : CorrectionState.State D) (n : ℕ) (x : D × ℝ) : HarmonicCalculus.ComplexVector

Complex perturbation as an element of ComplexVector.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.complexPressure {D : Type} (u : CorrectionState.State D) (n : ℕ) (x : D × ℝ) : ℂ

Complex pressure, given by (u.totalPressureIncrement n x : ℝ).

Equations

• NavierStokes.CorrectionStep.complexPressure u n x = ↑(u.totalPressureIncrement n x)

noncomputable def NavierStokes.CorrectionStep.virtualDivergence {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (n : ℕ) (x : D × ℝ) : Fin 3 → ℝ

Virtual divergence, given by ![0, -(c.operators.radialDiv 2 c.virtualTheta n x.1), -(c.operators.radialDiv 1 c.virtualAxial n x.1)].

Equations

• NavierStokes.CorrectionStep.virtualDivergence c n x = ![0, -c.operators.radialDiv 2 c.virtualTheta n x.1, -c.operators.radialDiv 1 c.virtualAxial n x.1]

noncomputable def NavierStokes.CorrectionStep.fullResidual {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (u : CorrectionState.State D) : CorrectionState.Oscillation D

This field uses actual Fréchet derivatives. The base flat error is restored once, alongside the negative virtual-stress divergence.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.fullGoodResidual {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (u : CorrectionState.State D) : CorrectionState.Oscillation D

Full good residual, given by fullResidual c u - u.errors.total.

Equations

• NavierStokes.CorrectionStep.fullGoodResidual c u = NavierStokes.CorrectionStep.fullResidual c u - u.errors.total

noncomputable def NavierStokes.CorrectionStep.angularMeanVector {D : Type} (f : CorrectionState.Oscillation D) : CorrectionState.MeanVector D

Angular mean vector, defined pointwise by angularAverage (fun k p => f k p i) n x.

Equations

• NavierStokes.CorrectionStep.angularMeanVector f n x i = NavierStokes.CorrectionState.angularAverage (fun (k : ℕ) (p : D × ℝ) => f k p i) n x

noncomputable def NavierStokes.CorrectionStep.angularNonconstant {D : Type} (f : CorrectionState.Oscillation D) : CorrectionState.Oscillation D

Angular nonconstant, defined pointwise by f n x i - angularMeanVector f n x.1 i.

Equations

• NavierStokes.CorrectionStep.angularNonconstant f n x i = f n x i - NavierStokes.CorrectionStep.angularMeanVector f n x.1 i

noncomputable def NavierStokes.CorrectionStep.fullGoodWaveResidual {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (u : CorrectionState.State D) : CorrectionState.Oscillation D

Full good wave residual, given by angularNonconstant (fullGoodResidual c u).

Equations

• NavierStokes.CorrectionStep.fullGoodWaveResidual c u = NavierStokes.CorrectionStep.angularNonconstant (NavierStokes.CorrectionStep.fullGoodResidual c u)

theorem NavierStokes.CorrectionStep.fullResidual_eq_good_add_excluded {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (u : CorrectionState.State D) : fullResidual c u = fullGoodResidual c u + u.errors.total

theorem NavierStokes.CorrectionStep.fullResidual_decomposition {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (u : CorrectionState.State D) : fullResidual c u = fun (n : ℕ) (x : D × ℝ) (i : Fin 3) => fullGoodWaveResidual c u n x i + angularMeanVector (fullGoodResidual c u) n x.1 i + u.errors.total n x i

def NavierStokes.CorrectionStep.AngularContinuous {D : Type} (u : CorrectionState.Oscillation D) : Prop

Angular continuous, given by ∀ n x i, Continuous (fun θ : ℝ => u n (x, θ) i).

Equations

• NavierStokes.CorrectionStep.AngularContinuous u = ∀ (n : ℕ) (x : D) (i : Fin 3), Continuous fun (θ : ℝ) => u n (x, θ) i

theorem NavierStokes.CorrectionStep.AngularContinuous.add {D : Type} {u v : CorrectionState.Oscillation D} (hu : AngularContinuous u) (hv : AngularContinuous v) : AngularContinuous (u + v)

theorem NavierStokes.CorrectionStep.bilinearCovariance_add_left {D : Type} {u v w : CorrectionState.Oscillation D} (hu : AngularContinuous u) (hv : AngularContinuous v) (hw : AngularContinuous w) : CorrectionState.bilinearCovariance (u + v) w = CorrectionState.bilinearCovariance u w + CorrectionState.bilinearCovariance v w

theorem NavierStokes.CorrectionStep.bilinearCovariance_add_right {D : Type} {u v w : CorrectionState.Oscillation D} (hu : AngularContinuous u) (hv : AngularContinuous v) (hw : AngularContinuous w) : CorrectionState.bilinearCovariance u (v + w) = CorrectionState.bilinearCovariance u v + CorrectionState.bilinearCovariance u w

noncomputable def NavierStokes.CorrectionStep.covarianceIncrement {D : Type} (u v : CorrectionState.Oscillation D) : Tensor D

The actual covariance increment contains both cross terms and the entire square of the exact increment.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.covariance_add {D : Type} {u v : CorrectionState.Oscillation D} (hu : AngularContinuous u) (hv : AngularContinuous v) : CorrectionState.bilinearCovariance (u + v) (u + v) = CorrectionState.bilinearCovariance u u + covarianceIncrement u v

theorem NavierStokes.CorrectionStep.covariance_actual_update {D : Type} (s : CorrectionState.State D) (m : MeanIncrementBounds.Triple D) (p : ScalarField D) (v : CorrectionState.Oscillation D) (q : CorrectionState.OscillatoryScalar D) (e : CorrectionState.ExcludedErrors D) (hu : AngularContinuous s.oscillation) (hv : AngularContinuous v) : (s.addIncrement m p v q e).covariance = s.covariance + covarianceIncrement s.oscillation v

noncomputable def NavierStokes.CorrectionStep.complexIncrement {D : Type} (m : MeanIncrementBounds.Triple D) (v : CorrectionState.Oscillation D) (n : ℕ) (x : D × ℝ) : HarmonicCalculus.ComplexVector

Complex increment, given by ![(m.radial n x.1 + v n x 0 : ℝ), (m.angular n x.1 + v n x 1 : ℝ), (m.axial n x.1 + v n x 2 : ℝ)].

Equations

• NavierStokes.CorrectionStep.complexIncrement m v n x = ![↑(m.radial n x.1 + v n x 0), ↑(m.angular n x.1 + v n x 1), ↑(m.axial n x.1 + v n x 2)]

noncomputable def NavierStokes.CorrectionStep.complexPressureIncrement {D : Type} (p : ScalarField D) (q : CorrectionState.OscillatoryScalar D) (n : ℕ) (x : D × ℝ) : ℂ

Complex pressure increment, given by (p n x.1 + q n x : ℝ).

Equations

• NavierStokes.CorrectionStep.complexPressureIncrement p q n x = ↑(p n x.1 + q n x)

theorem NavierStokes.CorrectionStep.complexPerturbation_actual_update {D : Type} (s : CorrectionState.State D) (m : MeanIncrementBounds.Triple D) (p : ScalarField D) (v : CorrectionState.Oscillation D) (q : CorrectionState.OscillatoryScalar D) (e : CorrectionState.ExcludedErrors D) (n : ℕ) : complexPerturbation (s.addIncrement m p v q e) n = complexPerturbation s n + complexIncrement m v n

theorem NavierStokes.CorrectionStep.complexPressure_actual_update {D : Type} (s : CorrectionState.State D) (m : MeanIncrementBounds.Triple D) (p : ScalarField D) (v : CorrectionState.Oscillation D) (q : CorrectionState.OscillatoryScalar D) (e : CorrectionState.ExcludedErrors D) (n : ℕ) : complexPressure (s.addIncrement m p v q e) n = complexPressure s n + complexPressureIncrement p q n

noncomputable def NavierStokes.CorrectionStep.fullDifferentialIncrement {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (s : CorrectionState.State D) (m : MeanIncrementBounds.Triple D) (p : ScalarField D) (v : CorrectionState.Oscillation D) (q : CorrectionState.OscillatoryScalar D) : ℕ → D × ℝ → HarmonicCalculus.ComplexVector

The differential increment uses the old exact perturbation in both cross terms. The stored excluded residual is not multiplied into the PDE.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.fullResidual_actual_update {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set (D × ℝ)} (hU : IsOpen U) (c : CorrectionState.Context D) (s : CorrectionState.State D) (m : MeanIncrementBounds.Triple D) (p : ScalarField D) (v : CorrectionState.Oscillation D) (q : CorrectionState.OscillatoryScalar D) (e : CorrectionState.ExcludedErrors D) (n : ℕ) (hr : ContDiffOn ℝ (↑⊤) (radialDirection c n) U) (ha : ∀ (i : Fin 3), ContDiffOn ℝ (↑⊤) (fun (x : D × ℝ) => complexPerturbation s n x i) U) (hb : ∀ (i : Fin 3), ContDiffOn ℝ (↑⊤) (fun (x : D × ℝ) => complexIncrement m v n x i) U) (hp : ContDiffOn ℝ (↑⊤) (complexPressure s n) U) (hq : ContDiffOn ℝ (↑⊤) (complexPressureIncrement p q n) U) {x : D × ℝ} (hx : x ∈ U) (i : Fin 3) : fullResidual c (s.addIncrement m p v q e) n x i - fullResidual c s n x i = (fullDifferentialIncrement c s m p v q n x i).re + e.base n x i

theorem NavierStokes.CorrectionStep.fullGoodResidual_actual_update {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set (D × ℝ)} (hU : IsOpen U) (c : CorrectionState.Context D) (s : CorrectionState.State D) (m : MeanIncrementBounds.Triple D) (p : ScalarField D) (v : CorrectionState.Oscillation D) (q : CorrectionState.OscillatoryScalar D) (e : CorrectionState.ExcludedErrors D) (n : ℕ) (hr : ContDiffOn ℝ (↑⊤) (radialDirection c n) U) (ha : ∀ (i : Fin 3), ContDiffOn ℝ (↑⊤) (fun (x : D × ℝ) => complexPerturbation s n x i) U) (hb : ∀ (i : Fin 3), ContDiffOn ℝ (↑⊤) (fun (x : D × ℝ) => complexIncrement m v n x i) U) (hp : ContDiffOn ℝ (↑⊤) (complexPressure s n) U) (hq : ContDiffOn ℝ (↑⊤) (complexPressureIncrement p q n) U) {x : D × ℝ} (hx : x ∈ U) (i : Fin 3) : fullGoodResidual c (s.addIncrement m p v q e) n x i - fullGoodResidual c s n x i = (fullDifferentialIncrement c s m p v q n x i).re - e.gaussian n x i - e.aliasError n x i

noncomputable def NavierStokes.CorrectionStep.meanBar {S : Type} (f : ScalarField (PressureStream.Lift S)) : ScalarField (PressureStream.Lift S)

Mean bar, defined pointwise by PressureStream.torusAverage (f n) (x.1, x.2.1).

Equations

• NavierStokes.CorrectionStep.meanBar f n x = NavierStokes.PressureStream.torusAverage (f n) (x.1, x.2.1)

noncomputable def NavierStokes.CorrectionStep.temporalPressureChange {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (r : CorrectionState.ReconstructionData) (h : ℝ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) : ScalarField (PressureStream.Lift S)

Temporal pressure change, given by (temporalStage r h axial c u).pressure - u.pressure.

Equations

• NavierStokes.CorrectionStep.temporalPressureChange r h axial c u = (NavierStokes.CorrectionState.temporalStage r h axial c u).pressure - u.pressure

theorem NavierStokes.CorrectionStep.temporalIncrement_smooth {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] (r : CorrectionState.ReconstructionData) (h : ℝ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (U : Set (PressureStream.Lift S)) (ha : 0 < r.inner) (hd : 0 < r.exponent) (hθ : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.thetaResidual c n)) (hz : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.axialResidual c n)) (hpθ : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.axialResidual c n)) (hsz : ∀ (n : ℕ), RadialAlias.RadiallySupported r.inner r.outer (u.axialResidual c n)) : MeanIncrementBounds.SmoothTriple U (CorrectionState.temporalIncrement r h axial c u)

theorem NavierStokes.CorrectionStep.temporalStage_theta_exact {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] {U : Set (PressureStream.Lift S)} (hU : IsOpen U) (r : CorrectionState.ReconstructionData) (h : ℝ) (axial slow : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (ha : 0 < r.inner) (hd : 0 < r.exponent) (hcompat : c.operators = CorrectionState.graphOperators r c.operators.epsilon (ChartScales.timeCoefficient h) axial slow (TorusInverse.vector TorusInverse.Direction.temporal)) (hprofile : ContDiffOn ℝ (↑⊤) c.operators.radialProfile U) (hb : MeanIncrementBounds.SmoothTriple U c.base) (hm : MeanIncrementBounds.SmoothTriple U u.mean) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (u.covariance i j)) (hθ : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.thetaResidual c n)) (hz : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.axialResidual c n)) (hpθ : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.axialResidual c n)) (hsz : ∀ (n : ℕ), RadialAlias.RadiallySupported r.inner r.outer (u.axialResidual c n)) : MeanIncrementBounds.Agree U ((CorrectionState.temporalStage r h axial c u).thetaResidual c) (meanBar (u.thetaResidual c) + MeanIncrementBounds.thetaRemainder c.operators c.base u.mean (CorrectionState.temporalIncrement r h axial c u))

theorem NavierStokes.CorrectionStep.temporalStage_axial_exact {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] {U : Set (PressureStream.Lift S)} (hU : IsOpen U) (r : CorrectionState.ReconstructionData) (h : ℝ) (axial slow : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (ha : 0 < r.inner) (hd : 0 < r.exponent) (hcompat : c.operators = CorrectionState.graphOperators r c.operators.epsilon (ChartScales.timeCoefficient h) axial slow (TorusInverse.vector TorusInverse.Direction.temporal)) (hprofile : ContDiffOn ℝ (↑⊤) c.operators.radialProfile U) (hb : MeanIncrementBounds.SmoothTriple U c.base) (hm : MeanIncrementBounds.SmoothTriple U u.mean) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (u.covariance i j)) (hp : MeanIncrementBounds.SmoothOn U u.pressure) (hnp : MeanIncrementBounds.SmoothOn U (CorrectionState.temporalStage r h axial c u).pressure) (hθ : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.thetaResidual c n)) (hz : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.axialResidual c n)) (hpθ : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.axialResidual c n)) (hsz : ∀ (n : ℕ), RadialAlias.RadiallySupported r.inner r.outer (u.axialResidual c n)) : MeanIncrementBounds.Agree U (fun (n : ℕ) (x : PressureStream.Lift S) => (CorrectionState.temporalStage r h axial c u).axialResidual c n x - CorrectionState.temporalAlias r h c u n (x, 0) 2) (meanBar (u.axialResidual c) + MeanIncrementBounds.axialRemainder c.operators c.base u.mean (CorrectionState.temporalIncrement r h axial c u) (temporalPressureChange r h axial c u))

theorem NavierStokes.CorrectionStep.temporalIncrement_mem {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] (r : CorrectionState.ReconstructionData) (h : ℝ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) {cL cR H : ℝ} (ha : 0 < r.inner) (hd : 0 < r.exponent) (hcL : 0 < cL) (hcR : 0 < cR) (hh : 0 ≤ h) (L : ℕ → ℝ) (hε : ∀ (n : ℕ), 0 < c.operators.epsilon n) (hεone : ∀ (n : ℕ), c.operators.epsilon n ≤ 1) (hL : ∀ (n : ℕ), 1 ≤ L n) (hscale : ∀ (n : ℕ), ChartScales.S n ≤ L n) (hM : ∀ (n : ℕ), r.frequency n ≠ 0) (hvr : r.radialDirection = TorusInverse.vector TorusInverse.Direction.radial) (hθclass : WeightedClasses.MeanClass (WeightedRadialPrimitive.logStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) H (u.thetaResidual c)) (hzclass : WeightedClasses.MeanClass (WeightedRadialPrimitive.logStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) H (u.axialResidual c)) (hθ : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.thetaResidual c n)) (hz : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.axialResidual c n)) (hpθ : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.axialResidual c n)) (hsz : ∀ (n : ℕ), RadialAlias.RadiallySupported r.inner r.outer (u.axialResidual c n)) : MeanIncrementBounds.IncrementBounds (WeightedRadialPrimitive.logStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) H (CorrectionState.temporalIncrement r h axial c u)

The increment bound is proved for the actual inverse and stream, from the current residual classes. No increment or updated-residual class is assumed. The inverse-direction hypothesis is the concrete graph direction.

theorem NavierStokes.CorrectionStep.temporalStage_theta_mem {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] (r : CorrectionState.ReconstructionData) (h : ℝ) (axial slow : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) {cL cR H κ β : ℝ} (ha : 0 < r.inner) (hd : 0 < r.exponent) (hcL : 0 < cL) (hcR : 0 < cR) (hh : 0 ≤ h) (L : ℕ → ℝ) (hε : ∀ (n : ℕ), 0 < c.operators.epsilon n) (hεone : ∀ (n : ℕ), c.operators.epsilon n ≤ 1) (hL : ∀ (n : ℕ), 1 ≤ L n) (hscale : ∀ (n : ℕ), ChartScales.S n ≤ L n) (hM : ∀ (n : ℕ), r.frequency n ≠ 0) (hvr : r.radialDirection = TorusInverse.vector TorusInverse.Direction.radial) (hcompat : c.operators = CorrectionState.graphOperators r c.operators.epsilon (ChartScales.timeCoefficient h) axial slow (TorusInverse.vector TorusInverse.Direction.temporal)) (ho : MeanIncrementBounds.OperatorBounds (WeightedRadialPrimitive.logStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) c.operators κ) (hb : MeanIncrementBounds.BaseBounds (WeightedRadialPrimitive.logStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) c.base) (hm : MeanIncrementBounds.CumulativeBounds (WeightedRadialPrimitive.logStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) u.mean) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn (WeightedRadialPrimitive.logStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL).domain (u.covariance i j)) (hθclass : WeightedClasses.MeanClass (WeightedRadialPrimitive.logStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) H (u.thetaResidual c)) (hzclass : WeightedClasses.MeanClass (WeightedRadialPrimitive.logStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) H (u.axialResidual c)) (hbar : WeightedClasses.MeanClass (WeightedRadialPrimitive.logStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) β (meanBar (u.thetaResidual c))) (hθ : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.thetaResidual c n)) (hz : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.axialResidual c n)) (hpθ : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.axialResidual c n)) (hsz : ∀ (n : ℕ), RadialAlias.RadiallySupported r.inner r.outer (u.axialResidual c n)) (hH : 9 / 10 ≤ H) (hβ : β ≤ H + 1 - 2 * κ) : WeightedClasses.MeanClass (WeightedRadialPrimitive.logStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) β ((CorrectionState.temporalStage r h axial c u).thetaResidual c)

An actual temporal stage preserves the improved bar exponent whenever that exponent is below its proved differentiated remainder exponent.

theorem NavierStokes.CorrectionStep.temporalStage_pressure_formula {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (r : CorrectionState.ReconstructionData) (h : ℝ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) : (CorrectionState.temporalStage r h axial c u).pressure = MeanIncrementBounds.reconstructedPressure r.exponent r.inner r.outer ⋯ r.frequency (fun (x : ℕ) => r.radialDirection) c.operators c.base (MeanIncrementBounds.updated u.mean (CorrectionState.temporalIncrement r h axial c u)) u.covariance

theorem NavierStokes.CorrectionStep.temporalPressureChange_mem {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (r : CorrectionState.ReconstructionData) (h : ℝ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) {cL cR H κ : ℝ} (ha : 0 < r.inner) (hd : 0 < r.exponent) (hcL : 0 < cL) (hcR : 0 < cR) (L : ℕ → ℝ) (hε : ∀ (n : ℕ), 0 < c.operators.epsilon n) (hεone : ∀ (n : ℕ), c.operators.epsilon n ≤ 1) (hL : ∀ (n : ℕ), 1 ≤ L n) (ho : MeanIncrementBounds.OperatorBounds (WeightedRadialPrimitive.logStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) c.operators κ) (hb : MeanIncrementBounds.BaseBounds (WeightedRadialPrimitive.logStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) c.base) (hm : MeanIncrementBounds.CumulativeBounds (WeightedRadialPrimitive.logStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) u.mean) (hi : MeanIncrementBounds.IncrementBounds (WeightedRadialPrimitive.logStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) H (CorrectionState.temporalIncrement r h axial c u)) (hH : 9 / 10 ≤ H) (hκ : 2 * κ ≤ 9 / 10) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn (WeightedRadialPrimitive.logStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL).domain (u.covariance i j)) (hf : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (MeanIncrementBounds.gr c.operators c.base (MeanIncrementBounds.updated u.mean (CorrectionState.temporalIncrement r h axial c u)) u.covariance n)) (hg : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.gr c n)) (hsf : ∀ (n : ℕ), RadialAlias.RadiallySupported r.inner r.outer (MeanIncrementBounds.gr c.operators c.base (MeanIncrementBounds.updated u.mean (CorrectionState.temporalIncrement r h axial c u)) u.covariance n)) (hsg : ∀ (n : ℕ), RadialAlias.RadiallySupported r.inner r.outer (u.gr c n)) (hpressure : u.pressure = (CorrectionState.reconstructPressure r c u).pressure) : WeightedClasses.MeanClass (WeightedRadialPrimitive.logStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) H (temporalPressureChange r h axial c u)

The pressure change is bounded by applying the actual compact inverse to the actual change of gr, whose centrifugal term is retained.

theorem NavierStokes.CorrectionStep.temporalStage_axial_mem {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] {s : WeightedClasses.StripData (PressureStream.Lift S)} (r : CorrectionState.ReconstructionData) (h : ℝ) (axial slow : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) {H κ β : ℝ} (ha : 0 < r.inner) (hd : 0 < r.exponent) (hcompat : c.operators = CorrectionState.graphOperators r c.operators.epsilon (ChartScales.timeCoefficient h) axial slow (TorusInverse.vector TorusInverse.Direction.temporal)) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hb : MeanIncrementBounds.BaseBounds s c.base) (hm : MeanIncrementBounds.CumulativeBounds s u.mean) (hi : MeanIncrementBounds.IncrementBounds s H (CorrectionState.temporalIncrement r h axial c u)) (hp : MeanIncrementBounds.SmoothOn s.domain u.pressure) (hdp : WeightedClasses.MeanClass s H (temporalPressureChange r h axial c u)) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn s.domain (u.covariance i j)) (hbar : WeightedClasses.MeanClass s β (meanBar (u.axialResidual c))) (hθ : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.thetaResidual c n)) (hz : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.axialResidual c n)) (hpθ : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.axialResidual c n)) (hsz : ∀ (n : ℕ), RadialAlias.RadiallySupported r.inner r.outer (u.axialResidual c n)) (hH : 9 / 10 ≤ H) (hβ : β ≤ H + 1 - 2 * κ) : WeightedClasses.MeanClass s β fun (n : ℕ) (x : PressureStream.Lift S) => (CorrectionState.temporalStage r h axial c u).axialResidual c n x - CorrectionState.temporalAlias r h c u n (x, 0) 2

The axial alias remains explicit in the conclusion. Its superflatness is handled separately; it is not erased from the constructed velocity.

theorem NavierStokes.CorrectionStep.temporalStage_cumulative {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {s : WeightedClasses.StripData (PressureStream.Lift S)} (r : CorrectionState.ReconstructionData) (h : ℝ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) {H : ℝ} (hu : CorrectionState.CumulativeBounds s u) (hi : MeanIncrementBounds.IncrementBounds s H (CorrectionState.temporalIncrement r h axial c u)) (hp : WeightedClasses.MeanClass s H (temporalPressureChange r h axial c u)) (hH : 9 / 10 ≤ H) : CorrectionState.CumulativeBounds s (CorrectionState.temporalStage r h axial c u)

One physical field behind the chart family

The predicate below is deliberately stronger than an indexed collection of unrelated chart solutions. Every chart is tied to the same physical fields by specified maps and the manuscript's velocity, pressure, and residual units. Operator naturality and the concrete chart maps are separate obligations.

structure NavierStokes.CorrectionStep.PhysicalFields (P : Type) : Type

Physical fields data, collecting mean, pressure, oscillation, oscillatoryPressure, baseError, gaussianError and their compatibility conditions.

• mean : P → Fin 3 → ℝ

  Mean field of PhysicalFields, of type P → Fin 3 → ℝ.

• pressure : P → ℝ

  Pressure field of PhysicalFields, of type P → ℝ.

• oscillation : P × ℝ → Fin 3 → ℝ

  Oscillation of PhysicalFields, of type P × ℝ → Fin 3 → ℝ.

• oscillatoryPressure : P × ℝ → ℝ

  Oscillatory pressure of PhysicalFields, of type P × ℝ → ℝ.

• baseError : P × ℝ → Fin 3 → ℝ

  Base error of PhysicalFields, of type P × ℝ → Fin 3 → ℝ.

• gaussianError : P × ℝ → Fin 3 → ℝ

  Gaussian error of PhysicalFields, of type P × ℝ → Fin 3 → ℝ.

• aliasError : P × ℝ → Fin 3 → ℝ

  Alias error of PhysicalFields, of type P × ℝ → Fin 3 → ℝ.

noncomputable def NavierStokes.CorrectionStep.PhysicalFields.add {P : Type} (u v : PhysicalFields P) : PhysicalFields P

Add, bundling mean, pressure, oscillation, oscillatoryPressure and the required compatibility proofs.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.meanComponents {D : Type} (m : MeanIncrementBounds.Triple D) (n : ℕ) (x : D) : Fin 3 → ℝ

Mean components, given by ![m.radial n x, m.angular n x, m.axial n x].

Equations

• NavierStokes.CorrectionStep.meanComponents m n x = ![m.radial n x, m.angular n x, m.axial n x]

theorem NavierStokes.CorrectionStep.meanComponents_updated {D : Type} (m h : MeanIncrementBounds.Triple D) (n : ℕ) (x : D) (i : Fin 3) : meanComponents (MeanIncrementBounds.updated m h) n x i = meanComponents m n x i + meanComponents h n x i

structure NavierStokes.CorrectionStep.RepresentsPhysical {D P : Type} (chart : ℕ → P → D) (domain : ℕ → Set P) (Q : ℕ → ℝ) (A : ℝ) (u : CorrectionState.State D) (v : PhysicalFields P) : Prop

chart includes the actual torus covering as well as spatial/time rescaling. domain n specifies where that band is active.

• mean (n : ℕ) (x : P) : x ∈ domain n → ∀ (i : Fin 3), meanComponents u.mean n (chart n x) i = Q n ^ A * v.mean x i
• pressure (n : ℕ) (x : P) : x ∈ domain n → u.pressure n (chart n x) = Q n ^ (2 * A) * v.pressure x
• oscillation (n : ℕ) (x : P) : x ∈ domain n → ∀ (θ : ℝ) (i : Fin 3), u.oscillation n (chart n x, θ) i = Q n ^ A * v.oscillation (x, θ) i
• oscillatoryPressure (n : ℕ) (x : P) : x ∈ domain n → ∀ (θ : ℝ), u.oscillatoryPressure n (chart n x, θ) = Q n ^ (2 * A) * v.oscillatoryPressure (x, θ)
• baseError (n : ℕ) (x : P) : x ∈ domain n → ∀ (θ : ℝ) (i : Fin 3), u.errors.base n (chart n x, θ) i = Q n ^ (2 * A + 1 / 2) * v.baseError (x, θ) i
• gaussianError (n : ℕ) (x : P) : x ∈ domain n → ∀ (θ : ℝ) (i : Fin 3), u.errors.gaussian n (chart n x, θ) i = Q n ^ (2 * A + 1 / 2) * v.gaussianError (x, θ) i
• aliasError (n : ℕ) (x : P) : x ∈ domain n → ∀ (θ : ℝ) (i : Fin 3), u.errors.aliasError n (chart n x, θ) i = Q n ^ (2 * A + 1 / 2) * v.aliasError (x, θ) i

theorem NavierStokes.CorrectionStep.RepresentsPhysical.addIncrement {D P : Type} {chart : ℕ → P → D} {domain : ℕ → Set P} {Q : ℕ → ℝ} {A : ℝ} {u : CorrectionState.State D} {v w : PhysicalFields P} (hu : RepresentsPhysical chart domain Q A u v) (m : MeanIncrementBounds.Triple D) (p : ScalarField D) (osc : CorrectionState.Oscillation D) (pr : CorrectionState.OscillatoryScalar D) (e : CorrectionState.ExcludedErrors D) (hw : RepresentsPhysical chart domain Q A { mean := m, pressure := p, oscillation := osc, oscillatoryPressure := pr, errors := e } w) : RepresentsPhysical chart domain Q A (u.addIncrement m p osc pr e) (v.add w)

Actual addition preserves the specified common physical realization. This does not manufacture a realization for a separately solved chart.

theorem NavierStokes.CorrectionStep.RepresentsPhysical.mean_overlap {D P : Type} {chart : ℕ → P → D} {domain : ℕ → Set P} {Q : ℕ → ℝ} {A : ℝ} {u : CorrectionState.State D} {v : PhysicalFields P} (hu : RepresentsPhysical chart domain Q A u v) (hQ : ∀ (n : ℕ), 0 < Q n) (n m : ℕ) (x : P) (hn : x ∈ domain n) (hm : x ∈ domain m) (i : Fin 3) : meanComponents u.mean n (chart n x) i / Q n ^ A = meanComponents u.mean m (chart m x) i / Q m ^ A

noncomputable def NavierStokes.CorrectionStep.rankPressureChange {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (p : CorrectionState.ReconstructionData) (r : CorrectionState.RankData S) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) : ScalarField (PressureStream.Lift S)

Rank pressure change, given by (rankStage p r axial c u).pressure - u.pressure.

Equations

• NavierStokes.CorrectionStep.rankPressureChange p r axial c u = (NavierStokes.CorrectionState.rankStage p r axial c u).pressure - u.pressure

theorem NavierStokes.CorrectionStep.slow_directional_zero {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {U : Set (PressureStream.Lift S)} (hU : IsOpen U) {f : ScalarField (PressureStream.Lift S)} (hf : MeanIncrementBounds.SmoothOn U f) (hslow : DefectIncrementBounds.IsSlow f) (v : PressureStream.Plane) (n : ℕ) {x : PressureStream.Lift S} (hx : x ∈ U) : (fderiv ℝ (f n) x) (0, 0, v) = 0

theorem NavierStokes.CorrectionStep.rankStage_theta_mem {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {s : WeightedClasses.StripData (PressureStream.Lift S)} (p : CorrectionState.ReconstructionData) (r : CorrectionState.RankData S) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) {H κ β : ℝ} (v : PressureStream.Plane) (hfast : c.operators.vT = (0, 0, v)) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hb : MeanIncrementBounds.BaseBounds s c.base) (hm : MeanIncrementBounds.CumulativeBounds s u.mean) (hi : MeanIncrementBounds.IncrementBounds s H (CorrectionState.rankIncrement p r axial c u)) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn s.domain (u.covariance i j)) (hcurrent : WeightedClasses.MeanClass s β (u.thetaResidual c)) (hH : 9 / 10 ≤ H) (hβ : β ≤ H + 1 - 2 * κ) : WeightedClasses.MeanClass s β ((CorrectionState.rankStage p r axial c u).thetaResidual c)

theorem NavierStokes.CorrectionStep.rankStage_axial_mem {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {s : WeightedClasses.StripData (PressureStream.Lift S)} (p : CorrectionState.ReconstructionData) (r : CorrectionState.RankData S) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (hg : DefectIncrementBounds.RankGeometry p r c u) {H κ β : ℝ} (v : PressureStream.Plane) (hfast : c.operators.vT = (0, 0, v)) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hb : MeanIncrementBounds.BaseBounds s c.base) (hm : MeanIncrementBounds.CumulativeBounds s u.mean) (hi : MeanIncrementBounds.IncrementBounds s H (CorrectionState.rankIncrement p r axial c u)) (hp : MeanIncrementBounds.SmoothOn s.domain u.pressure) (hdp : WeightedClasses.MeanClass s H (rankPressureChange p r axial c u)) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn s.domain (u.covariance i j)) (hcurrent : WeightedClasses.MeanClass s β (u.axialResidual c)) (hH : 9 / 10 ≤ H) (hβ : β ≤ H + 1 - 2 * κ) : WeightedClasses.MeanClass s β ((CorrectionState.rankStage p r axial c u).axialResidual c)

theorem NavierStokes.CorrectionStep.rankStage_cumulative {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {s : WeightedClasses.StripData (PressureStream.Lift S)} (p : CorrectionState.ReconstructionData) (r : CorrectionState.RankData S) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) {H : ℝ} (hu : CorrectionState.CumulativeBounds s u) (hi : MeanIncrementBounds.IncrementBounds s H (CorrectionState.rankIncrement p r axial c u)) (hp : WeightedClasses.MeanClass s H (rankPressureChange p r axial c u)) (hH : 9 / 10 ≤ H) : CorrectionState.CumulativeBounds s (CorrectionState.rankStage p r axial c u)

theorem NavierStokes.CorrectionStep.angularAverage_add {D : Type} {f g : CorrectionState.OscillatoryScalar D} (hf : ∀ (n : ℕ) (x : D), Continuous fun (θ : ℝ) => f n (x, θ)) (hg : ∀ (n : ℕ) (x : D), Continuous fun (θ : ℝ) => g n (x, θ)) : CorrectionState.angularAverage (f + g) = CorrectionState.angularAverage f + CorrectionState.angularAverage g

theorem NavierStokes.CorrectionStep.angularMeanVector_add {D : Type} {f g : CorrectionState.Oscillation D} (hf : AngularContinuous f) (hg : AngularContinuous g) : angularMeanVector (f + g) = angularMeanVector f + angularMeanVector g

theorem NavierStokes.CorrectionStep.meanGoodResidual_exact_errors {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (u : CorrectionState.State D) (hb : AngularContinuous u.errors.base) (hg : AngularContinuous u.errors.gaussian) (ha : AngularContinuous u.errors.aliasError) : u.meanGoodResidual c = u.reducedMeanResidual c - angularMeanVector u.errors.gaussian - angularMeanVector u.errors.aliasError

The base error is restored and subtracted exactly once. Gaussian and alias errors remain actual subtracted means, with no zero/flat substitution.

theorem NavierStokes.CorrectionStep.meanGoodResidual_at {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (u : CorrectionState.State D) (n : ℕ) (x : D) (i : Fin 3) (hb : Continuous fun (θ : ℝ) => u.errors.base n (x, θ) i) (hg : Continuous fun (θ : ℝ) => u.errors.gaussian n (x, θ) i) (ha : Continuous fun (θ : ℝ) => u.errors.aliasError n (x, θ) i) : u.meanGoodResidual c n x i = u.reducedMeanResidual c n x i - angularMeanVector u.errors.gaussian n x i - angularMeanVector u.errors.aliasError n x i

The same cancellation only uses angular continuity on the selected fiber. No regularity outside the current physical domain is needed.

theorem NavierStokes.CorrectionStep.meanResidualBounds_of_explicit_errors {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {σ : ℝ} (c : CorrectionState.Context D) (u : CorrectionState.State D) (hb : AngularContinuous u.errors.base) (hg : AngularContinuous u.errors.gaussian) (ha : AngularContinuous u.errors.aliasError) (hθ : WeightedClasses.MeanClass s (1 + σ) (u.thetaResidual c)) (hz : WeightedClasses.MeanClass s (1 + σ) (u.axialResidual c)) (hgθ : WeightedClasses.MeanClass s (1 + σ) fun (n : ℕ) (x : D) => angularMeanVector u.errors.gaussian n x 1) (hgz : WeightedClasses.MeanClass s (1 + σ) fun (n : ℕ) (x : D) => angularMeanVector u.errors.gaussian n x 2) (haθ : WeightedClasses.MeanClass s (1 + σ) fun (n : ℕ) (x : D) => angularMeanVector u.errors.aliasError n x 1) (haz : WeightedClasses.MeanClass s (1 + σ) fun (n : ℕ) (x : D) => angularMeanVector u.errors.aliasError n x 2) : CorrectionState.MeanResidualBounds s σ c u

noncomputable def NavierStokes.CorrectionStep.normalizedRankData (coord A B lam a b : ℝ) : CorrectionState.RankData PressureStream.Plane

The concrete normalized five-row inverse uses the physical coordinate functions of the current slow point, with no dependence on the torus slot.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.normalizedRank_angular (coord A B lam a b : ℝ) (c : CorrectionState.Context MeanRankUpdate.ChartPoint) (u : CorrectionState.State MeanRankUpdate.ChartPoint) (n : ℕ) : MeanRankUpdate.slowLift (CorrectionState.rankAngular (normalizedRankData coord A B lam a b) c u n) = MeanRankUpdate.chartAngular coord A B lam a b fun (z : MeanRankUpdate.ChartPoint) => CorrectionState.debt c u n z.2.1

theorem NavierStokes.CorrectionStep.normalizedRank_desired (coord A B lam a b : ℝ) (c : CorrectionState.Context MeanRankUpdate.ChartPoint) (u : CorrectionState.State MeanRankUpdate.ChartPoint) (n : ℕ) : CorrectionState.rankDesiredAxial (normalizedRankData coord A B lam a b) c u n = MeanRankUpdate.slowChartDesired coord A B lam a b (CorrectionState.debt c u n)

theorem NavierStokes.CorrectionStep.normalizedRank_potential (p : CorrectionState.ReconstructionData) (coord A B lam a b : ℝ) (c : CorrectionState.Context MeanRankUpdate.ChartPoint) (u : CorrectionState.State MeanRankUpdate.ChartPoint) (n : ℕ) : CorrectionState.rankPotential p (normalizedRankData coord A B lam a b) c u n = MeanRankUpdate.actualChartPotential coord A B lam a b p.exponent p.inner p.outer (p.frequency n) p.radialDirection (CorrectionState.debt c u n)

theorem NavierStokes.CorrectionStep.normalizedRank_radial (p : CorrectionState.ReconstructionData) (coord A B lam a b : ℝ) (axial : PressureStream.Plane × PressureStream.Plane) (c : CorrectionState.Context MeanRankUpdate.ChartPoint) (u : CorrectionState.State MeanRankUpdate.ChartPoint) : (CorrectionState.rankIncrement p (normalizedRankData coord A B lam a b) axial c u).radial = fun (n : ℕ) (x : MeanRankUpdate.ChartPoint) => c.operators.epsilon n * MeanRankUpdate.actualChartRadial coord A B lam a b p.exponent p.inner p.outer (p.frequency n) p.radialDirection axial (CorrectionState.debt c u n) x

theorem NavierStokes.CorrectionStep.normalizedRankIncrement_mem (s : WeightedClasses.StripData MeanRankUpdate.ChartPoint) (p : CorrectionState.ReconstructionData) (c : CorrectionState.Context MeanRankUpdate.ChartPoint) (u : CorrectionState.State MeanRankUpdate.ChartPoint) {coord A B lam a b qlo qhi H : ℝ} (hc : 0 < coord) (hc1 : coord < 1) (hlam : 0 < lam) (ha : 0 < a) (hab : a < b) (hB : B ≠ 0) (hp : 0 < p.exponent) (hlo : 0 < p.inner) (hqlo : 0 < qlo) (hleft : p.inner ≤ √qlo * a) (hright : √qhi * b ≤ p.outer) (hT : ∀ x ∈ s.domain, MeanRankUpdate.chartInput x ∈ PhysicalCoordinateBounds.positiveTime) (hq : ∀ x ∈ s.domain, MeanRankUpdate.chartQ coord x ∈ Set.Icc qlo qhi) (hR : ∀ x ∈ s.domain, x.1 ∈ Set.Icc p.inner p.outer) (hz : ∃ (δ : ℝ), 0 < δ ∧ ∀ x ∈ s.domain, x ∈ MeanRankUpdate.supportBand a b qlo qhi → δ ≤ s.zeta x) (axial : PressureStream.Plane × PressureStream.Plane) (hε : c.operators.epsilon = s.epsilon) (hd : WeightedClasses.UnweightedClass s H fun (n : ℕ) (x : MeanRankUpdate.ChartPoint) => CorrectionState.debt c u n x.2.1) : MeanIncrementBounds.IncrementBounds s H (CorrectionState.rankIncrement p (normalizedRankData coord A B lam a b) axial c u)

All three classes of the actual rank increment follow from the measured debt. The radial factor is the literal epsilon in rankIncrement.

theorem NavierStokes.CorrectionStep.rankStage_pressure_formula {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (p : CorrectionState.ReconstructionData) (r : CorrectionState.RankData S) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) : (CorrectionState.rankStage p r axial c u).pressure = MeanIncrementBounds.reconstructedPressure p.exponent p.inner p.outer ⋯ p.frequency (fun (x : ℕ) => p.radialDirection) c.operators c.base (MeanIncrementBounds.updated u.mean (CorrectionState.rankIncrement p r axial c u)) u.covariance

theorem NavierStokes.CorrectionStep.rankPressureChange_mem {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (p : CorrectionState.ReconstructionData) (r : CorrectionState.RankData S) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) {cL cR H κ : ℝ} (ha : 0 < p.inner) (hd : 0 < p.exponent) (hcL : 0 < cL) (hcR : 0 < cR) (L : ℕ → ℝ) (hε : ∀ (n : ℕ), 0 < c.operators.epsilon n) (hεone : ∀ (n : ℕ), c.operators.epsilon n ≤ 1) (hL : ∀ (n : ℕ), 1 ≤ L n) (ho : MeanIncrementBounds.OperatorBounds (WeightedRadialPrimitive.logStripData p.inner p.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) c.operators κ) (hb : MeanIncrementBounds.BaseBounds (WeightedRadialPrimitive.logStripData p.inner p.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) c.base) (hm : MeanIncrementBounds.CumulativeBounds (WeightedRadialPrimitive.logStripData p.inner p.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) u.mean) (hi : MeanIncrementBounds.IncrementBounds (WeightedRadialPrimitive.logStripData p.inner p.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) H (CorrectionState.rankIncrement p r axial c u)) (hH : 9 / 10 ≤ H) (hκ : 2 * κ ≤ 9 / 10) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn (WeightedRadialPrimitive.logStripData p.inner p.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL).domain (u.covariance i j)) (hf : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (MeanIncrementBounds.gr c.operators c.base (MeanIncrementBounds.updated u.mean (CorrectionState.rankIncrement p r axial c u)) u.covariance n)) (hg : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.gr c n)) (hsf : ∀ (n : ℕ), RadialAlias.RadiallySupported p.inner p.outer (MeanIncrementBounds.gr c.operators c.base (MeanIncrementBounds.updated u.mean (CorrectionState.rankIncrement p r axial c u)) u.covariance n)) (hsg : ∀ (n : ℕ), RadialAlias.RadiallySupported p.inner p.outer (u.gr c n)) (hpressure : u.pressure = (CorrectionState.reconstructPressure p c u).pressure) : WeightedClasses.MeanClass (WeightedRadialPrimitive.logStripData p.inner p.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL) H (rankPressureChange p r axial c u)

The pressure estimate is for the pressure actually recomputed after the rank correction. The input is the current radial source, not an assumed bound on the new pressure.

noncomputable def NavierStokes.CorrectionStep.refreshPressureAlias {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (p : CorrectionState.ReconstructionData) (c : CorrectionState.Context (PressureStream.Lift S)) (old current : CorrectionState.State (PressureStream.Lift S)) : CorrectionState.State (PressureStream.Lift S)

Replace precisely the obsolete radial alias when the pressure has been recomputed. All other accumulated aliases remain in the error field.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.refreshPressureAlias_separated {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (p : CorrectionState.ReconstructionData) (c : CorrectionState.Context (PressureStream.Lift S)) (old current : CorrectionState.State (PressureStream.Lift S)) (other : CorrectionState.Oscillation (PressureStream.Lift S)) (he : current.errors.aliasError = other + CorrectionState.pressureAlias p c old) : (refreshPressureAlias p c old current).errors.aliasError = other + CorrectionState.pressureAlias p c current

theorem NavierStokes.CorrectionStep.refreshPressureAlias_fullResidual {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (p : CorrectionState.ReconstructionData) (c : CorrectionState.Context (PressureStream.Lift S)) (old current : CorrectionState.State (PressureStream.Lift S)) : fullResidual c (refreshPressureAlias p c old current) = fullResidual c current

theorem NavierStokes.CorrectionStep.refreshPressureAlias_fullGoodResidual {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (p : CorrectionState.ReconstructionData) (c : CorrectionState.Context (PressureStream.Lift S)) (old current : CorrectionState.State (PressureStream.Lift S)) : fullGoodResidual c (refreshPressureAlias p c old current) = fullGoodResidual c current - (CorrectionState.pressureAlias p c current - CorrectionState.pressureAlias p c old)

theorem NavierStokes.CorrectionStep.reconstructed_radial_minus_alias {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (p : CorrectionState.ReconstructionData) (ha : 0 < p.inner) (hd : 0 < p.exponent) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (hoperator : ∀ (f : ScalarField (PressureStream.Lift S)) (n : ℕ) (x : PressureStream.Lift S), c.operators.dr f n x = PressureStream.graphDr (PressureStream.physicalSpeed p.exponent (p.frequency n)) (0, p.radialDirection) (f n) x) (hsmooth : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.gr c n)) (hsupport : ∀ (n : ℕ), RadialAlias.RadiallySupported p.inner p.outer (u.gr c n)) (n : ℕ) (x : PressureStream.Lift S) : (CorrectionState.reconstructPressure p c u).radialResidual c n x - CorrectionState.pressureAlias p c u n (x, 0) 0 = -PressureStream.rho p.inner p.outer ⋯ x.1 * CorrectionState.pressureDefect c u n x.2.1

The exact current radial alias cancels only the alias part of the reconstructed radial equation; the repaired pressure defect remains.

theorem NavierStokes.CorrectionStep.fullResidual_eq_harmonicResidual {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (u : CorrectionState.State D) : fullResidual c u = HarmonicResidual.stateFullResidual c u

theorem NavierStokes.CorrectionStep.fullGoodResidual_eq_harmonicResidual {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (u : CorrectionState.State D) : fullGoodResidual c u = HarmonicResidual.stateGoodResidual c u

theorem NavierStokes.CorrectionStep.fullGoodWaveResidual_eq_harmonicResidual {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (u : CorrectionState.State D) : fullGoodWaveResidual c u = HarmonicResidual.stateGoodWaveResidual c u

theorem NavierStokes.CorrectionStep.fullGoodWaveResidual_grouped {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {ι : Type u_1} {U : Set D} (hU : IsOpen U) {c : CorrectionState.Context D} {u : CorrectionState.State D} {labels : ℕ → Finset ι} {blocks : ι → CorrectionState.HarmonicBlock D} {gaussian aliasError : ι → HarmonicResidual.BlockCoefficients D} (hrep : HarmonicResidual.BlockRepresentation labels blocks gaussian aliasError u) {n : ℕ} (h : HarmonicResidual.ExtractionRegular U c u labels blocks gaussian aliasError n) {x : D × ℝ} (hx : x ∈ HarmonicResidual.liftDomain U) (i : Fin 3) : fullGoodWaveResidual c u n x i = ∑ l ∈ labels n, (HarmonicResidual.residualBlock c u (blocks l) (gaussian l) (aliasError l)).oscillation n x i

The right-hand sides for the particular solves are obtained from the literal current nonlinear PDE residual, by differentiating and convolving its stored finite harmonics and then removing the zero harmonic.

theorem NavierStokes.CorrectionStep.fullResidual_harmonic_decomposition {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {ι : Type u_1} {U : Set D} (hU : IsOpen U) {c : CorrectionState.Context D} {u : CorrectionState.State D} {labels : ℕ → Finset ι} {blocks : ι → CorrectionState.HarmonicBlock D} {gaussian aliasError : ι → HarmonicResidual.BlockCoefficients D} (hrep : HarmonicResidual.BlockRepresentation labels blocks gaussian aliasError u) {n : ℕ} (h : HarmonicResidual.ExtractionRegular U c u labels blocks gaussian aliasError n) {x : D × ℝ} (hx : x ∈ HarmonicResidual.liftDomain U) (i : Fin 3) : fullResidual c u n x i = ∑ l ∈ labels n, (HarmonicResidual.residualBlock c u (blocks l) (gaussian l) (aliasError l)).oscillation n x i + HarmonicResidual.stateMeanCoefficientValue labels blocks gaussian aliasError c u n x.1 i + u.errors.total n x i

Reconstruction retains the actual zero mode and every stored error. No mean equation or error-flatness assertion is hidden in this identity.

theorem NavierStokes.CorrectionStep.temporalIncrement_torusMean {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] (p : CorrectionState.ReconstructionData) (h : ℝ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (ha : 0 < p.inner) (hd : 0 < p.exponent) (hθ : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.thetaResidual c n)) (hz : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.axialResidual c n)) (hpθ : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.axialResidual c n)) (hsz : ∀ (n : ℕ), RadialAlias.RadiallySupported p.inner p.outer (u.axialResidual c n)) (n : ℕ) (x : ℝ × S) : PressureStream.torusAverage ((CorrectionState.temporalIncrement p h axial c u).angular n) x = 0 ∧ PressureStream.torusAverage ((CorrectionState.temporalIncrement p h axial c u).axial n) x = 0

The actual angular and reconstructed axial temporal increments have zero torus mean before taking either radial moment.

theorem NavierStokes.CorrectionStep.temporalStage_preserve_masses {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] (p : CorrectionState.ReconstructionData) (h : ℝ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (ha : 0 < p.inner) (hd : 0 < p.exponent) (hmθ : ∀ (n : ℕ), Continuous (u.mean.angular n)) (hmz : ∀ (n : ℕ), Continuous (u.mean.axial n)) (hθ : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.thetaResidual c n)) (hz : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.axialResidual c n)) (hpθ : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.axialResidual c n)) (hsz : ∀ (n : ℕ), RadialAlias.RadiallySupported p.inner p.outer (u.axialResidual c n)) : CorrectionState.radialMoment 2 (CorrectionState.temporalStage p h axial c u).mean.angular = CorrectionState.radialMoment 2 u.mean.angular ∧ CorrectionState.radialMoment 1 (CorrectionState.temporalStage p h axial c u).mean.axial = CorrectionState.radialMoment 1 u.mean.axial

theorem NavierStokes.CorrectionStep.angularMean_fullGoodResidual {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} {c : CorrectionState.Context D} {u : CorrectionState.State D} (H : LiftedMeanResidual.MeanHypotheses U c u) (n : ℕ) {x : D} (hx : x ∈ U) (i : Fin 3) : angularMeanVector (fullGoodResidual c u) n x i = u.meanGoodResidual c n x i

theorem NavierStokes.CorrectionStep.meanCoefficientValue_eq_meanResidual {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {ι : Type u_1} {U : Set D} {c : CorrectionState.Context D} {u : CorrectionState.State D} {labels : ℕ → Finset ι} {blocks : ι → CorrectionState.HarmonicBlock D} {gaussian aliasError : ι → HarmonicResidual.BlockCoefficients D} (hrep : HarmonicResidual.BlockRepresentation labels blocks gaussian aliasError u) (H : LiftedMeanResidual.MeanHypotheses U c u) {n : ℕ} (h : HarmonicResidual.ExtractionRegular U c u labels blocks gaussian aliasError n) {x : D} (hx : x ∈ U) (i : Fin 3) : HarmonicResidual.stateMeanCoefficientValue labels blocks gaussian aliasError c u n x i = u.meanGoodResidual c n x i

The zero harmonic of the differentiated coefficient reconstruction is the actual mean equation, with its exact excluded-error subtraction.

theorem NavierStokes.CorrectionStep.fullResidual_reconstructed_with_mean {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {ι : Type u_1} {U : Set D} {c : CorrectionState.Context D} {u : CorrectionState.State D} {labels : ℕ → Finset ι} {blocks : ι → CorrectionState.HarmonicBlock D} {gaussian aliasError : ι → HarmonicResidual.BlockCoefficients D} (hrep : HarmonicResidual.BlockRepresentation labels blocks gaussian aliasError u) (H : LiftedMeanResidual.MeanHypotheses U c u) {n : ℕ} (h : HarmonicResidual.ExtractionRegular U c u labels blocks gaussian aliasError n) {x : D × ℝ} (hx : x ∈ HarmonicResidual.liftDomain U) (i : Fin 3) : fullResidual c u n x i = ∑ l ∈ labels n, (HarmonicResidual.residualBlock c u (blocks l) (gaussian l) (aliasError l)).oscillation n x i + u.meanGoodResidual c n x.1 i + u.errors.total n x i

noncomputable def NavierStokes.CorrectionStep.meanLift {D : Type} (m : MeanIncrementBounds.Triple D) : CorrectionState.Oscillation D

Mean lift, defined pointwise by meanComponents m n x.1.

Equations

• NavierStokes.CorrectionStep.meanLift m n x = NavierStokes.CorrectionStep.meanComponents m n x.1

noncomputable def NavierStokes.CorrectionStep.meanDivergence {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (m : MeanIncrementBounds.Triple D) : ScalarField D

Mean divergence, defined pointwise by c.operators.dr m.radial n x + m.radial n x / c.operators.radius x + c.operators.dz m.axial n x.

Equations

• NavierStokes.CorrectionStep.meanDivergence c m n x = c.operators.dr m.radial n x + m.radial n x / c.operators.radius x + c.operators.dz m.axial n x

noncomputable def NavierStokes.CorrectionStep.fullDivergence {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (u : CorrectionState.State D) : CorrectionState.OscillatoryScalar D

Full divergence as an element of OscillatoryScalar D.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.meanLift_divergence {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} (hU : IsOpen U) (c : CorrectionState.Context D) (m : MeanIncrementBounds.Triple D) (hm : MeanIncrementBounds.SmoothTriple U m) (n : ℕ) {x : D} (hx : x ∈ U) (θ : ℝ) : LiftedMeanResidual.realDivergence (fun (y : D × ℝ) => c.operators.radius y.1) (radialDirection c n) angularDirection (axialDirection c n) (meanLift m n) (x, θ) = meanDivergence c m n x

theorem NavierStokes.CorrectionStep.fullDivergence_actual_update {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (u : CorrectionState.State D) (m : MeanIncrementBounds.Triple D) (p : ScalarField D) (w : CorrectionState.Oscillation D) (q : CorrectionState.OscillatoryScalar D) (e : CorrectionState.ExcludedErrors D) (n : ℕ) (x : D × ℝ) (hu : ∀ (i : Fin 3), DifferentiableAt ℝ (fun (y : D × ℝ) => u.totalVelocity c n y i) x) (hi : ∀ (i : Fin 3), DifferentiableAt ℝ (fun (y : D × ℝ) => meanLift m n y i + w n y i) x) : fullDivergence c (u.addIncrement m p w q e) n x = fullDivergence c u n x + LiftedMeanResidual.realDivergence (fun (y : D × ℝ) => c.operators.radius y.1) (radialDirection c n) angularDirection (axialDirection c n) (fun (y : D × ℝ) => meanLift m n y + w n y) x

Addition preserves actual cylindrical divergence by the derivative sum rule. The correction's divergence is a separate explicit summand.

theorem NavierStokes.CorrectionStep.meanAddition_fullDivergence {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} (hU : IsOpen U) (c : CorrectionState.Context D) (u : CorrectionState.State D) (m : MeanIncrementBounds.Triple D) (p : ScalarField D) (q : CorrectionState.OscillatoryScalar D) (e : CorrectionState.ExcludedErrors D) (hm : MeanIncrementBounds.SmoothTriple U m) (n : ℕ) {x : D} (hx : x ∈ U) (θ : ℝ) (hu : ∀ (i : Fin 3), DifferentiableAt ℝ (fun (y : D × ℝ) => u.totalVelocity c n y i) (x, θ)) : fullDivergence c (u.addIncrement m p 0 q e) n (x, θ) = fullDivergence c u n (x, θ) + meanDivergence c m n x

theorem NavierStokes.CorrectionStep.fullDivergence_reconstructPressure {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (p : CorrectionState.ReconstructionData) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) : fullDivergence c (CorrectionState.reconstructPressure p c u) = fullDivergence c u

theorem NavierStokes.CorrectionStep.meanDivergence_eq_graph {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (p : CorrectionState.ReconstructionData) (epsilon fast : ℕ → ℝ) (axial slowTime : S × PressureStream.Plane) (temporal : PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (hcompat : c.operators = CorrectionState.graphOperators p epsilon fast axial slowTime temporal) (m : MeanIncrementBounds.Triple (PressureStream.Lift S)) (n : ℕ) (x : PressureStream.Lift S) : meanDivergence c m n x = PressureStream.graphDivergence (PressureStream.physicalSpeed p.exponent (p.frequency n)) (0, p.radialDirection) (epsilon n • axial) (m.radial n) (m.axial n) x

theorem NavierStokes.CorrectionStep.temporalIncrement_meanDivergence_zero {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] (p : CorrectionState.ReconstructionData) (h : ℝ) (axial slowTime : S × PressureStream.Plane) (temporal : PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (ha : 0 < p.inner) (hd : 0 < p.exponent) (hcompat : c.operators = CorrectionState.graphOperators p c.operators.epsilon c.operators.fastCoefficient axial slowTime temporal) (hz : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.axialResidual c n)) (hpz : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.axialResidual c n)) (hsz : ∀ (n : ℕ), RadialAlias.RadiallySupported p.inner p.outer (u.axialResidual c n)) (n : ℕ) (x : PressureStream.Lift S) : meanDivergence c (CorrectionState.temporalIncrement p h axial c u) n x = 0

theorem NavierStokes.CorrectionStep.temporalStage_fullDivergence {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] (p : CorrectionState.ReconstructionData) (h : ℝ) (axial slowTime : S × PressureStream.Plane) (temporal : PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (ha : 0 < p.inner) (hd : 0 < p.exponent) (hcompat : c.operators = CorrectionState.graphOperators p c.operators.epsilon c.operators.fastCoefficient axial slowTime temporal) (hθ : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.thetaResidual c n)) (hz : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.axialResidual c n)) (hpθ : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.axialResidual c n)) (hsz : ∀ (n : ℕ), RadialAlias.RadiallySupported p.inner p.outer (u.axialResidual c n)) (n : ℕ) (x : PressureStream.Lift S × ℝ) (hu : ∀ (i : Fin 3), DifferentiableAt ℝ (fun (y : PressureStream.Lift S × ℝ) => u.totalVelocity c n y i) x) : fullDivergence c (CorrectionState.temporalStage p h axial c u) n x = fullDivergence c u n x

theorem NavierStokes.CorrectionStep.temporalStage_zeroMasses {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] (p : CorrectionState.ReconstructionData) (h : ℝ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (ha : 0 < p.inner) (hd : 0 < p.exponent) (hmθ : ∀ (n : ℕ), Continuous (u.mean.angular n)) (hmz : ∀ (n : ℕ), Continuous (u.mean.axial n)) (hθ : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.thetaResidual c n)) (hz : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.axialResidual c n)) (hpθ : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.axialResidual c n)) (hsz : ∀ (n : ℕ), RadialAlias.RadiallySupported p.inner p.outer (u.axialResidual c n)) (hzero : CorrectionState.ZeroMasses u) : CorrectionState.ZeroMasses (CorrectionState.temporalStage p h axial c u)

theorem NavierStokes.CorrectionStep.rankIncrement_meanDivergence_zero {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (p : CorrectionState.ReconstructionData) (r : CorrectionState.RankData S) (axial slowTime : S × PressureStream.Plane) (temporal : PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (ha : 0 < p.inner) (hd : 0 < p.exponent) (hcompat : c.operators = CorrectionState.graphOperators p c.operators.epsilon c.operators.fastCoefficient axial slowTime temporal) (hf : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (CorrectionState.rankDesiredAxial r c u n)) (hs : ∀ (n : ℕ), RadialAlias.RadiallySupported p.inner p.outer (CorrectionState.rankDesiredAxial r c u n)) (n : ℕ) (x : PressureStream.Lift S) : meanDivergence c (CorrectionState.rankIncrement p r axial c u) n x = 0

theorem NavierStokes.CorrectionStep.rankStage_fullDivergence {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {U : Set (PressureStream.Lift S)} (hU : IsOpen U) (p : CorrectionState.ReconstructionData) (r : CorrectionState.RankData S) (axial slowTime : S × PressureStream.Plane) (temporal : PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (ha : 0 < p.inner) (hd : 0 < p.exponent) (hcompat : c.operators = CorrectionState.graphOperators p c.operators.epsilon c.operators.fastCoefficient axial slowTime temporal) (hm : MeanIncrementBounds.SmoothTriple U (CorrectionState.rankIncrement p r axial c u)) (hf : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (CorrectionState.rankDesiredAxial r c u n)) (hs : ∀ (n : ℕ), RadialAlias.RadiallySupported p.inner p.outer (CorrectionState.rankDesiredAxial r c u n)) (n : ℕ) {x : PressureStream.Lift S × ℝ} (hx : x.1 ∈ U) (hu : ∀ (i : Fin 3), DifferentiableAt ℝ (fun (y : PressureStream.Lift S × ℝ) => u.totalVelocity c n y i) x) : fullDivergence c (CorrectionState.rankStage p r axial c u) n x = fullDivergence c u n x

noncomputable def NavierStokes.CorrectionStep.reconstructPressureFamily {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (r : ℕ → CorrectionState.ReconstructionData) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) : CorrectionState.State (PressureStream.Lift S)

Pressure reconstruction with the prescribed transported radial data for each band. This is an actual field constructor.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.commonTemporalError {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (r : ℕ → CorrectionState.ReconstructionData) (h : ℝ) (index : ℕ → ℕ) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) : CorrectionState.Oscillation (PressureStream.Lift S)

Common temporal error as an element of Oscillation (PressureStream.Lift S).

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.commonTemporalStage {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (r : ℕ → CorrectionState.ReconstructionData) (h : ℝ) (index : ℕ → ℕ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) : CorrectionState.State (PressureStream.Lift S)

Common temporal stage, constructed using reconstructPressureFamily.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.commonTemporalPressureChange {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (r : ℕ → CorrectionState.ReconstructionData) (h : ℝ) (index : ℕ → ℕ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) : ScalarField (PressureStream.Lift S)

Common temporal pressure change, given by (commonTemporalStage r h index axial c u).pressure - u.pressure.

Equations

• NavierStokes.CorrectionStep.commonTemporalPressureChange r h index axial c u = (NavierStokes.CorrectionStep.commonTemporalStage r h index axial c u).pressure - u.pressure

theorem NavierStokes.CorrectionStep.common_fastTime {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (h : ℝ) (index : ℕ → ℕ) (c : CorrectionState.Context (PressureStream.Lift S)) (hv : c.operators.vT = (0, 0, TorusInverse.vector TorusInverse.Direction.temporal)) (hf : ∀ (n : ℕ), c.operators.fastCoefficient n = ChartScales.Tg ^ index n * ChartScales.Q n ^ (1 + h)) (f : ScalarField (PressureStream.Lift S)) (n : ℕ) (x : PressureStream.Lift S) : c.operators.fastTime f n x = MeanChartCompatibility.fastAtIndex h n (index n) (f n) x

theorem NavierStokes.CorrectionStep.commonTemporalStage_native {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (r : CorrectionState.ReconstructionData) (h : ℝ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) : commonTemporalStage (fun (x : ℕ) => r) h (ChartScales.nativeIndex h) axial c u = CorrectionState.temporalStage r h axial c u

theorem NavierStokes.CorrectionStep.commonTemporalIncrement_smooth {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] (r : ℕ → CorrectionState.ReconstructionData) (h : ℝ) (index : ℕ → ℕ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (U : Set (PressureStream.Lift S)) (ha : ∀ (n : ℕ), 0 < (r n).inner) (hd : ∀ (n : ℕ), 0 < (r n).exponent) (hθ : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.thetaResidual c n)) (hz : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.axialResidual c n)) (hpθ : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.axialResidual c n)) (hsz : ∀ (n : ℕ), RadialAlias.RadiallySupported (r n).inner (r n).outer (u.axialResidual c n)) : MeanIncrementBounds.SmoothTriple U (MeanChartCompatibility.commonTemporalIncrement r h index axial c u)

theorem NavierStokes.CorrectionStep.commonTemporalStage_theta_exact {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] {U : Set (PressureStream.Lift S)} (hU : IsOpen U) (r : ℕ → CorrectionState.ReconstructionData) (h : ℝ) (index : ℕ → ℕ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (ha : ∀ (n : ℕ), 0 < (r n).inner) (hd : ∀ (n : ℕ), 0 < (r n).exponent) (hv : c.operators.vT = (0, 0, TorusInverse.vector TorusInverse.Direction.temporal)) (hfast : ∀ (n : ℕ), c.operators.fastCoefficient n = ChartScales.Tg ^ index n * ChartScales.Q n ^ (1 + h)) (hprofile : ContDiffOn ℝ (↑⊤) c.operators.radialProfile U) (hb : MeanIncrementBounds.SmoothTriple U c.base) (hm : MeanIncrementBounds.SmoothTriple U u.mean) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (u.covariance i j)) (hθ : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.thetaResidual c n)) (hz : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.axialResidual c n)) (hpθ : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.axialResidual c n)) (hsz : ∀ (n : ℕ), RadialAlias.RadiallySupported (r n).inner (r n).outer (u.axialResidual c n)) : MeanIncrementBounds.Agree U ((commonTemporalStage r h index axial c u).thetaResidual c) (meanBar (u.thetaResidual c) + MeanIncrementBounds.thetaRemainder c.operators c.base u.mean (MeanChartCompatibility.commonTemporalIncrement r h index axial c u))

Fast cancellation is now performed at the chosen common index; the remaining angular mean is the original torus bar plus the exact remainder.

theorem NavierStokes.CorrectionStep.commonTemporalStage_axial_exact {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] {U : Set (PressureStream.Lift S)} (hU : IsOpen U) (r : ℕ → CorrectionState.ReconstructionData) (h : ℝ) (index : ℕ → ℕ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (ha : ∀ (n : ℕ), 0 < (r n).inner) (hd : ∀ (n : ℕ), 0 < (r n).exponent) (hv : c.operators.vT = (0, 0, TorusInverse.vector TorusInverse.Direction.temporal)) (hfast : ∀ (n : ℕ), c.operators.fastCoefficient n = ChartScales.Tg ^ index n * ChartScales.Q n ^ (1 + h)) (hprofile : ContDiffOn ℝ (↑⊤) c.operators.radialProfile U) (hb : MeanIncrementBounds.SmoothTriple U c.base) (hm : MeanIncrementBounds.SmoothTriple U u.mean) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (u.covariance i j)) (hp : MeanIncrementBounds.SmoothOn U u.pressure) (hnp : MeanIncrementBounds.SmoothOn U (commonTemporalStage r h index axial c u).pressure) (hθ : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.thetaResidual c n)) (hz : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.axialResidual c n)) (hpθ : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.axialResidual c n)) (hsz : ∀ (n : ℕ), RadialAlias.RadiallySupported (r n).inner (r n).outer (u.axialResidual c n)) : MeanIncrementBounds.Agree U (fun (n : ℕ) (x : PressureStream.Lift S) => (commonTemporalStage r h index axial c u).axialResidual c n x - commonTemporalError r h index c u n (x, 0) 2) (meanBar (u.axialResidual c) + MeanIncrementBounds.axialRemainder c.operators c.base u.mean (MeanChartCompatibility.commonTemporalIncrement r h index axial c u) (commonTemporalPressureChange r h index axial c u))

theorem NavierStokes.CorrectionStep.streamPotential_const_mul {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (d a b M c : ℝ) (v : S) (f : ℝ × S → ℝ) : (PressureStream.streamPotential d a b M v fun (x : ℝ × S) => c * f x) = fun (x : ℝ × S) => c * PressureStream.streamPotential d a b M v f x

noncomputable def NavierStokes.CorrectionStep.scaleTriple {D : Type} (a : ℕ → ℝ) (m : MeanIncrementBounds.Triple D) : MeanIncrementBounds.Triple D

Scale triple, bundling radial, angular, axial.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.triple_ext {D : Type} {a b : MeanIncrementBounds.Triple D} (hr : a.radial = b.radial) (ht : a.angular = b.angular) (hz : a.axial = b.axial) : a = b

theorem NavierStokes.CorrectionStep.scaleTriple_mem {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {H : ℝ} {a : ℕ → ℝ} {m : MeanIncrementBounds.Triple D} (ha : WeightedClasses.BandBound s 0 a) (hm : MeanIncrementBounds.IncrementBounds s H m) : MeanIncrementBounds.IncrementBounds s H (scaleTriple a m)

theorem NavierStokes.CorrectionStep.commonTemporalIncrement_eq_scale {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] (p : CorrectionState.ReconstructionData) (h : ℝ) (index : ℕ → ℕ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (ha : 0 < p.inner) (hd : 0 < p.exponent) (hz : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.axialResidual c n)) (hpz : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.axialResidual c n)) (hsz : ∀ (n : ℕ), RadialAlias.RadiallySupported p.inner p.outer (u.axialResidual c n)) : MeanChartCompatibility.commonTemporalIncrement (fun (x : ℕ) => p) h index axial c u = scaleTriple (fun (n : ℕ) => MeanChartCompatibility.commonRatio h n (index n)) (CorrectionState.temporalIncrement p h axial c u)

Changing the common clock multiplies the actual inverse and its actual stream realization by the same band scalar.

theorem NavierStokes.CorrectionStep.commonTemporalIncrement_mem_of_native {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] {s : WeightedClasses.StripData (PressureStream.Lift S)} (p : CorrectionState.ReconstructionData) (h : ℝ) (index : ℕ → ℕ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) {H : ℝ} (ha : 0 < p.inner) (hd : 0 < p.exponent) (gap : ℕ) (hgap : ∀ (n : ℕ), ChartScales.nativeIndex h n ≤ index n + gap) (hz : ∀ (n : ℕ), ContDiff ℝ (↑⊤) (u.axialResidual c n)) (hpz : ∀ (n : ℕ), PressureStream.TorusPeriodicLift (u.axialResidual c n)) (hsz : ∀ (n : ℕ), RadialAlias.RadiallySupported p.inner p.outer (u.axialResidual c n)) (hi : MeanIncrementBounds.IncrementBounds s H (CorrectionState.temporalIncrement p h axial c u)) : MeanIncrementBounds.IncrementBounds s H (MeanChartCompatibility.commonTemporalIncrement (fun (x : ℕ) => p) h index axial c u)

The common/native gap has no cost in the residual exponent. This statement works on any strip on which the native construction was proved.

noncomputable def NavierStokes.CorrectionStep.addBlock {D : Type} (a b : CorrectionState.HarmonicBlock D) : CorrectionState.HarmonicBlock D

Add coefficient families on the same fixed label carrier.

Equations

• One or more equations did not get rendered due to their size.

structure NavierStokes.CorrectionStep.SameCarrier {D : Type} (a b : CorrectionState.HarmonicBlock D) : Prop

Same carrier data, collecting frequency, phase, angular.

• frequency : b.frequency = a.frequency
• phase : b.phase = a.phase
• angular : b.angularFrequency = a.angularFrequency

theorem NavierStokes.CorrectionStep.addBlock_oscillation {D : Type} (a b : CorrectionState.HarmonicBlock D) (h : SameCarrier a b) : (addBlock a b).oscillation = a.oscillation + b.oscillation

theorem NavierStokes.CorrectionStep.addBlock_pressure {D : Type} (a b : CorrectionState.HarmonicBlock D) (h : SameCarrier a b) : (addBlock a b).oscillatoryPressure = a.oscillatoryPressure + b.oscillatoryPressure

theorem NavierStokes.CorrectionStep.addBlock_band {D : Type} {a b : CorrectionState.HarmonicBlock D} {N M : ℕ} (ha : a.BandLimited N) (hb : b.BandLimited M) : (addBlock a b).BandLimited (max N M)

theorem NavierStokes.CorrectionStep.addBlock_waveBounds {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {α β : ℝ} {a b : CorrectionState.HarmonicBlock D} (ha : CorrectionState.HarmonicBlock.WaveBounds s P α a) (hb : CorrectionState.HarmonicBlock.WaveBounds s P β b) (hαβ : α ≤ β) : CorrectionState.HarmonicBlock.WaveBounds s P α (addBlock a b)

theorem NavierStokes.CorrectionStep.addBlock_pressureBounds {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {α β : ℝ} {a b : CorrectionState.HarmonicBlock D} (ha : CorrectionState.HarmonicBlock.PressureBounds s P α a) (hb : CorrectionState.HarmonicBlock.PressureBounds s P β b) (hαβ : α ≤ β) : CorrectionState.HarmonicBlock.PressureBounds s P α (addBlock a b)

theorem NavierStokes.CorrectionStep.addBlock_differenceBounds {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {α β : ℝ} (primary old increment : CorrectionState.HarmonicBlock D) (hold : ∀ (i : Fin 3) (j : ℤ), j ≠ 0 → WeightedClasses.WaveClass s P α fun (n : ℕ) (x : D) => (old.velocity n i).coeff j x - (primary.velocity n i).coeff j x) (hi : CorrectionState.HarmonicBlock.WaveBounds s P β increment) (hαβ : α ≤ β) (i : Fin 3) (j : ℤ) : j ≠ 0 → WeightedClasses.WaveClass s P α fun (n : ℕ) (x : D) => ((addBlock old increment).velocity n i).coeff j x - (primary.velocity n i).coeff j x

The cumulative difference is the literal coefficient difference from the same primary field, including all previous corrections.

theorem NavierStokes.CorrectionStep.block_waveBounds_all {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {α : ℝ} (b : CorrectionState.HarmonicBlock D) (hb : CorrectionState.HarmonicBlock.WaveBounds s P α b) (hzero : ∀ (n : ℕ) (i : Fin 3), (b.velocity n i).coeff 0 = 0) (hP : ∀ (n : ℕ), ∀ x ∈ s.domain, 0 ≤ P n x) (i : Fin 3) (j : ℤ) : WeightedClasses.WaveClass s P α fun (n : ℕ) (x : D) => (b.velocity n i).coeff j x

theorem NavierStokes.CorrectionStep.block_angularContinuous {D : Type} (b : CorrectionState.HarmonicBlock D) : AngularContinuous b.oscillation

theorem NavierStokes.CorrectionStep.sameCarrier_covarianceIncrement_mem {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {α β : ℝ} (a b : CorrectionState.HarmonicBlock D) (hcarrier : SameCarrier a b) (N M : ℕ) (hNa : a.BandLimited N) (hMb : b.BandLimited M) (ha : CorrectionState.HarmonicBlock.WaveBounds s P α a) (hb : CorrectionState.HarmonicBlock.WaveBounds s P β b) (ha0 : ∀ (n : ℕ) (i : Fin 3), (a.velocity n i).coeff 0 = 0) (hb0 : ∀ (n : ℕ) (i : Fin 3), (b.velocity n i).coeff 0 = 0) (hαβ : α ≤ β) (hkp : ∀ (n : ℕ), a.angularFrequency n ≠ 0) (hP0 : ∀ (n : ℕ), ∀ x ∈ s.domain, 0 ≤ P n x) (hP1 : ∀ (n : ℕ), ∀ x ∈ s.domain, P n x ≤ 1) : TensorClass s (α + β) (covarianceIncrement a.oscillation b.oscillation)

Both old/new cross covariances and the entire new-wave square are estimated as actual angular integrals. There is no tensor-update premise.

theorem NavierStokes.CorrectionStep.oneLabel_stateCovariance_change {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {α β : ℝ} (u : CorrectionState.State D) (a b : CorrectionState.HarmonicBlock D) (hu : u.oscillation = a.oscillation) (hcarrier : SameCarrier a b) (N M : ℕ) (hNa : a.BandLimited N) (hMb : b.BandLimited M) (ha : CorrectionState.HarmonicBlock.WaveBounds s P α a) (hb : CorrectionState.HarmonicBlock.WaveBounds s P β b) (ha0 : ∀ (n : ℕ) (i : Fin 3), (a.velocity n i).coeff 0 = 0) (hb0 : ∀ (n : ℕ) (i : Fin 3), (b.velocity n i).coeff 0 = 0) (hαβ : α ≤ β) (hkp : ∀ (n : ℕ), a.angularFrequency n ≠ 0) (hP0 : ∀ (n : ℕ), ∀ x ∈ s.domain, 0 ≤ P n x) (hP1 : ∀ (n : ℕ), ∀ x ∈ s.domain, P n x ≤ 1) (m : MeanIncrementBounds.Triple D) (p : ScalarField D) (e : CorrectionState.ExcludedErrors D) : TensorClass s (α + β) ((u.addIncrement m p b.oscillation b.oscillatoryPressure e).covariance - u.covariance)

Substitution of the constructed field into the state's covariance is now paired with the tensor class of its exact change.

theorem NavierStokes.CorrectionStep.meanUpdate_residualBlock_mem {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {κ α H β : ℝ} {P : ℕ → D → ℝ} (c : CorrectionState.Context D) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hκ : κ ≤ 1 / 2) (hR : ∀ x ∈ s.domain, 0 < c.operators.radius x) (u v : CorrectionState.State D) (m : MeanIncrementBounds.Triple D) (he : v.mean = MeanIncrementBounds.updated u.mean m) (hbase : MeanIncrementBounds.SmoothTriple s.domain c.base) (hmean : MeanIncrementBounds.SmoothTriple s.domain u.mean) (hm : MeanIncrementBounds.IncrementBounds s H m) (b : CorrectionState.HarmonicBlock D) (hb : CorrectionState.HarmonicBlock.WaveBounds s P α b) (hN : ∀ (i : Fin 3), WeightedClasses.UnweightedClass s 0 fun (n : ℕ) (x : D) => (HarmonicMeanInteraction.slowNormal c ho hR b.phase n x).ofLp i) (hk : WeightedClasses.BandBound s (-(1 / 2)) b.frequency) (hkp : WeightedClasses.BandBound s (-(1 / 2)) fun (n : ℕ) => ↑(b.angularFrequency n)) (hP : ∀ (n : ℕ), ∀ x ∈ s.domain, 0 ≤ P n x) (G A₀ A₁ : HarmonicResidual.BlockCoefficients D) (hA : ∀ (n : ℕ) (i : Fin 3), HarmonicFields.BandLimited (A₁ n i - A₀ n i) 0) (hold : CorrectionState.HarmonicBlock.WaveBounds s P β (HarmonicResidual.residualBlock c u b G A₀)) (hβ : β ≤ α + H - 1 / 2) : CorrectionState.HarmonicBlock.WaveBounds s P β (HarmonicResidual.residualBlock c v b G A₁)

The actual residual block retains a target exponent through a mean update. Its change is estimated by the two differentiated cross-advections.

theorem NavierStokes.CorrectionStep.meanUpdate_residualBlock_next {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {κ σ : ℝ} {P : ℕ → D → ℝ} (c : CorrectionState.Context D) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hκ : κ ≤ 1 / 100000) (hR : ∀ x ∈ s.domain, 0 < c.operators.radius x) (u v : CorrectionState.State D) (m : MeanIncrementBounds.Triple D) (he : v.mean = MeanIncrementBounds.updated u.mean m) (hbase : MeanIncrementBounds.SmoothTriple s.domain c.base) (hmean : MeanIncrementBounds.SmoothTriple s.domain u.mean) (hm : MeanIncrementBounds.IncrementBounds s (ExponentLedger.meanUpdateExponent σ κ) m) (b : CorrectionState.HarmonicBlock D) (hb : CorrectionState.HarmonicBlock.WaveBounds s P (1 / 2) b) (hN : ∀ (i : Fin 3), WeightedClasses.UnweightedClass s 0 fun (n : ℕ) (x : D) => (HarmonicMeanInteraction.slowNormal c ho hR b.phase n x).ofLp i) (hk : WeightedClasses.BandBound s (-(1 / 2)) b.frequency) (hkp : WeightedClasses.BandBound s (-(1 / 2)) fun (n : ℕ) => ↑(b.angularFrequency n)) (hP : ∀ (n : ℕ), ∀ x ∈ s.domain, 0 ≤ P n x) (G A₀ A₁ : HarmonicResidual.BlockCoefficients D) (hA : ∀ (n : ℕ) (i : Fin 3), HarmonicFields.BandLimited (A₁ n i - A₀ n i) 0) (hold : CorrectionState.HarmonicBlock.WaveBounds s P (ExponentLedger.waveExponent (σ + 1 / 10)) (HarmonicResidual.residualBlock c u b G A₀)) : CorrectionState.HarmonicBlock.WaveBounds s P (ExponentLedger.waveExponent (σ + 1 / 10)) (HarmonicResidual.residualBlock c v b G A₁)

With the cumulative wave exponent 1/2, each actual temporal or rank mean increment has wave effect of exponent H.

theorem NavierStokes.CorrectionStep.rankStage_axial_sub_mem {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {s : WeightedClasses.StripData (PressureStream.Lift S)} (p : CorrectionState.ReconstructionData) (r : CorrectionState.RankData S) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (hg : DefectIncrementBounds.RankGeometry p r c u) {H κ β : ℝ} (v : PressureStream.Plane) (hfast : c.operators.vT = (0, 0, v)) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hb : MeanIncrementBounds.BaseBounds s c.base) (hm : MeanIncrementBounds.CumulativeBounds s u.mean) (hi : MeanIncrementBounds.IncrementBounds s H (CorrectionState.rankIncrement p r axial c u)) (hp : MeanIncrementBounds.SmoothOn s.domain u.pressure) (hdp : WeightedClasses.MeanClass s H (rankPressureChange p r axial c u)) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn s.domain (u.covariance i j)) (A : ScalarField (PressureStream.Lift S)) (hcurrent : WeightedClasses.MeanClass s β (u.axialResidual c - A)) (hH : 9 / 10 ≤ H) (hβ : β ≤ H + 1 - 2 * κ) : WeightedClasses.MeanClass s β ((CorrectionState.rankStage p r axial c u).axialResidual c - A)

A previously accumulated temporal alias remains subtracted through the rank stage. No size assumption on that unchanged alias is needed here.

theorem NavierStokes.CorrectionStep.AngularContinuous.neg {D : Type} {u : CorrectionState.Oscillation D} (hu : AngularContinuous u) : AngularContinuous (-u)

theorem NavierStokes.CorrectionStep.AngularContinuous.sub {D : Type} {u v : CorrectionState.Oscillation D} (hu : AngularContinuous u) (hv : AngularContinuous v) : AngularContinuous (u - v)

theorem NavierStokes.CorrectionStep.bilinearCovariance_neg_left {D : Type} (u v : CorrectionState.Oscillation D) : CorrectionState.bilinearCovariance (-u) v = -CorrectionState.bilinearCovariance u v

theorem NavierStokes.CorrectionStep.bilinearCovariance_neg_right {D : Type} (u v : CorrectionState.Oscillation D) : CorrectionState.bilinearCovariance u (-v) = -CorrectionState.bilinearCovariance u v

theorem NavierStokes.CorrectionStep.bilinearCovariance_sub_left {D : Type} {u v w : CorrectionState.Oscillation D} (hu : AngularContinuous u) (hv : AngularContinuous v) (hw : AngularContinuous w) : CorrectionState.bilinearCovariance (u - v) w = CorrectionState.bilinearCovariance u w - CorrectionState.bilinearCovariance v w

theorem NavierStokes.CorrectionStep.bilinearCovariance_sub_right {D : Type} {u v w : CorrectionState.Oscillation D} (hu : AngularContinuous u) (hv : AngularContinuous v) (hw : AngularContinuous w) : CorrectionState.bilinearCovariance u (v - w) = CorrectionState.bilinearCovariance u v - CorrectionState.bilinearCovariance u w

noncomputable def NavierStokes.CorrectionStep.symmetricCovariance {D : Type} (u v : CorrectionState.Oscillation D) : Tensor D

Symmetric covariance, given by bilinearCovariance u v + bilinearCovariance v u.

Equations

• NavierStokes.CorrectionStep.symmetricCovariance u v = NavierStokes.CorrectionState.bilinearCovariance u v + NavierStokes.CorrectionState.bilinearCovariance v u

noncomputable def NavierStokes.CorrectionStep.signedTensorRemainder {D : Type} (primary old tangent curl : CorrectionState.Oscillation D) : Tensor D

The signed update is separated at the level of actual angular integrals. The square contains the entire tangent plus curl increment.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.signedTensorRemainder_exact {D : Type} (primary old tangent curl : CorrectionState.Oscillation D) (hp : AngularContinuous primary) (ho : AngularContinuous old) (ht : AngularContinuous tangent) (hc : AngularContinuous curl) : signedTensorRemainder primary old tangent curl = symmetricCovariance (old - primary) tangent + symmetricCovariance old curl + CorrectionState.bilinearCovariance (tangent + curl) (tangent + curl)

noncomputable def NavierStokes.CorrectionStep.subBlock {D : Type} (a b : CorrectionState.HarmonicBlock D) : CorrectionState.HarmonicBlock D

Sub block, given by { a with velocity := fun n i => a.velocity n i - b.velocity n i pressure := fun n => a.pressure n - b.pressure n }.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.subBlock_oscillation {D : Type} (a b : CorrectionState.HarmonicBlock D) (h : SameCarrier a b) : (subBlock a b).oscillation = a.oscillation - b.oscillation

theorem NavierStokes.CorrectionStep.subBlock_band {D : Type} {a b : CorrectionState.HarmonicBlock D} {N M : ℕ} (ha : a.BandLimited N) (hb : b.BandLimited M) : (subBlock a b).BandLimited (max N M)

theorem NavierStokes.CorrectionStep.symmetricCovariance_mem {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {α β : ℝ} (a b : CorrectionState.HarmonicBlock D) (hcarrier : SameCarrier a b) (N : ℕ) (hNa : a.BandLimited N) (ha : CorrectionState.HarmonicBlock.WaveBounds s P α a) (hb : CorrectionState.HarmonicBlock.WaveBounds s P β b) (ha0 : ∀ (n : ℕ) (i : Fin 3), (a.velocity n i).coeff 0 = 0) (hb0 : ∀ (n : ℕ) (i : Fin 3), (b.velocity n i).coeff 0 = 0) (hkp : ∀ (n : ℕ), a.angularFrequency n ≠ 0) (hP0 : ∀ (n : ℕ), ∀ x ∈ s.domain, 0 ≤ P n x) (hP1 : ∀ (n : ℕ), ∀ x ∈ s.domain, P n x ≤ 1) : TensorClass s (α + β) (symmetricCovariance a.oscillation b.oscillation)

theorem NavierStokes.CorrectionStep.signedTensorRemainder_mem {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {α δ β η γ : ℝ} (primary old tangent curl : CorrectionState.HarmonicBlock D) (N : ℕ) (hop : SameCarrier old primary) (hot : SameCarrier old tangent) (hoc : SameCarrier old curl) (hpN : primary.BandLimited N) (hoN : old.BandLimited N) (htN : tangent.BandLimited N) (hcN : curl.BandLimited N) (ho : CorrectionState.HarmonicBlock.WaveBounds s P α old) (hd : CorrectionState.HarmonicBlock.WaveBounds s P δ (subBlock old primary)) (ht : CorrectionState.HarmonicBlock.WaveBounds s P β tangent) (hc : CorrectionState.HarmonicBlock.WaveBounds s P η curl) (hp0 : ∀ (n : ℕ) (i : Fin 3), (primary.velocity n i).coeff 0 = 0) (ho0 : ∀ (n : ℕ) (i : Fin 3), (old.velocity n i).coeff 0 = 0) (ht0 : ∀ (n : ℕ) (i : Fin 3), (tangent.velocity n i).coeff 0 = 0) (hc0 : ∀ (n : ℕ) (i : Fin 3), (curl.velocity n i).coeff 0 = 0) (hβη : β ≤ η) (hγd : γ ≤ δ + β) (hγc : γ ≤ α + η) (hγs : γ ≤ 2 * β) (hkp : ∀ (n : ℕ), old.angularFrequency n ≠ 0) (hP0 : ∀ (n : ℕ), ∀ x ∈ s.domain, 0 ≤ P n x) (hP1 : ∀ (n : ℕ), ∀ x ∈ s.domain, P n x ≤ 1) : TensorClass s γ (signedTensorRemainder primary.oscillation old.oscillation tangent.oscillation curl.oscillation)

The three signed errors have exponents δ+β, α+η, and 2β. The stronger bound on the old-minus-primary field is used only for the first term. No class of a resulting covariance is assumed.

theorem NavierStokes.CorrectionStep.signedTensorRemainder_divergence_mem {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {σ κ : ℝ} (c : CorrectionState.Context D) (hops : MeanIncrementBounds.OperatorBounds s c.operators κ) (hσ : 1 / 5 ≤ σ) (hκ : κ ≤ 1 / 100000) (primary old tangent curl : CorrectionState.HarmonicBlock D) (N : ℕ) (hop : SameCarrier old primary) (hot : SameCarrier old tangent) (hoc : SameCarrier old curl) (hpN : primary.BandLimited N) (hoN : old.BandLimited N) (htN : tangent.BandLimited N) (hcN : curl.BandLimited N) (ho : CorrectionState.HarmonicBlock.WaveBounds s P (1 / 2) old) (hd : CorrectionState.HarmonicBlock.WaveBounds s P (17 / 25) (subBlock old primary)) (ht : CorrectionState.HarmonicBlock.WaveBounds s P (ExponentLedger.waveExponent σ - κ) tangent) (hc : CorrectionState.HarmonicBlock.WaveBounds s P (ExponentLedger.waveExponent σ + 1 / 2 - 2 * κ) curl) (hp0 : ∀ (n : ℕ) (i : Fin 3), (primary.velocity n i).coeff 0 = 0) (ho0 : ∀ (n : ℕ) (i : Fin 3), (old.velocity n i).coeff 0 = 0) (ht0 : ∀ (n : ℕ) (i : Fin 3), (tangent.velocity n i).coeff 0 = 0) (hc0 : ∀ (n : ℕ) (i : Fin 3), (curl.velocity n i).coeff 0 = 0) (hkp : ∀ (n : ℕ), old.angularFrequency n ≠ 0) (hP0 : ∀ (n : ℕ), ∀ x ∈ s.domain, 0 ≤ P n x) (hP1 : ∀ (n : ℕ), ∀ x ∈ s.domain, P n x ≤ 1) : have E := signedTensorRemainder primary.oscillation old.oscillation tangent.oscillation curl.oscillation; WeightedClasses.MeanClass s (ExponentLedger.meanExponent σ + 17 / 100) (thetaCovarianceChange c.operators E) ∧ WeightedClasses.MeanClass s (ExponentLedger.meanExponent σ + 17 / 100) (axialCovarianceChange c.operators E) ∧ WeightedClasses.MeanClass s (ExponentLedger.meanExponent σ + 17 / 100) (radialCovarianceChange c.operators E)

Applying the fixed radial derivative loss still leaves the signed tensor error at the manuscript's .17 improvement.

theorem NavierStokes.CorrectionStep.temporalIncrement_local_mem {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] (r : CorrectionState.ReconstructionData) (h : ℝ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) {cL cR H : ℝ} (ha : 0 < r.inner) (hd : 0 < r.exponent) (hcL : 0 < cL) (hcR : 0 < cR) (hh : 0 ≤ h) (L : ℕ → ℝ) (hε : ∀ (n : ℕ), 0 < c.operators.epsilon n) (hεone : ∀ (n : ℕ), c.operators.epsilon n ≤ 1) (hL : ∀ (n : ℕ), 1 ≤ L n) (hscale : ∀ (n : ℕ), ChartScales.S n ≤ L n) (U : Set S) (hU : IsOpen U) (hθclass : WeightedClasses.MeanClass (PhysicalMeanDomain.localStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL U hU) H (u.thetaResidual c)) (hzclass : WeightedClasses.MeanClass (PhysicalMeanDomain.localStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL U hU) H (u.axialResidual c)) (hθ : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.thetaResidual c n) (PhysicalMeanDomain.slowDomain U)) (hz : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.axialResidual c n) (PhysicalMeanDomain.slowDomain U)) (hpθ : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn U (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn U (u.axialResidual c n)) (hsz : ∀ (n : ℕ), PhysicalMeanDomain.SupportedOn r.inner r.outer U (u.axialResidual c n)) : MeanIncrementBounds.IncrementBounds (PhysicalMeanDomain.localStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL U hU) H (CorrectionState.temporalIncrement r h axial c u)

The native temporal construction is bounded on a genuine open slow domain. The source need not satisfy estimates at nonpositive slow time.

theorem NavierStokes.CorrectionStep.commonRatio_bandBound {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} (h : ℝ) (index : ℕ → ℕ) (gap : ℕ) (hgap : ∀ (n : ℕ), ChartScales.nativeIndex h n ≤ index n + gap) : WeightedClasses.BandBound s 0 fun (n : ℕ) => MeanChartCompatibility.commonRatio h n (index n)

theorem NavierStokes.CorrectionStep.commonTemporalIncrement_local_mem {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] (r : CorrectionState.ReconstructionData) (h : ℝ) (index : ℕ → ℕ) (gap : ℕ) (hgap : ∀ (n : ℕ), ChartScales.nativeIndex h n ≤ index n + gap) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) {cL cR H : ℝ} (ha : 0 < r.inner) (hd : 0 < r.exponent) (hcL : 0 < cL) (hcR : 0 < cR) (hh : 0 ≤ h) (L : ℕ → ℝ) (hε : ∀ (n : ℕ), 0 < c.operators.epsilon n) (hεone : ∀ (n : ℕ), c.operators.epsilon n ≤ 1) (hL : ∀ (n : ℕ), 1 ≤ L n) (hscale : ∀ (n : ℕ), ChartScales.S n ≤ L n) (U : Set S) (hU : IsOpen U) (hθclass : WeightedClasses.MeanClass (PhysicalMeanDomain.localStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL U hU) H (u.thetaResidual c)) (hzclass : WeightedClasses.MeanClass (PhysicalMeanDomain.localStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL U hU) H (u.axialResidual c)) (hθ : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.thetaResidual c n) (PhysicalMeanDomain.slowDomain U)) (hz : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.axialResidual c n) (PhysicalMeanDomain.slowDomain U)) (hpθ : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn U (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn U (u.axialResidual c n)) (hsz : ∀ (n : ℕ), PhysicalMeanDomain.SupportedOn r.inner r.outer U (u.axialResidual c n)) : MeanIncrementBounds.IncrementBounds (PhysicalMeanDomain.localStripData r.inner r.outer cL cR ha hcL hcR c.operators.epsilon L hε hεone hL U hU) H (MeanChartCompatibility.commonTemporalIncrement (fun (x : ℕ) => r) h index axial c u)

A local source estimate is transported through the actual common-clock inverse and then through the actual stream. No output estimate or global slow-domain extension is a hypothesis.

theorem NavierStokes.CorrectionStep.reconstructedPressure_local_change_mem {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] {a b d cL cR : ℝ} (ha : 0 < a) (hab : a < b) (hd : 0 < d) (hcL : 0 < cL) (hcR : 0 < cR) (ε L : ℕ → ℝ) (hε : ∀ (n : ℕ), 0 < ε n) (hεone : ∀ (n : ℕ), ε n ≤ 1) (hL : ∀ (n : ℕ), 1 ≤ L n) (U : Set S) (hU : IsOpen U) {κ H : ℝ} {o : MeanIncrementBounds.Operators (PressureStream.Lift S)} {base mean inc : MeanIncrementBounds.Triple (PressureStream.Lift S)} (ho : MeanIncrementBounds.OperatorBounds (PhysicalMeanDomain.localStripData a b cL cR ha hcL hcR ε L hε hεone hL U hU) o κ) (hb : MeanIncrementBounds.BaseBounds (PhysicalMeanDomain.localStripData a b cL cR ha hcL hcR ε L hε hεone hL U hU) base) (hm : MeanIncrementBounds.CumulativeBounds (PhysicalMeanDomain.localStripData a b cL cR ha hcL hcR ε L hε hεone hL U hU) mean) (hi : MeanIncrementBounds.IncrementBounds (PhysicalMeanDomain.localStripData a b cL cR ha hcL hcR ε L hε hεone hL U hU) H inc) (hH : 9 / 10 ≤ H) (hκ : 2 * κ ≤ 9 / 10) (W : Tensor (PressureStream.Lift S)) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn (PhysicalMeanDomain.localStripData a b cL cR ha hcL hcR ε L hε hεone hL U hU).domain (W i j)) (hf : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (MeanIncrementBounds.gr o base (MeanIncrementBounds.updated mean inc) W n) (PhysicalMeanDomain.slowDomain U)) (hg : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (MeanIncrementBounds.gr o base mean W n) (PhysicalMeanDomain.slowDomain U)) (hsf : ∀ (n : ℕ), PhysicalMeanDomain.SupportedOn a b U (MeanIncrementBounds.gr o base (MeanIncrementBounds.updated mean inc) W n)) (hsg : ∀ (n : ℕ), PhysicalMeanDomain.SupportedOn a b U (MeanIncrementBounds.gr o base mean W n)) (M : ℕ → ℝ) (v : ℕ → PressureStream.Plane) : WeightedClasses.MeanClass (PhysicalMeanDomain.localStripData a b cL cR ha hcL hcR ε L hε hεone hL U hU) H (MeanIncrementBounds.reconstructedPressure d a b hab M v o base (MeanIncrementBounds.updated mean inc) W - MeanIncrementBounds.reconstructedPressure d a b hab M v o base mean W)

Recomputed pressure on the same local slow domain. The source change class is derived from the exact nonlinear radial equation.

theorem NavierStokes.CorrectionStep.blockOfCoefficients_difference_mem {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData (D × ℝ)} {P : ℕ → D × ℝ → ℝ} {α : ℝ} (a b : LinearWaveBounds.WaveCoefficients (D × ℝ)) (kp : ℕ → ℤ) (hab : WeightedClasses.WaveClass s P α fun (n : ℕ) (x : D × ℝ) => a.amplitude n x - b.amplitude n x) : CorrectionState.HarmonicBlock.WaveBounds (SignedWaveUpdate.sectionStrip s) (fun (n : ℕ) (x : D) => P n (x, 0)) α (subBlock (SignedWaveUpdate.blockOfCoefficients a kp) (SignedWaveUpdate.blockOfCoefficients b kp))

The class of a literal coefficient difference is transported from the full cylindrical coefficient domain to the actual harmonic blocks.

theorem NavierStokes.CorrectionStep.correctedBlock_sameCarrier {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (a : LinearWaveBounds.WaveCoefficients (D × ℝ)) (s : WeightedClasses.StripData (D × ℝ)) (d : LinearWaveBounds.GraphDirections (D × ℝ)) (ψ : ℕ → D × ℝ → ℝ) (kp : ℕ → ℤ) : SameCarrier (SignedWaveUpdate.blockOfCoefficients (a.withCutoff ψ) kp) (SignedWaveUpdate.blockOfCoefficients (a.corrected s d ψ) kp)

theorem NavierStokes.CorrectionStep.correctedBlock_split {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (a : LinearWaveBounds.WaveCoefficients (D × ℝ)) (s : WeightedClasses.StripData (D × ℝ)) (d : LinearWaveBounds.GraphDirections (D × ℝ)) (ψ : ℕ → D × ℝ → ℝ) (kp : ℕ → ℤ) : (SignedWaveUpdate.blockOfCoefficients (a.corrected s d ψ) kp).oscillation = (SignedWaveUpdate.blockOfCoefficients (a.withCutoff ψ) kp).oscillation + (subBlock (SignedWaveUpdate.blockOfCoefficients (a.corrected s d ψ) kp) (SignedWaveUpdate.blockOfCoefficients (a.withCutoff ψ) kp)).oscillation

theorem NavierStokes.CorrectionStep.constructedSignedBlock_bounds {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData (D × ℝ)} {d : LinearWaveBounds.GraphDirections (D × ℝ)} {a : LinearWaveBounds.WaveCoefficients (D × ℝ)} {P₀ P : ℕ → D × ℝ → ℝ} {α₀ B κ : ℝ} (hbase : LinearWaveBounds.InputBounds s P₀ α₀ κ d a) (hκ : κ ≤ 1 / 2) {H : ℕ → D × ℝ → SignedWaveUpdate.Mat2} {T R : ℕ → D × ℝ → SignedWaveUpdate.Vec2} {mask ψ : ℕ → D × ℝ → ℝ} {v Ndot : ℕ → D × ℝ → SignedWaveUpdate.Space} {A : ℕ → D × ℝ → SignedWaveUpdate.Space →L[ℝ] SignedWaveUpdate.Space} (hcov : SignedWaveUpdate.CovarianceControl s H T) (hR : ∀ (i : Fin 2), WeightedClasses.MeanClass s (B - 1 / 2 - κ) fun (n : ℕ) (x : D × ℝ) => R n x i) (hm : WeightedClasses.UnweightedClass s 0 mask) (hv : WeightedClasses.MemClass s P 0 v) (hN : PhaseJetBounds.PolynomialJets (CurlClassBounds.phaseDomain s) (a.normal s d)) (hNdot : WeightedClasses.UnweightedClass s 0 Ndot) (hA : WeightedClasses.UnweightedClass s 0 A) {b M : ℝ} (hb : 0 < b) (hlo : ∀ (n : ℕ), ∀ x ∈ s.domain, b ≤ ‖a.normal s d n x‖) (hhi : ∀ (n : ℕ), ∀ x ∈ s.domain, ‖a.normal s d n x‖ ≤ M) (hK : WeightedClasses.BandBound s (1 / 2) fun (n : ℕ) => 1 / a.frequency n) {radius : D × ℝ → ℝ} (hradius : a.radius = fun (x : ℕ) => radius) (hψ : WeightedClasses.UnweightedClass s 0 ψ) (kp : ℕ → ℤ) (j : Fin 2) : have z := SignedWaveUpdate.coefficients a s d H T R mask v Ndot A j; have tangent := SignedWaveUpdate.blockOfCoefficients (z.withCutoff ψ) kp; have exactBlock := SignedWaveUpdate.blockOfCoefficients (z.corrected s d ψ) kp; CorrectionState.HarmonicBlock.WaveBounds (SignedWaveUpdate.sectionStrip s) (fun (n : ℕ) (x : D) => P n (x, 0)) (B - κ) tangent ∧ CorrectionState.HarmonicBlock.WaveBounds (SignedWaveUpdate.sectionStrip s) (fun (n : ℕ) (x : D) => P n (x, 0)) (B - κ) exactBlock ∧ CorrectionState.HarmonicBlock.PressureBounds (SignedWaveUpdate.sectionStrip s) (fun (n : ℕ) (x : D) => P n (x, 0)) (B + 1 / 2 - κ) exactBlock ∧ CorrectionState.HarmonicBlock.WaveBounds (SignedWaveUpdate.sectionStrip s) (fun (n : ℕ) (x : D) => P n (x, 0)) (B + 1 / 2 - 2 * κ) (subBlock exactBlock tangent)

The tangent and curl-difference blocks used by the tensor estimate are the blocks of the actual signed quotient, homogeneous pressure, cutoff, and curl construction. Their classes are conclusions from primitive data.

theorem NavierStokes.CorrectionStep.twoWaveUpdates_oscillation {D : Type} (old particular signed : CorrectionState.HarmonicBlock D) (hp : SameCarrier old particular) (hs : SameCarrier old signed) : (addBlock (addBlock old particular) signed).oscillation = old.oscillation + particular.oscillation + signed.oscillation

Both wave insertions retain their original carrier. This equality is about the actual evaluated fields, not only their coefficient arrays.

theorem NavierStokes.CorrectionStep.twoWaveUpdates_band {D : Type} {old particular signed : CorrectionState.HarmonicBlock D} {N M K : ℕ} (ho : old.BandLimited N) (hp : particular.BandLimited M) (hs : signed.BandLimited K) : (addBlock (addBlock old particular) signed).BandLimited (max (max N M) K)

theorem NavierStokes.CorrectionStep.twoWaveUpdates_cumulative {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {σ κ : ℝ} (hσ : 1 / 5 ≤ σ) (hκ : κ ≤ 1 / 100000) (primary old particular signed : CorrectionState.HarmonicBlock D) (ho : CorrectionState.HarmonicBlock.WaveBounds s P (1 / 2) old) (hod : ∀ (i : Fin 3) (j : ℤ), j ≠ 0 → WeightedClasses.WaveClass s P (17 / 25) fun (n : ℕ) (x : D) => (old.velocity n i).coeff j x - (primary.velocity n i).coeff j x) (hop : CorrectionState.HarmonicBlock.PressureBounds s P 1 old) (hp : CorrectionState.HarmonicBlock.WaveBounds s P (ExponentLedger.waveExponent σ) particular) (hpp : CorrectionState.HarmonicBlock.PressureBounds s P (ExponentLedger.waveExponent σ + 1 / 2) particular) (hs : CorrectionState.HarmonicBlock.WaveBounds s P (ExponentLedger.waveExponent σ - κ) signed) (hsp : CorrectionState.HarmonicBlock.PressureBounds s P (ExponentLedger.waveExponent σ + 1 / 2 - κ) signed) : have finalBlock := addBlock (addBlock old particular) signed; CorrectionState.HarmonicBlock.WaveBounds s P (1 / 2) finalBlock ∧ (∀ (i : Fin 3) (j : ℤ), j ≠ 0 → WeightedClasses.WaveClass s P (17 / 25) fun (n : ℕ) (x : D) => (finalBlock.velocity n i).coeff j x - (primary.velocity n i).coeff j x) ∧ CorrectionState.HarmonicBlock.PressureBounds s P 1 finalBlock

Cumulative bounds after the actual two coefficient additions. The reference field in the difference is the same primary tangent throughout.

theorem NavierStokes.CorrectionStep.temporalAtIndex_local_smooth {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] (h : ℝ) (n i : ℕ) {V : Set S} (hV : IsOpen V) {f : PressureStream.Lift S → ℝ} (hf : ContDiffOn ℝ (↑⊤) f (PhysicalMeanDomain.slowDomain V)) (hp : PhysicalMeanDomain.PeriodicOn V f) : ContDiffOn ℝ (↑⊤) (MeanChartCompatibility.temporalAtIndex h n i f) (PhysicalMeanDomain.slowDomain V)

theorem NavierStokes.CorrectionStep.temporalAtIndex_local_fast {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] (h : ℝ) (n i : ℕ) {V : Set S} (hV : IsOpen V) {f : PressureStream.Lift S → ℝ} (hf : ContDiffOn ℝ (↑⊤) f (PhysicalMeanDomain.slowDomain V)) (hp : PhysicalMeanDomain.PeriodicOn V f) {x : PressureStream.Lift S} (hx : x.2.1 ∈ V) : MeanChartCompatibility.fastAtIndex h n i (MeanChartCompatibility.temporalAtIndex h n i f) x = -TemporalMeanUpdate.centered f x

The common clock cancels the actual local residual. Localization is used only to prove a germ identity for the same torus inverse.

noncomputable def NavierStokes.CorrectionStep.gaugeTemporalPressureChange {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (g : VariableGaugeMean.GaugeData S) (h : ℝ) (index : ℕ → ℕ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) : ScalarField (PressureStream.Lift S)

Gauge temporal pressure change, given by `(temporalStageState g h index axial c u).pressure

• u.pressure`.

Equations

• NavierStokes.CorrectionStep.gaugeTemporalPressureChange g h index axial c u = (NavierStokes.VariableGaugeMean.temporalStageState g h index axial c u).pressure - u.pressure

noncomputable def NavierStokes.CorrectionStep.gaugeRankPressureChange {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (g : VariableGaugeMean.GaugeData S) (r : CorrectionState.RankData S) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) : ScalarField (PressureStream.Lift S)

Gauge rank pressure change, given by (rankStageState g r axial c u).pressure - u.pressure.

Equations

• NavierStokes.CorrectionStep.gaugeRankPressureChange g r axial c u = (NavierStokes.VariableGaugeMean.rankStageState g r axial c u).pressure - u.pressure

theorem NavierStokes.CorrectionStep.gaugeTemporalStage_covariance {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (g : VariableGaugeMean.GaugeData S) (h : ℝ) (index : ℕ → ℕ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) : (VariableGaugeMean.temporalStageState g h index axial c u).covariance = u.covariance

theorem NavierStokes.CorrectionStep.gaugeRankStage_covariance {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (g : VariableGaugeMean.GaugeData S) (r : CorrectionState.RankData S) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) : (VariableGaugeMean.rankStageState g r axial c u).covariance = u.covariance

theorem NavierStokes.CorrectionStep.gaugeTemporalStage_cumulative {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {s : WeightedClasses.StripData (PressureStream.Lift S)} (g : VariableGaugeMean.GaugeData S) (h : ℝ) (index : ℕ → ℕ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) {H : ℝ} (hu : CorrectionState.CumulativeBounds s u) (hi : MeanIncrementBounds.IncrementBounds s H (VariableGaugeMean.temporalIncrementState g h index axial c u)) (hp : WeightedClasses.MeanClass s H (gaugeTemporalPressureChange g h index axial c u)) (hH : 9 / 10 ≤ H) : CorrectionState.CumulativeBounds s (VariableGaugeMean.temporalStageState g h index axial c u)

theorem NavierStokes.CorrectionStep.gaugeRankStage_cumulative {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {s : WeightedClasses.StripData (PressureStream.Lift S)} (g : VariableGaugeMean.GaugeData S) (r : CorrectionState.RankData S) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) {H : ℝ} (hu : CorrectionState.CumulativeBounds s u) (hi : MeanIncrementBounds.IncrementBounds s H (VariableGaugeMean.rankIncrementState g r axial c u)) (hp : WeightedClasses.MeanClass s H (gaugeRankPressureChange g r axial c u)) (hH : 9 / 10 ≤ H) : CorrectionState.CumulativeBounds s (VariableGaugeMean.rankStageState g r axial c u)

theorem NavierStokes.CorrectionStep.gaugeTemporal_fastCancellation {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] {U : Set (PressureStream.Lift S)} (hU : IsOpen U) {V : Set S} (hV : IsOpen V) (hUV : ∀ x ∈ U, x.2.1 ∈ V) (g : VariableGaugeMean.GaugeData S) (h : ℝ) (index : ℕ → ℕ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (hv : c.operators.vT = (0, 0, TorusInverse.vector TorusInverse.Direction.temporal)) (hfast : ∀ (n : ℕ), c.operators.fastCoefficient n = ChartScales.Tg ^ index n * ChartScales.Q n ^ (1 + h)) (hi : MeanIncrementBounds.SmoothTriple U (VariableGaugeMean.temporalIncrementState g h index axial c u)) (hθ : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.thetaResidual c n) (PhysicalMeanDomain.slowDomain V)) (hz : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.axialResidual c n) (PhysicalMeanDomain.slowDomain V)) (hpθ : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn V (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn V (u.axialResidual c n)) (n : ℕ) {x : PressureStream.Lift S} (hx : x ∈ U) : c.operators.fastTime (VariableGaugeMean.temporalIncrementState g h index axial c u).angular n x + (u.thetaResidual c n x - meanBar (u.thetaResidual c) n x) = 0 ∧ c.operators.fastTime (VariableGaugeMean.temporalIncrementState g h index axial c u).axial n x + (u.axialResidual c n x - meanBar (u.axialResidual c) n x) = VariableGaugeMean.temporalAliasState g h index c u n (x, 0) 2

The actual gauge stream may differ from the desired axial inverse; its entire fast derivative is retained as the named axial alias.

theorem NavierStokes.CorrectionStep.gaugeTemporalStage_theta_exact {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] {U : Set (PressureStream.Lift S)} (hU : IsOpen U) {V : Set S} (hV : IsOpen V) (hUV : ∀ x ∈ U, x.2.1 ∈ V) (g : VariableGaugeMean.GaugeData S) (h : ℝ) (index : ℕ → ℕ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (hv : c.operators.vT = (0, 0, TorusInverse.vector TorusInverse.Direction.temporal)) (hfast : ∀ (n : ℕ), c.operators.fastCoefficient n = ChartScales.Tg ^ index n * ChartScales.Q n ^ (1 + h)) (hprofile : ContDiffOn ℝ (↑⊤) c.operators.radialProfile U) (hb : MeanIncrementBounds.SmoothTriple U c.base) (hm : MeanIncrementBounds.SmoothTriple U u.mean) (hi : MeanIncrementBounds.SmoothTriple U (VariableGaugeMean.temporalIncrementState g h index axial c u)) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (u.covariance i j)) (hθ : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.thetaResidual c n) (PhysicalMeanDomain.slowDomain V)) (hz : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.axialResidual c n) (PhysicalMeanDomain.slowDomain V)) (hpθ : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn V (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn V (u.axialResidual c n)) : MeanIncrementBounds.Agree U ((VariableGaugeMean.temporalStageState g h index axial c u).thetaResidual c) (meanBar (u.thetaResidual c) + MeanIncrementBounds.thetaRemainder c.operators c.base u.mean (VariableGaugeMean.temporalIncrementState g h index axial c u))

theorem NavierStokes.CorrectionStep.gaugeTemporalStage_axial_exact {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] {U : Set (PressureStream.Lift S)} (hU : IsOpen U) {V : Set S} (hV : IsOpen V) (hUV : ∀ x ∈ U, x.2.1 ∈ V) (g : VariableGaugeMean.GaugeData S) (h : ℝ) (index : ℕ → ℕ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (hv : c.operators.vT = (0, 0, TorusInverse.vector TorusInverse.Direction.temporal)) (hfast : ∀ (n : ℕ), c.operators.fastCoefficient n = ChartScales.Tg ^ index n * ChartScales.Q n ^ (1 + h)) (hprofile : ContDiffOn ℝ (↑⊤) c.operators.radialProfile U) (hb : MeanIncrementBounds.SmoothTriple U c.base) (hm : MeanIncrementBounds.SmoothTriple U u.mean) (hi : MeanIncrementBounds.SmoothTriple U (VariableGaugeMean.temporalIncrementState g h index axial c u)) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (u.covariance i j)) (hp : MeanIncrementBounds.SmoothOn U u.pressure) (hnp : MeanIncrementBounds.SmoothOn U (VariableGaugeMean.temporalStageState g h index axial c u).pressure) (hθ : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.thetaResidual c n) (PhysicalMeanDomain.slowDomain V)) (hz : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.axialResidual c n) (PhysicalMeanDomain.slowDomain V)) (hpθ : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn V (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn V (u.axialResidual c n)) : MeanIncrementBounds.Agree U (fun (n : ℕ) (x : PressureStream.Lift S) => (VariableGaugeMean.temporalStageState g h index axial c u).axialResidual c n x - VariableGaugeMean.temporalAliasState g h index c u n (x, 0) 2) (meanBar (u.axialResidual c) + MeanIncrementBounds.axialRemainder c.operators c.base u.mean (VariableGaugeMean.temporalIncrementState g h index axial c u) (gaugeTemporalPressureChange g h index axial c u))

theorem NavierStokes.CorrectionStep.gaugeTemporalStage_mean_gain {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] {s : WeightedClasses.StripData (PressureStream.Lift S)} {V : Set S} (hV : IsOpen V) (hUV : ∀ x ∈ s.domain, x.2.1 ∈ V) (g : VariableGaugeMean.GaugeData S) (h : ℝ) (index : ℕ → ℕ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) {H κ β : ℝ} (hv : c.operators.vT = (0, 0, TorusInverse.vector TorusInverse.Direction.temporal)) (hfast : ∀ (n : ℕ), c.operators.fastCoefficient n = ChartScales.Tg ^ index n * ChartScales.Q n ^ (1 + h)) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hb : MeanIncrementBounds.BaseBounds s c.base) (hu : CorrectionState.CumulativeBounds s u) (hi : MeanIncrementBounds.IncrementBounds s H (VariableGaugeMean.temporalIncrementState g h index axial c u)) (hdp : WeightedClasses.MeanClass s H (gaugeTemporalPressureChange g h index axial c u)) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn s.domain (u.covariance i j)) (hbarθ : WeightedClasses.MeanClass s β (meanBar (u.thetaResidual c))) (hbarz : WeightedClasses.MeanClass s β (meanBar (u.axialResidual c))) (hθ : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.thetaResidual c n) (PhysicalMeanDomain.slowDomain V)) (hz : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.axialResidual c n) (PhysicalMeanDomain.slowDomain V)) (hpθ : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn V (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn V (u.axialResidual c n)) (hH : 9 / 10 ≤ H) (hβ : β ≤ H + 1 - 2 * κ) : WeightedClasses.MeanClass s β ((VariableGaugeMean.temporalStageState g h index axial c u).thetaResidual c) ∧ WeightedClasses.MeanClass s β fun (n : ℕ) (x : PressureStream.Lift S) => (VariableGaugeMean.temporalStageState g h index axial c u).axialResidual c n x - VariableGaugeMean.temporalAliasState g h index c u n (x, 0) 2

The actual variable-gauge temporal update has the same differentiated mean remainder as the fixed-gauge update. Its axial alias remains explicit.

theorem NavierStokes.CorrectionStep.gaugeTemporalStage_next_mean {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] {s : WeightedClasses.StripData (PressureStream.Lift S)} {V : Set S} (hV : IsOpen V) (hUV : ∀ x ∈ s.domain, x.2.1 ∈ V) (g : VariableGaugeMean.GaugeData S) (h : ℝ) (index : ℕ → ℕ) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) {σ κ : ℝ} (hσ : 1 / 5 ≤ σ) (hκ : κ ≤ 1 / 100000) (hv : c.operators.vT = (0, 0, TorusInverse.vector TorusInverse.Direction.temporal)) (hfast : ∀ (n : ℕ), c.operators.fastCoefficient n = ChartScales.Tg ^ index n * ChartScales.Q n ^ (1 + h)) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hb : MeanIncrementBounds.BaseBounds s c.base) (hu : CorrectionState.CumulativeBounds s u) (hi : MeanIncrementBounds.IncrementBounds s (ExponentLedger.meanUpdateExponent σ κ) (VariableGaugeMean.temporalIncrementState g h index axial c u)) (hdp : WeightedClasses.MeanClass s (ExponentLedger.meanUpdateExponent σ κ) (gaugeTemporalPressureChange g h index axial c u)) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn s.domain (u.covariance i j)) (hbarθ : WeightedClasses.MeanClass s (ExponentLedger.meanExponent σ + 17 / 100) (meanBar (u.thetaResidual c))) (hbarz : WeightedClasses.MeanClass s (ExponentLedger.meanExponent σ + 17 / 100) (meanBar (u.axialResidual c))) (hθ : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.thetaResidual c n) (PhysicalMeanDomain.slowDomain V)) (hz : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.axialResidual c n) (PhysicalMeanDomain.slowDomain V)) (hpθ : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn V (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn V (u.axialResidual c n)) : WeightedClasses.MeanClass s (ExponentLedger.meanExponent (σ + 1 / 10)) ((VariableGaugeMean.temporalStageState g h index axial c u).thetaResidual c) ∧ WeightedClasses.MeanClass s (ExponentLedger.meanExponent (σ + 1 / 10)) fun (n : ℕ) (x : PressureStream.Lift S) => (VariableGaugeMean.temporalStageState g h index axial c u).axialResidual c n x - VariableGaugeMean.temporalAliasState g h index c u n (x, 0) 2

noncomputable def NavierStokes.CorrectionStep.gaugeRefreshPressureAlias {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (g : VariableGaugeMean.GaugeData S) (c : CorrectionState.Context (PressureStream.Lift S)) (old current : CorrectionState.State (PressureStream.Lift S)) : CorrectionState.State (PressureStream.Lift S)

Gauge refresh pressure alias as an element of State (PressureStream.Lift S).

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.gaugeRefreshPressureAlias_separated {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (g : VariableGaugeMean.GaugeData S) (c : CorrectionState.Context (PressureStream.Lift S)) (old current : CorrectionState.State (PressureStream.Lift S)) (other : CorrectionState.Oscillation (PressureStream.Lift S)) (he : current.errors.aliasError = other + VariableGaugeMean.pressureAliasState g c old) : (gaugeRefreshPressureAlias g c old current).errors.aliasError = other + VariableGaugeMean.pressureAliasState g c current

theorem NavierStokes.CorrectionStep.gaugeRefreshPressureAlias_fullResidual {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (g : VariableGaugeMean.GaugeData S) (c : CorrectionState.Context (PressureStream.Lift S)) (old current : CorrectionState.State (PressureStream.Lift S)) : fullResidual c (gaugeRefreshPressureAlias g c old current) = fullResidual c current

theorem NavierStokes.CorrectionStep.gaugeRefreshPressureAlias_fullGoodResidual {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (g : VariableGaugeMean.GaugeData S) (c : CorrectionState.Context (PressureStream.Lift S)) (old current : CorrectionState.State (PressureStream.Lift S)) : fullGoodResidual c (gaugeRefreshPressureAlias g c old current) = fullGoodResidual c current - (VariableGaugeMean.pressureAliasState g c current - VariableGaugeMean.pressureAliasState g c old)

noncomputable def NavierStokes.CorrectionStep.gaugePressureAliasBlock {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (g : VariableGaugeMean.GaugeData S) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (b : CorrectionState.HarmonicBlock (PressureStream.Lift S)) : CorrectionState.HarmonicBlock (PressureStream.Lift S)

Gauge pressure alias block, given by ErrorHarmonics.zeroBlock b.frequency b.phase b.angularFrequency (fun n x => pressureAliasState g c u n (x, 0)).

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.gaugeTemporalAliasBlock {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (g : VariableGaugeMean.GaugeData S) (h : ℝ) (index : ℕ → ℕ) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (b : CorrectionState.HarmonicBlock (PressureStream.Lift S)) : CorrectionState.HarmonicBlock (PressureStream.Lift S)

Gauge temporal alias block, given by ErrorHarmonics.zeroBlock b.frequency b.phase b.angularFrequency (fun n x => temporalAliasState g h index c u n (x, 0)).

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.gaugePressureAliasBlock_represents {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (g : VariableGaugeMean.GaugeData S) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (b : CorrectionState.HarmonicBlock (PressureStream.Lift S)) : (gaugePressureAliasBlock g c u b).oscillation = VariableGaugeMean.pressureAliasState g c u

theorem NavierStokes.CorrectionStep.gaugeTemporalAliasBlock_represents {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (g : VariableGaugeMean.GaugeData S) (h : ℝ) (index : ℕ → ℕ) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (b : CorrectionState.HarmonicBlock (PressureStream.Lift S)) : (gaugeTemporalAliasBlock g h index c u b).oscillation = VariableGaugeMean.temporalAliasState g h index c u

theorem NavierStokes.CorrectionStep.gaugePressureAliasBlock_band {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (g : VariableGaugeMean.GaugeData S) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (b : CorrectionState.HarmonicBlock (PressureStream.Lift S)) : (gaugePressureAliasBlock g c u b).BandLimited 0

theorem NavierStokes.CorrectionStep.gaugeTemporalAliasBlock_band {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (g : VariableGaugeMean.GaugeData S) (h : ℝ) (index : ℕ → ℕ) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (b : CorrectionState.HarmonicBlock (PressureStream.Lift S)) : (gaugeTemporalAliasBlock g h index c u b).BandLimited 0

theorem NavierStokes.CorrectionStep.physicalResidual_decomposition {ι : Type u_1} {Q : ℝ} (hQ : 0 < Q) (h : ℝ) (k n : ℕ) (c : CorrectionState.Context PhysicalResidualBridge.Lift) (s : CorrectionState.State PhysicalResidualBridge.Lift) (hop : PhysicalResidualBridge.MatchesAt c.operators (PhysicalResidualBridge.commonGraph Q h k) n) {V : Set PhysicalResidualBridge.Lift} (hmean : LiftedMeanResidual.MeanHypotheses V c s) {labels : ℕ → Finset ι} {blocks : ι → CorrectionState.HarmonicBlock PhysicalResidualBridge.Lift} {gaussian aliasError : ι → HarmonicResidual.BlockCoefficients PhysicalResidualBridge.Lift} (hrep : HarmonicResidual.BlockRepresentation labels blocks gaussian aliasError s) (hregular : HarmonicResidual.ExtractionRegular V c s labels blocks gaussian aliasError n) (hR : ∀ x ∈ HarmonicResidual.liftDomain V, x.1.1 ≠ 0) {p₀ : PhysicalResidualBridge.Cylinder → ℝ} (hB : ∀ (i : Fin 3), ContDiffOn ℝ (↑⊤) (fun (x : PhysicalResidualBridge.Cylinder) => PhysicalResidualBridge.baseComponents c n x i) (HarmonicResidual.liftDomain V)) (ha : ∀ (i : Fin 3), ContDiffOn ℝ (↑⊤) (fun (x : PhysicalResidualBridge.Cylinder) => PhysicalResidualBridge.incrementComponents s n x i) (HarmonicResidual.liftDomain V)) (hp₀ : ContDiffOn ℝ (↑⊤) p₀ (HarmonicResidual.liftDomain V)) (hp : ContDiffOn ℝ (↑⊤) (s.totalPressureIncrement n) (HarmonicResidual.liftDomain V)) {t : ℝ} {q : ProblemStatement.Space} (hz : (t, q) ∈ (PhysicalResidualBridge.commonGraph Q h k).source (HarmonicResidual.liftDomain V)) (hbase : ∀ (i : Fin 3), PhysicalResidualBridge.graphResidual (Q ^ h) PhysicalResidualBridge.ScaledGraph.radius (PhysicalResidualBridge.commonGraph Q h k).radial PhysicalResidualBridge.ScaledGraph.angular (PhysicalResidualBridge.commonGraph Q h k).axial (PhysicalResidualBridge.commonGraph Q h k).temporal (PhysicalResidualBridge.baseComponents c n) p₀ ((PhysicalResidualBridge.commonGraph Q h k).map (t, q)) i = LiftedMeanResidual.virtualDivergence c n ((PhysicalResidualBridge.commonGraph Q h k).map (t, q)) i + s.errors.base n ((PhysicalResidualBridge.commonGraph Q h k).map (t, q)) i) {u : ProblemStatement.VelocityField} {P : ProblemStatement.PressureField} (hu : ContDiffAt ℝ 2 u (t, CylindricalResidual.chart q)) (hP : DifferentiableAt ℝ P (t, CylindricalResidual.chart q)) (huRep : (fun (z : ProblemStatement.SpaceTime) => u (z.1, CylindricalResidual.chart z.2)) =ᶠ[nhds (t, q)] fun (z : ℝ × ProblemStatement.Space) => (CylindricalResidual.frame (z.2.ofLp 1)) ((PhysicalResidualBridge.commonGraph Q h k).velocity (fun (y : PhysicalResidualBridge.Cylinder) (j : Fin 3) => PhysicalResidualBridge.baseComponents c n y j + PhysicalResidualBridge.incrementComponents s n y j) z)) (hpRep : CylindricalResidual.pressurePullback P =ᶠ[nhds (t, q)] (PhysicalResidualBridge.commonGraph Q h k).pressure fun (y : PhysicalResidualBridge.Cylinder) => p₀ y + s.totalPressureIncrement n y) (i : Fin 3) : Q ^ (2 * CoordinateAlgebra.A h + 1 / 2) * ((CylindricalResidual.frame (-q.ofLp 1)) (ProblemStatement.navierStokesResidual u P t (CylindricalResidual.chart q))).ofLp i = ∑ l ∈ labels n, (HarmonicResidual.residualBlock c s (blocks l) (gaussian l) (aliasError l)).oscillation n ((PhysicalResidualBridge.commonGraph Q h k).map (t, q)) i + s.meanGoodResidual c n ((PhysicalResidualBridge.commonGraph Q h k).map (t, q)).1 i + s.errors.total n ((PhysicalResidualBridge.commonGraph Q h k).map (t, q)) i

The coefficient/mean/error decomposition is a decomposition of the actual viscosity-one Cartesian residual after the proved graph scaling.

theorem NavierStokes.CorrectionStep.angularMean_const_mul (a : ℂ) (f : ℝ → ℂ) : (HarmonicFields.angularMean fun (θ : ℝ) => a * f θ) = a * HarmonicFields.angularMean f

theorem NavierStokes.CorrectionStep.block_velocity_pullback_at {D : Type} (a b : CorrectionState.HarmonicBlock D) (n m : ℕ) (φ : D → D) (scale : ℝ) (x : D) (i : Fin 3) (j : ℤ) (ha : HarmonicFields.ConjugateSymmetric (a.velocity n i)) (hb : HarmonicFields.ConjugateSymmetric (b.velocity m i)) (hkp : a.angularFrequency n = b.angularFrequency m) (hkn : a.angularFrequency n ≠ 0) (hphase : a.frequency n * a.phase n x = b.frequency m * b.phase m (φ x)) (hfield : ∀ (θ : ℝ), a.oscillation n (x, θ) i = scale * b.oscillation m (φ x, θ) i) : (a.velocity n i).coeff j x = ↑scale * (b.velocity m i).coeff j (φ x)

Equality of actual real block fields, together with the literal carrier transformation, determines the transformed source coefficients. Conjugacy is used explicitly to recover the full complex field.

theorem NavierStokes.CorrectionStep.assembledSigned_stateTensor_mem {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {ι : Type} {s : WeightedClasses.StripData D} {P : ι → ℕ → D → ℝ} {α δ β η γ : ℝ} (f : LabelSumBounds.SignedFamily s P α δ β η) (hβη : β ≤ η) (hγd : γ ≤ δ + β) (hγc : γ ≤ α + η) (hγs : γ ≤ 2 * β) {d h : ℝ} {vr vt : TorusInverse.Plane} {sys : PartitionedCovariance.SlotSystem d h vr vt} (labels : ℕ → Finset ι) (label : ℕ → ι → SlotColoring.Label) (hinj : ∀ (n : ℕ), Set.InjOn (label n) ↑(labels n)) (hlevel : ∀ (n : ℕ), ∀ l ∈ labels n, 1 ≤ (label n l).1) (χ : ℕ → D → LabelSumBounds.WindowPoint) (hχ : ∀ (n : ℕ), ContinuousOn (χ n) s.domain) (Y : ℕ → D → TorusInverse.Plane) (hp : LabelSumBounds.SupportedOscillations sys label χ Y s.domain fun (l : ι) => (f.primary l).oscillation) (ho : LabelSumBounds.SupportedOscillations sys label χ Y s.domain fun (l : ι) => (f.old l).oscillation) (ht : LabelSumBounds.SupportedOscillations sys label χ Y s.domain fun (l : ι) => (f.tangent l).oscillation) (hc : LabelSumBounds.SupportedOscillations sys label χ Y s.domain fun (l : ι) => (f.curl l).oscillation) (u : CorrectionState.State D) (hu : u.oscillation = LabelSumBounds.fieldSum labels fun (l : ι) => (f.old l).oscillation) (m : MeanIncrementBounds.Triple D) (p : ScalarField D) (q : CorrectionState.OscillatoryScalar D) (e : CorrectionState.ExcludedErrors D) : have primary := LabelSumBounds.fieldSum labels fun (l : ι) => (f.primary l).oscillation; have tangent := LabelSumBounds.fieldSum labels fun (l : ι) => (f.tangent l).oscillation; have curl := LabelSumBounds.fieldSum labels fun (l : ι) => (f.curl l).oscillation; TensorClass s γ ((u.addIncrement m p (tangent + curl) q e).covariance - u.covariance - symmetricCovariance primary tangent)

Uniform label bounds and the proved slot overlap bound control the actual state covariance after adding every signed tangent and curl.

theorem NavierStokes.CorrectionStep.waveStage_residual_mem {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ α β H γ : ℝ} (c : CorrectionState.Context D) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hκ : κ ≤ 1 / 2) (hR : ∀ x ∈ s.domain, 0 < c.operators.radius x) (u v : CorrectionState.State D) (hmean : v.mean = u.mean) (hm : MeanIncrementBounds.IncrementBounds s H u.mean) (hbase : MeanIncrementBounds.SmoothTriple s.domain c.base) (a b : CorrectionState.HarmonicBlock D) {M N : ℕ} (ha : CorrectionState.HarmonicBlock.WaveBounds s P α a) (hb : CorrectionState.HarmonicBlock.WaveBounds s P β b) (ha0 : HarmonicWaveInteraction.ZeroMode a) (hb0 : HarmonicWaveInteraction.ZeroMode b) (hM : a.BandLimited M) (hN : b.BandLimited N) (hΦ : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (a.phase n) s.domain) (hk : ∀ (n : ℕ), a.frequency n ≠ 0) (hkp : ∀ (n : ℕ), a.angularFrequency n ≠ 0) (hda : HarmonicWaveInteraction.ModeSolenoidal s c a) (hdb : HarmonicWaveInteraction.ModeSolenoidal s c (HarmonicWaveInteraction.withCarrier a b)) (hNormal : ∀ (i : Fin 3), WeightedClasses.UnweightedClass s 0 fun (n : ℕ) (x : D) => (HarmonicMeanInteraction.slowNormal c ho hR a.phase n x).ofLp i) (hFreq : WeightedClasses.BandBound s (-(1 / 2)) a.frequency) (hAng : WeightedClasses.BandBound s (-(1 / 2)) fun (n : ℕ) => ↑(a.angularFrequency n)) (hP0 : ∀ (n : ℕ), ∀ x ∈ s.domain, 0 ≤ P n x) (hP1 : ∀ (n : ℕ), ∀ x ∈ s.domain, P n x ≤ 1) (hpa : ∀ (n : ℕ), HarmonicResidual.SmoothCoefficients s.domain (a.pressure n)) (hpb : ∀ (n : ℕ), HarmonicResidual.SmoothCoefficients s.domain (b.pressure n)) (G g A₀ A₁ : HarmonicResidual.BlockCoefficients D) (hA : ∀ (n : ℕ) (i : Fin 3), HarmonicFields.BandLimited (A₁ n i - A₀ n i) 0) (hlinear : ∀ (i : Fin 3) (j : ℤ), j ≠ 0 → WeightedClasses.WaveClass s P γ fun (n : ℕ) (x : D) => ((HarmonicResidual.residualBlock c u a G A₀).velocity n i).coeff j x + ((HarmonicWaveInteraction.linearGoodBlock c a b g).velocity n i).coeff j x) (hγm : γ ≤ β + H - 1 / 2) (hγc : γ ≤ α + β - κ) (hγs : γ ≤ β + β - κ) : CorrectionState.HarmonicBlock.WaveBounds s P γ (HarmonicResidual.residualBlock c v (HarmonicWaveInteraction.addBlock a b) (G + g) A₁)

The only linear input is a bound on the literal old residual plus the literal linear increment after its Gaussian subtraction. All nonlinear terms of the actual new residual are derived by the harmonic calculus.

noncomputable def NavierStokes.CorrectionStep.zeroTriple {D : Type} : MeanIncrementBounds.Triple D

Zero triple, given by ⟨0, 0, 0⟩.

Equations

• NavierStokes.CorrectionStep.zeroTriple = { radial := 0, angular := 0, axial := 0 }

theorem NavierStokes.CorrectionStep.updated_zeroTriple {D : Type} (m : MeanIncrementBounds.Triple D) : MeanIncrementBounds.updated m zeroTriple = m

noncomputable def NavierStokes.CorrectionStep.gaugeWaveStage {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (g : VariableGaugeMean.GaugeData S) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (w : CorrectionState.Oscillation (PressureStream.Lift S)) (q : CorrectionState.OscillatoryScalar (PressureStream.Lift S)) (e : CorrectionState.ExcludedErrors (PressureStream.Lift S)) : CorrectionState.State (PressureStream.Lift S)

Insert the actual oscillation and its actual excluded error, then reconstruct pressure from the resulting literal covariance.

Equations

• NavierStokes.CorrectionStep.gaugeWaveStage g c u w q e = NavierStokes.VariableGaugeMean.reconstructState g c (u.addIncrement NavierStokes.CorrectionStep.zeroTriple 0 w q e)

noncomputable def NavierStokes.CorrectionStep.gaugeWavePressureChange {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (g : VariableGaugeMean.GaugeData S) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (w : CorrectionState.Oscillation (PressureStream.Lift S)) (q : CorrectionState.OscillatoryScalar (PressureStream.Lift S)) (e : CorrectionState.ExcludedErrors (PressureStream.Lift S)) : ScalarField (PressureStream.Lift S)

Gauge wave pressure change, given by (gaugeWaveStage g c u w q e).pressure - u.pressure.

Equations

• NavierStokes.CorrectionStep.gaugeWavePressureChange g c u w q e = (NavierStokes.CorrectionStep.gaugeWaveStage g c u w q e).pressure - u.pressure

theorem NavierStokes.CorrectionStep.gaugeWaveStage_mean {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (g : VariableGaugeMean.GaugeData S) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (w : CorrectionState.Oscillation (PressureStream.Lift S)) (q : CorrectionState.OscillatoryScalar (PressureStream.Lift S)) (e : CorrectionState.ExcludedErrors (PressureStream.Lift S)) : (gaugeWaveStage g c u w q e).mean = u.mean

theorem NavierStokes.CorrectionStep.gaugeWaveStage_covariance {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] (g : VariableGaugeMean.GaugeData S) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (w : CorrectionState.Oscillation (PressureStream.Lift S)) (q : CorrectionState.OscillatoryScalar (PressureStream.Lift S)) (e : CorrectionState.ExcludedErrors (PressureStream.Lift S)) (hu : AngularContinuous u.oscillation) (hw : AngularContinuous w) : (gaugeWaveStage g c u w q e).covariance = u.covariance + covarianceIncrement u.oscillation w

theorem NavierStokes.CorrectionStep.gaugeWaveStage_theta_change {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {U : Set (PressureStream.Lift S)} (hU : IsOpen U) (g : VariableGaugeMean.GaugeData S) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (w : CorrectionState.Oscillation (PressureStream.Lift S)) (q : CorrectionState.OscillatoryScalar (PressureStream.Lift S)) (e : CorrectionState.ExcludedErrors (PressureStream.Lift S)) (hu : AngularContinuous u.oscillation) (hw : AngularContinuous w) (hb : MeanIncrementBounds.SmoothTriple U c.base) (hm : MeanIncrementBounds.SmoothTriple U u.mean) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (u.covariance i j)) (hX : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (covarianceIncrement u.oscillation w i j)) : MeanIncrementBounds.Agree U ((gaugeWaveStage g c u w q e).thetaResidual c - u.thetaResidual c) (thetaCovarianceChange c.operators (covarianceIncrement u.oscillation w))

theorem NavierStokes.CorrectionStep.gaugeWaveStage_gr_change {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {U : Set (PressureStream.Lift S)} (hU : IsOpen U) (g : VariableGaugeMean.GaugeData S) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (w : CorrectionState.Oscillation (PressureStream.Lift S)) (q : CorrectionState.OscillatoryScalar (PressureStream.Lift S)) (e : CorrectionState.ExcludedErrors (PressureStream.Lift S)) (hu : AngularContinuous u.oscillation) (hw : AngularContinuous w) (hb : MeanIncrementBounds.SmoothTriple U c.base) (hm : MeanIncrementBounds.SmoothTriple U u.mean) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (u.covariance i j)) (hX : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (covarianceIncrement u.oscillation w i j)) : MeanIncrementBounds.Agree U ((gaugeWaveStage g c u w q e).gr c - u.gr c) (radialCovarianceChange c.operators (covarianceIncrement u.oscillation w))

theorem NavierStokes.CorrectionStep.axialResidual_pressure_change {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} (hU : IsOpen U) (o : MeanIncrementBounds.Operators D) {b m : MeanIncrementBounds.Triple D} (hb : MeanIncrementBounds.SmoothTriple U b) (hm : MeanIncrementBounds.SmoothTriple U m) (W : Tensor D) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (W i j)) (p q T : ScalarField D) (hp : MeanIncrementBounds.SmoothOn U p) (hq : MeanIncrementBounds.SmoothOn U q) : MeanIncrementBounds.Agree U (MeanIncrementBounds.axialResidual o b m W (p + q) T - MeanIncrementBounds.axialResidual o b m W p T) (o.dz q)

theorem NavierStokes.CorrectionStep.gaugeWaveStage_axial_change {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {U : Set (PressureStream.Lift S)} (hU : IsOpen U) (g : VariableGaugeMean.GaugeData S) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (w : CorrectionState.Oscillation (PressureStream.Lift S)) (q : CorrectionState.OscillatoryScalar (PressureStream.Lift S)) (e : CorrectionState.ExcludedErrors (PressureStream.Lift S)) (hu : AngularContinuous u.oscillation) (hw : AngularContinuous w) (hb : MeanIncrementBounds.SmoothTriple U c.base) (hm : MeanIncrementBounds.SmoothTriple U u.mean) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (u.covariance i j)) (hX : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn U (covarianceIncrement u.oscillation w i j)) (hp : MeanIncrementBounds.SmoothOn U u.pressure) (hδp : MeanIncrementBounds.SmoothOn U (gaugeWavePressureChange g c u w q e)) : MeanIncrementBounds.Agree U ((gaugeWaveStage g c u w q e).axialResidual c - u.axialResidual c) (axialCovarianceChange c.operators (covarianceIncrement u.oscillation w) + c.operators.dz (gaugeWavePressureChange g c u w q e))

theorem NavierStokes.CorrectionStep.gaugeWaveStage_mean_changes_mem {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {s : WeightedClasses.StripData (PressureStream.Lift S)} {α κ : ℝ} (g : VariableGaugeMean.GaugeData S) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (w : CorrectionState.Oscillation (PressureStream.Lift S)) (q : CorrectionState.OscillatoryScalar (PressureStream.Lift S)) (e : CorrectionState.ExcludedErrors (PressureStream.Lift S)) (hu : AngularContinuous u.oscillation) (hw : AngularContinuous w) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hb : MeanIncrementBounds.BaseBounds s c.base) (hm : CorrectionState.CumulativeBounds s u) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn s.domain (u.covariance i j)) (hX : TensorClass s α (covarianceIncrement u.oscillation w)) (hδp : WeightedClasses.MeanClass s (α - κ) (gaugeWavePressureChange g c u w q e)) : WeightedClasses.MeanClass s (α - κ) ((gaugeWaveStage g c u w q e).thetaResidual c - u.thetaResidual c) ∧ WeightedClasses.MeanClass s (α - κ) ((gaugeWaveStage g c u w q e).axialResidual c - u.axialResidual c) ∧ WeightedClasses.MeanClass s (α - κ) ((gaugeWaveStage g c u w q e).gr c - u.gr c)

theorem NavierStokes.CorrectionStep.gaugeWaveStage_cumulative {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {s : WeightedClasses.StripData (PressureStream.Lift S)} {α : ℝ} (g : VariableGaugeMean.GaugeData S) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (w : CorrectionState.Oscillation (PressureStream.Lift S)) (q : CorrectionState.OscillatoryScalar (PressureStream.Lift S)) (e : CorrectionState.ExcludedErrors (PressureStream.Lift S)) (hm : CorrectionState.CumulativeBounds s u) (hδp : WeightedClasses.MeanClass s α (gaugeWavePressureChange g c u w q e)) (hα : 9 / 10 ≤ α) : CorrectionState.CumulativeBounds s (gaugeWaveStage g c u w q e)

structure NavierStokes.CorrectionStep.SignedParameters (D : Type) [NormedAddCommGroup D] [NormedSpace ℝ D] : Type

Fixed primitive data of one primary signed slot. No output field, output estimate, or state transition is stored in this record.

• base : LinearWaveBounds.WaveCoefficients (D × ℝ)

  Base wave coefficients for the signed correction step.

• directions : LinearWaveBounds.GraphDirections (D × ℝ)

  Directions of SignedParameters, of type LinearWaveBounds.GraphDirections (D × ℝ).

• matrix : ℕ → D × ℝ → SignedWaveUpdate.Mat2

  Matrix of SignedParameters, of type ℕ → D × ℝ → SignedWaveUpdate.Mat2.

• target : ℕ → D × ℝ → SignedWaveUpdate.Vec2

  Target of SignedParameters, of type ℕ → D × ℝ → SignedWaveUpdate.Vec2.

• mask : ℕ → D × ℝ → ℝ

  Mask of SignedParameters, of type ℕ → D × ℝ → ℝ.

• fundamental : ℕ → D × ℝ → ProblemStatement.Space

  Fundamental of SignedParameters, of type ℕ → D × ℝ → ProblemStatement.Space.

• normalMotion : ℕ → D × ℝ → ProblemStatement.Space

  Normal motion of SignedParameters, of type ℕ → D × ℝ → ProblemStatement.Space.

• action : ℕ → D × ℝ → ProblemStatement.Space →L[ℝ] ProblemStatement.Space

  Action of SignedParameters, of type ℕ → D × ℝ → ProblemStatement.Space →L[ℝ] ProblemStatement.Space.

• cutoff : ℕ → D × ℝ → ℝ

  Cutoff of SignedParameters, of type ℕ → D × ℝ → ℝ.

• angularFrequency : ℕ → ℤ

  Angular frequency of SignedParameters, of type ℕ → ℤ.

• column : Fin 2

  Column of SignedParameters, of type Fin 2.

noncomputable def NavierStokes.CorrectionStep.SignedParameters.coefficients {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : SignedParameters D) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : LinearWaveBounds.WaveCoefficients (D × ℝ)

Coefficients, constructed using SignedWaveUpdate.coefficients.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.SignedParameters.exactBlock {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : SignedParameters D) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : CorrectionState.HarmonicBlock D

Exact block, constructed using SignedWaveUpdate.blockOfCoefficients.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.SignedParameters.tangentBlock {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : SignedParameters D) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : CorrectionState.HarmonicBlock D

Tangent block, given by SignedWaveUpdate.blockOfCoefficients ((p.coefficients s request).withCutoff p.cutoff) p.angularFrequency.

Equations

• p.tangentBlock s request = NavierStokes.SignedWaveUpdate.blockOfCoefficients ((p.coefficients s request).withCutoff p.cutoff) p.angularFrequency

noncomputable def NavierStokes.CorrectionStep.SignedParameters.curlBlock {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : SignedParameters D) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : CorrectionState.HarmonicBlock D

Curl block, given by subBlock (p.exactBlock s request) (p.tangentBlock s request).

Equations

• p.curlBlock s request = NavierStokes.CorrectionStep.subBlock (p.exactBlock s request) (p.tangentBlock s request)

theorem NavierStokes.CorrectionStep.SignedParameters.exactBlock_split {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : SignedParameters D) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : (p.exactBlock s request).oscillation = (p.tangentBlock s request).oscillation + (p.curlBlock s request).oscillation

theorem NavierStokes.CorrectionStep.sectionStrip_productStrip {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (s : WeightedClasses.StripData D) : SignedWaveUpdate.sectionStrip (HarmonicWaveInteraction.productStrip s) = s

theorem NavierStokes.CorrectionStep.SignedParameters.exactBlock_band {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : SignedParameters D) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : (p.exactBlock s request).BandLimited 1

theorem NavierStokes.CorrectionStep.SignedParameters.tangentBlock_band {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : SignedParameters D) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : (p.tangentBlock s request).BandLimited 1

theorem NavierStokes.CorrectionStep.SignedParameters.curlBlock_band {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : SignedParameters D) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : (p.curlBlock s request).BandLimited 1

theorem NavierStokes.CorrectionStep.SignedParameters.exactBlock_zero {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : SignedParameters D) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) (n : ℕ) (i : Fin 3) : ((p.exactBlock s request).velocity n i).coeff 0 = 0

theorem NavierStokes.CorrectionStep.SignedParameters.tangentBlock_zero {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : SignedParameters D) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) (n : ℕ) (i : Fin 3) : ((p.tangentBlock s request).velocity n i).coeff 0 = 0

theorem NavierStokes.CorrectionStep.SignedParameters.block_bounds {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : SignedParameters D) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) {P₀ : ℕ → D × ℝ → ℝ} {P : ℕ → D → ℝ} {α₀ B κ : ℝ} (hbase : LinearWaveBounds.InputBounds (HarmonicWaveInteraction.productStrip s) P₀ α₀ κ p.directions p.base) (hκ : κ ≤ 1 / 2) (hcov : SignedWaveUpdate.CovarianceControl (HarmonicWaveInteraction.productStrip s) p.matrix p.target) (hR : ∀ (i : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) (B - 1 / 2 - κ) fun (n : ℕ) (x : D × ℝ) => request n x i) (hm : WeightedClasses.UnweightedClass (HarmonicWaveInteraction.productStrip s) 0 p.mask) (hv : WeightedClasses.MemClass (HarmonicWaveInteraction.productStrip s) (fun (n : ℕ) (x : D × ℝ) => P n x.1) 0 p.fundamental) (hN : PhaseJetBounds.PolynomialJets (CurlClassBounds.phaseDomain (HarmonicWaveInteraction.productStrip s)) (p.base.normal (HarmonicWaveInteraction.productStrip s) p.directions)) (hNdot : WeightedClasses.UnweightedClass (HarmonicWaveInteraction.productStrip s) 0 p.normalMotion) (hA : WeightedClasses.UnweightedClass (HarmonicWaveInteraction.productStrip s) 0 p.action) {b M : ℝ} (hb : 0 < b) (hlo : ∀ (n : ℕ), ∀ x ∈ (HarmonicWaveInteraction.productStrip s).domain, b ≤ ‖p.base.normal (HarmonicWaveInteraction.productStrip s) p.directions n x‖) (hhi : ∀ (n : ℕ), ∀ x ∈ (HarmonicWaveInteraction.productStrip s).domain, ‖p.base.normal (HarmonicWaveInteraction.productStrip s) p.directions n x‖ ≤ M) (hK : WeightedClasses.BandBound (HarmonicWaveInteraction.productStrip s) (1 / 2) fun (n : ℕ) => 1 / p.base.frequency n) {radius : D × ℝ → ℝ} (hradius : p.base.radius = fun (x : ℕ) => radius) (hψ : WeightedClasses.UnweightedClass (HarmonicWaveInteraction.productStrip s) 0 p.cutoff) : CorrectionState.HarmonicBlock.WaveBounds s P (B - κ) (p.tangentBlock s request) ∧ CorrectionState.HarmonicBlock.WaveBounds s P (B - κ) (p.exactBlock s request) ∧ CorrectionState.HarmonicBlock.PressureBounds s P (B + 1 / 2 - κ) (p.exactBlock s request) ∧ CorrectionState.HarmonicBlock.WaveBounds s P (B + 1 / 2 - 2 * κ) (p.curlBlock s request)

Every output bound here is derived from the same explicit signed quotient and curl, on the exact product strip used by the current state.

structure NavierStokes.CorrectionStep.SignedParameters.Control {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : SignedParameters D) (s : WeightedClasses.StripData D) (P₀ : ℕ → D × ℝ → ℝ) (P : ℕ → D → ℝ) (α₀ κ : ℝ) : Type

Control data, collecting baseBounds, kappa_le_half, covariance, mask, fundamental, normal and their compatibility conditions.

• baseBounds : LinearWaveBounds.InputBounds (HarmonicWaveInteraction.productStrip s) P₀ α₀ κ p.directions p.base
• kappa_le_half : κ ≤ 1 / 2
• covariance : SignedWaveUpdate.CovarianceControl (HarmonicWaveInteraction.productStrip s) p.matrix p.target

  Covariance of Control, of type SignedWaveUpdate.CovarianceControl (HarmonicWaveInteraction.productStrip s) p.matrix p.target.

• mask : WeightedClasses.UnweightedClass (HarmonicWaveInteraction.productStrip s) 0 p.mask
• fundamental : WeightedClasses.MemClass (HarmonicWaveInteraction.productStrip s) (fun (n : ℕ) (x : D × ℝ) => P n x.1) 0 p.fundamental
• normal : PhaseJetBounds.PolynomialJets (CurlClassBounds.phaseDomain (HarmonicWaveInteraction.productStrip s)) (p.base.normal (HarmonicWaveInteraction.productStrip s) p.directions)
• normalMotion : WeightedClasses.UnweightedClass (HarmonicWaveInteraction.productStrip s) 0 p.normalMotion
• action : WeightedClasses.UnweightedClass (HarmonicWaveInteraction.productStrip s) 0 p.action
• lower : ℝ

  Lower of Control, of type ℝ.

• upper : ℝ

  Upper of Control, of type ℝ.

• lower_pos : 0 < self.lower
• norm_lower (n : ℕ) (x : D × ℝ) : x ∈ (HarmonicWaveInteraction.productStrip s).domain → self.lower ≤ ‖p.base.normal (HarmonicWaveInteraction.productStrip s) p.directions n x‖
• norm_upper (n : ℕ) (x : D × ℝ) : x ∈ (HarmonicWaveInteraction.productStrip s).domain → ‖p.base.normal (HarmonicWaveInteraction.productStrip s) p.directions n x‖ ≤ self.upper
• inverseFrequency : WeightedClasses.BandBound (HarmonicWaveInteraction.productStrip s) (1 / 2) fun (n : ℕ) => 1 / p.base.frequency n
• radius : D × ℝ → ℝ

  Radius of Control, of type D × ℝ → ℝ.

• radius_eq : p.base.radius = fun (x : ℕ) => self.radius
• cutoff : WeightedClasses.UnweightedClass (HarmonicWaveInteraction.productStrip s) 0 p.cutoff

theorem NavierStokes.CorrectionStep.SignedParameters.Control.bounds {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : SignedParameters D} {s : WeightedClasses.StripData D} {P₀ : ℕ → D × ℝ → ℝ} {P : ℕ → D → ℝ} {α₀ κ B : ℝ} (h : p.Control s P₀ P α₀ κ) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) (hR : ∀ (i : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) (B - 1 / 2 - κ) fun (n : ℕ) (x : D × ℝ) => request n x i) : CorrectionState.HarmonicBlock.WaveBounds s P (B - κ) (p.tangentBlock s request) ∧ CorrectionState.HarmonicBlock.WaveBounds s P (B - κ) (p.exactBlock s request) ∧ CorrectionState.HarmonicBlock.PressureBounds s P (B + 1 / 2 - κ) (p.exactBlock s request) ∧ CorrectionState.HarmonicBlock.WaveBounds s P (B + 1 / 2 - 2 * κ) (p.curlBlock s request)

noncomputable def NavierStokes.CorrectionStep.stateSignedBlock (p : SignedParameters LocalSignedRequest.Point) (s : WeightedClasses.StripData LocalSignedRequest.Point) (patch : SignedStressPrimitive.Patch) (coord : ℝ) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) : CorrectionState.HarmonicBlock LocalSignedRequest.Point

State signed block, given by p.exactBlock s (LocalSignedRequest.fullRequest s patch coord c u).

Equations

• NavierStokes.CorrectionStep.stateSignedBlock p s patch coord c u = p.exactBlock s (NavierStokes.LocalSignedRequest.fullRequest s patch coord c u)

noncomputable def NavierStokes.CorrectionStep.stateSignedTangent (p : SignedParameters LocalSignedRequest.Point) (s : WeightedClasses.StripData LocalSignedRequest.Point) (patch : SignedStressPrimitive.Patch) (coord : ℝ) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) : CorrectionState.HarmonicBlock LocalSignedRequest.Point

State signed tangent, given by p.tangentBlock s (LocalSignedRequest.fullRequest s patch coord c u).

Equations

• NavierStokes.CorrectionStep.stateSignedTangent p s patch coord c u = p.tangentBlock s (NavierStokes.LocalSignedRequest.fullRequest s patch coord c u)

noncomputable def NavierStokes.CorrectionStep.stateSignedCurl (p : SignedParameters LocalSignedRequest.Point) (s : WeightedClasses.StripData LocalSignedRequest.Point) (patch : SignedStressPrimitive.Patch) (coord : ℝ) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) : CorrectionState.HarmonicBlock LocalSignedRequest.Point

State signed curl, given by p.curlBlock s (LocalSignedRequest.fullRequest s patch coord c u).

Equations

• NavierStokes.CorrectionStep.stateSignedCurl p s patch coord c u = p.curlBlock s (NavierStokes.LocalSignedRequest.fullRequest s patch coord c u)

noncomputable def NavierStokes.CorrectionStep.stateSignedGaussian (p : SignedParameters LocalSignedRequest.Point) (s : WeightedClasses.StripData LocalSignedRequest.Point) (patch : SignedStressPrimitive.Patch) (coord : ℝ) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) : CorrectionState.HarmonicBlock LocalSignedRequest.Point

State signed gaussian, constructed using SignedWaveUpdate.gaussianBlock.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.signedWaveStage {ι : Type} (g : VariableGaugeMean.GaugeData PressureStream.Plane) (parameters : ι → SignedParameters LocalSignedRequest.Point) (labels : ℕ → Finset ι) (s : WeightedClasses.StripData LocalSignedRequest.Point) (patch : SignedStressPrimitive.Patch) (coord : ℝ) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) : CorrectionState.State LocalSignedRequest.Point

Every signed block and Gaussian field is computed from the actual current residual. The pressure is then recomputed from the updated field.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.stateSignedBlock_bounds {coord : ℝ} (U : LocalSignedRequest.SlowRegion coord) (patch : SignedStressPrimitive.Patch) {cL cR : ℝ} (hcL : 0 < cL) (hcR : 0 < cR) (ε L : ℕ → ℝ) (hε : ∀ (n : ℕ), 0 < ε n) (hεone : ∀ (n : ℕ), ε n ≤ 1) (hL : ∀ (n : ℕ), 1 ≤ L n) (s : WeightedClasses.StripData LocalSignedRequest.Point) (hs : s = LocalSignedRequest.movingStripData U patch.a patch.b cL cR ⋯ hcL hcR ε L hε hεone hL) (p : SignedParameters LocalSignedRequest.Point) {P₀ : ℕ → LocalSignedRequest.Point × ℝ → ℝ} {P : ℕ → LocalSignedRequest.Point → ℝ} {α₀ κ B : ℝ} (hcontrol : p.Control s P₀ P α₀ κ) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) (hθ : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.thetaResidual c n) (PhysicalMeanDomain.slowDomain U.carrier)) (hz : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.axialResidual c n) (PhysicalMeanDomain.slowDomain U.carrier)) (hsθ : ∀ (n : ℕ), LocalSignedRequest.MovingSupport patch.a patch.b coord U.carrier (u.thetaResidual c n)) (hsz : ∀ (n : ℕ), LocalSignedRequest.MovingSupport patch.a patch.b coord U.carrier (u.axialResidual c n)) (hcθ : WeightedClasses.MeanClass s (B + 1 / 2 - κ) (u.thetaResidual c)) (hcz : WeightedClasses.MeanClass s (B + 1 / 2 - κ) (u.axialResidual c)) : CorrectionState.HarmonicBlock.WaveBounds s P (B - κ) (stateSignedTangent p s patch coord c u) ∧ CorrectionState.HarmonicBlock.WaveBounds s P (B - κ) (stateSignedBlock p s patch coord c u) ∧ CorrectionState.HarmonicBlock.PressureBounds s P (B + 1 / 2 - κ) (stateSignedBlock p s patch coord c u) ∧ CorrectionState.HarmonicBlock.WaveBounds s P (B + 1 / 2 - 2 * κ) (stateSignedCurl p s patch coord c u)

The requested tensor is not supplied as an arbitrary input: these classes start from the current state's two actual mean residuals.

noncomputable def NavierStokes.CorrectionStep.linearBlockField {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (a b : CorrectionState.HarmonicBlock D) : CorrectionState.Oscillation D

The actual real linearized cylindrical residual of a block, evaluated with the carrier of the old spatial label.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.linearCoefficients_field {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} (hU : IsOpen U) (c : CorrectionState.Context D) (a b : CorrectionState.HarmonicBlock D) (n : ℕ) (hr : ContDiffOn ℝ (↑⊤) (HarmonicResidual.contextFrame c n).radial U) (hz : ContDiffOn ℝ (↑⊤) (HarmonicResidual.contextFrame c n).axial U) (hB : ∀ (i : Fin 3), ContDiffOn ℝ (↑⊤) (fun (y : D) => HarmonicResidual.contextBase c n y i) U) (hb : ∀ (i : Fin 3), HarmonicResidual.SmoothCoefficients U (b.velocity n i)) (hp : HarmonicResidual.SmoothCoefficients U (b.pressure n)) (hΦ : ContDiffOn ℝ (↑⊤) (a.phase n) U) {x : D × ℝ} (hx : x ∈ HarmonicResidual.liftDomain U) (i : Fin 3) : (HarmonicFields.field (HarmonicWaveInteraction.linearCoefficients c a b n i) (a.frequency n) (a.phase n) (a.angularFrequency n) x).re = linearBlockField c a b n x i

theorem NavierStokes.CorrectionStep.linearGoodBlock_cancel {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} (hU : IsOpen U) (c : CorrectionState.Context D) (a b source good : CorrectionState.HarmonicBlock D) (g : HarmonicResidual.BlockCoefficients D) (n : ℕ) (hr : ContDiffOn ℝ (↑⊤) (HarmonicResidual.contextFrame c n).radial U) (hz : ContDiffOn ℝ (↑⊤) (HarmonicResidual.contextFrame c n).axial U) (hB : ∀ (i : Fin 3), ContDiffOn ℝ (↑⊤) (fun (y : D) => HarmonicResidual.contextBase c n y i) U) (hb : ∀ (i : Fin 3), HarmonicResidual.SmoothCoefficients U (b.velocity n i)) (hp : HarmonicResidual.SmoothCoefficients U (b.pressure n)) (hΦ : ContDiffOn ℝ (↑⊤) (a.phase n) U) (hkp : a.angularFrequency n ≠ 0) (hs : ∀ (i : Fin 3), HarmonicFields.ConjugateSymmetric (source.velocity n i)) (hg : ∀ (i : Fin 3), HarmonicFields.ConjugateSymmetric (good.velocity n i)) {x : D} (hx : x ∈ U) (j : ℤ) (hj : j ≠ 0) (i : Fin 3) (hcancel : ∀ (θ : ℝ), linearBlockField c a b n (x, θ) i + (HarmonicWaveInteraction.withCarrier a source).oscillation n (x, θ) i = (HarmonicWaveInteraction.withCarrier a good).oscillation n (x, θ) i + (HarmonicFields.field (g n i) (a.frequency n) (a.phase n) (a.angularFrequency n) (x, θ)).re) : (source.velocity n i).coeff j x + ((HarmonicWaveInteraction.linearGoodBlock c a b g).velocity n i).coeff j x = (good.velocity n i).coeff j x

An actual field cancellation determines every nonzero coefficient. The Gaussian is subtracted only after its full field is retained in the identity. The conclusion uses the literal linearGoodBlock.

theorem NavierStokes.CorrectionStep.linearGoodBlock_cancel_mem {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {γ : ℝ} (c : CorrectionState.Context D) (a b source good : CorrectionState.HarmonicBlock D) (g : HarmonicResidual.BlockCoefficients D) (hr : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (HarmonicResidual.contextFrame c n).radial s.domain) (hz : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (HarmonicResidual.contextFrame c n).axial s.domain) (hB : MeanIncrementBounds.SmoothTriple s.domain c.base) (hb : ∀ (n : ℕ) (i : Fin 3), HarmonicResidual.SmoothCoefficients s.domain (b.velocity n i)) (hp : ∀ (n : ℕ), HarmonicResidual.SmoothCoefficients s.domain (b.pressure n)) (hΦ : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (a.phase n) s.domain) (hkp : ∀ (n : ℕ), a.angularFrequency n ≠ 0) (hs : ∀ (n : ℕ) (i : Fin 3), HarmonicFields.ConjugateSymmetric (source.velocity n i)) (hg : ∀ (n : ℕ) (i : Fin 3), HarmonicFields.ConjugateSymmetric (good.velocity n i)) (hgood : CorrectionState.HarmonicBlock.WaveBounds s P γ good) (hcancel : ∀ (n : ℕ), ∀ x ∈ s.domain, ∀ (θ : ℝ) (i : Fin 3), linearBlockField c a b n (x, θ) i + (HarmonicWaveInteraction.withCarrier a source).oscillation n (x, θ) i = (HarmonicWaveInteraction.withCarrier a good).oscillation n (x, θ) i + (HarmonicFields.field (g n i) (a.frequency n) (a.phase n) (a.angularFrequency n) (x, θ)).re) (i : Fin 3) (j : ℤ) : j ≠ 0 → WeightedClasses.WaveClass s P γ fun (n : ℕ) (x : D) => (source.velocity n i).coeff j x + ((HarmonicWaveInteraction.linearGoodBlock c a b g).velocity n i).coeff j x

noncomputable def NavierStokes.CorrectionStep.contextRealBase {D : Type} (c : CorrectionState.Context D) (n : ℕ) (x : D × ℝ) : Fin 3 → ℝ

Context real base, given by ![c.base.radial n x.1, c.base.angular n x.1, c.base.axial n x.1].

Equations

• NavierStokes.CorrectionStep.contextRealBase c n x = ![c.base.radial n x.1, c.base.angular n x.1, c.base.axial n x.1]

theorem NavierStokes.CorrectionStep.complexBase_eq_realLift {D : Type} (c : CorrectionState.Context D) (n : ℕ) : complexBase c n = LinearWaveResidual.realLift (contextRealBase c n)

theorem NavierStokes.CorrectionStep.contextRealBase_smooth {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} {c : CorrectionState.Context D} (hB : MeanIncrementBounds.SmoothTriple U c.base) (n : ℕ) (i : Fin 3) : ContDiffOn ℝ (↑⊤) (fun (x : D × ℝ) => contextRealBase c n x i) (HarmonicResidual.liftDomain U)

theorem NavierStokes.CorrectionStep.linearBlockField_eq_real {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} (hU : IsOpen U) (c : CorrectionState.Context D) (a b : CorrectionState.HarmonicBlock D) (n : ℕ) (hr : ContDiffOn ℝ (↑⊤) (radialDirection c n) (HarmonicResidual.liftDomain U)) (hz : ContDiffOn ℝ (↑⊤) (axialDirection c n) (HarmonicResidual.liftDomain U)) (hB : MeanIncrementBounds.SmoothTriple U c.base) (hb : ∀ (i : Fin 3), ContDiffOn ℝ (↑⊤) (fun (x : D × ℝ) => (HarmonicWaveInteraction.withCarrier a b).oscillation n x i) (HarmonicResidual.liftDomain U)) (hp : ContDiffOn ℝ (↑⊤) ((HarmonicWaveInteraction.withCarrier a b).oscillatoryPressure n) (HarmonicResidual.liftDomain U)) {x : D × ℝ} (hx : x ∈ HarmonicResidual.liftDomain U) : linearBlockField c a b n x = LinearWaveResidual.realComponentLinearResidual (c.operators.epsilon n) (fun (y : D × ℝ) => c.operators.radius y.1) (radialDirection c n) angularDirection (axialDirection c n) (timeDirection c n) (contextRealBase c n) ((HarmonicWaveInteraction.withCarrier a b).oscillation n) ((HarmonicWaveInteraction.withCarrier a b).oscillatoryPressure n) x

structure NavierStokes.CorrectionStep.WaveFrameMatch {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (c : CorrectionState.Context D) (s : WeightedClasses.StripData (D × ℝ)) (d : LinearWaveBounds.GraphDirections (D × ℝ)) (a : LinearWaveBounds.WaveCoefficients (D × ℝ)) : Prop

Primitive equality of the direction and background data. This record contains no residual identity and no statement about a corrected field.

• epsilon (n : ℕ) : s.epsilon n = c.operators.epsilon n
• radius (n : ℕ) : a.radius n = fun (y : D × ℝ) => c.operators.radius y.1
• radial (n : ℕ) : d.radialField n = radialDirection c n
• angular : d.angular = (0, 1)
• axial (n : ℕ) : d.axialField s n = axialDirection c n
• time (n : ℕ) : (LinearWaveResidual.timeDirection (s.epsilon n) (d.fastField n) fun (x : D × ℝ) => d.slow) = timeDirection c n
• radialBase (n : ℕ) (x : D × ℝ) : a.radialBase n x = c.base.radial n x.1
• angularBase (n : ℕ) (x : D × ℝ) : a.radius n x * a.frequencyBase n x = c.base.angular n x.1
• axialBase (n : ℕ) (x : D × ℝ) : a.axialBase n x = c.base.axial n x.1

theorem NavierStokes.CorrectionStep.WaveFrameMatch.base {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {c : CorrectionState.Context D} {s : WeightedClasses.StripData (D × ℝ)} {d : LinearWaveBounds.GraphDirections (D × ℝ)} {a : LinearWaveBounds.WaveCoefficients (D × ℝ)} (h : WaveFrameMatch c s d a) (n : ℕ) : LinearWaveResidual.complexBase (a.radius n) (a.radialBase n) (a.frequencyBase n) (a.axialBase n) = complexBase c n

theorem NavierStokes.CorrectionStep.WaveFrameMatch.harmonicResidual {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {c : CorrectionState.Context D} {s : WeightedClasses.StripData (D × ℝ)} {d : LinearWaveBounds.GraphDirections (D × ℝ)} {z : LinearWaveBounds.WaveCoefficients (D × ℝ)} (h : WaveFrameMatch c s d z) (n : ℕ) : z.harmonicResidual s d n = LinearWaveResidual.linearResidual (c.operators.epsilon n) (fun (y : D × ℝ) => c.operators.radius y.1) (radialDirection c n) angularDirection (axialDirection c n) (timeDirection c n) (complexBase c n) (HarmonicCalculus.vectorMode (z.frequency n) (z.phase n) (z.amplitude n)) (HarmonicCalculus.mode (z.frequency n) (z.phase n) (z.pressure n))

theorem NavierStokes.CorrectionStep.linearBlockField_eq_modeResidual {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {U : Set D} (hU : IsOpen U) (c : CorrectionState.Context D) (a b : CorrectionState.HarmonicBlock D) (s : WeightedClasses.StripData (D × ℝ)) (d : LinearWaveBounds.GraphDirections (D × ℝ)) (z : LinearWaveBounds.WaveCoefficients (D × ℝ)) (hm : WaveFrameMatch c s d z) (n : ℕ) (hB : MeanIncrementBounds.SmoothTriple U c.base) (hr : ContDiffOn ℝ (↑⊤) (radialDirection c n) (HarmonicResidual.liftDomain U)) (hz : ContDiffOn ℝ (↑⊤) (axialDirection c n) (HarmonicResidual.liftDomain U)) (hphase : ContDiffOn ℝ (↑⊤) (z.phase n) (HarmonicResidual.liftDomain U)) (hv : ∀ (i : Fin 3), ContDiffOn ℝ (↑⊤) (fun (x : D × ℝ) => z.amplitude n x i) (HarmonicResidual.liftDomain U)) (hp : ContDiffOn ℝ (↑⊤) (z.pressure n) (HarmonicResidual.liftDomain U)) (hvel : (HarmonicWaveInteraction.withCarrier a b).oscillation n = fun (x : D × ℝ) (i : Fin 3) => (HarmonicCalculus.vectorMode (z.frequency n) (z.phase n) (z.amplitude n) x i).re) (hpress : (HarmonicWaveInteraction.withCarrier a b).oscillatoryPressure n = fun (x : D × ℝ) => (HarmonicCalculus.mode (z.frequency n) (z.phase n) (z.pressure n) x).re) {x : D × ℝ} (hx : x ∈ HarmonicResidual.liftDomain U) : linearBlockField c a b n x = fun (i : Fin 3) => (z.harmonicResidual s d n x i).re

theorem NavierStokes.CorrectionStep.SignedParameters.Control.full_bounds {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : SignedParameters D} {s : WeightedClasses.StripData D} {P₀ : ℕ → D × ℝ → ℝ} {P : ℕ → D → ℝ} {α₀ κ B : ℝ} (h : p.Control s P₀ P α₀ κ) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) (hR : ∀ (i : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) (B - 1 / 2 - κ) fun (n : ℕ) (x : D × ℝ) => request n x i) : have z := p.coefficients s request; WeightedClasses.WaveClass (HarmonicWaveInteraction.productStrip s) (fun (n : ℕ) (x : D × ℝ) => P n x.1) (B - κ) (z.corrected (HarmonicWaveInteraction.productStrip s) p.directions p.cutoff).amplitude ∧ WeightedClasses.WaveClass (HarmonicWaveInteraction.productStrip s) (fun (n : ℕ) (x : D × ℝ) => P n x.1) (B + 1 / 2 - κ) (z.corrected (HarmonicWaveInteraction.productStrip s) p.directions p.cutoff).pressure ∧ (WeightedClasses.WaveClass (HarmonicWaveInteraction.productStrip s) (fun (n : ℕ) (x : D × ℝ) => P n x.1) (B + 1 / 2 - 2 * κ) fun (n : ℕ) (x : D × ℝ) => (z.corrected (HarmonicWaveInteraction.productStrip s) p.directions p.cutoff).amplitude n x - (z.withCutoff p.cutoff).amplitude n x) ∧ WeightedClasses.WaveClass (HarmonicWaveInteraction.productStrip s) (fun (n : ℕ) (x : D × ℝ) => P n x.1) (B + 1 / 2 - 4 * κ) (z.constructedGood (HarmonicWaveInteraction.productStrip s) p.directions p.cutoff)

noncomputable def NavierStokes.CorrectionStep.SignedParameters.goodBlock {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : SignedParameters D) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : CorrectionState.HarmonicBlock D

Good block, constructed using SignedWaveUpdate.coefficientBlock.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.SignedParameters.Control.good_bounds {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : SignedParameters D} {s : WeightedClasses.StripData D} {P₀ : ℕ → D × ℝ → ℝ} {P : ℕ → D → ℝ} {α₀ κ B : ℝ} (h : p.Control s P₀ P α₀ κ) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) (hR : ∀ (i : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) (B - 1 / 2 - κ) fun (n : ℕ) (x : D × ℝ) => request n x i) : CorrectionState.HarmonicBlock.WaveBounds s P (B + 1 / 2 - 4 * κ) (p.goodBlock s request)

structure NavierStokes.CorrectionStep.SignedParameters.Dynamics {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : SignedParameters D) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : Type

The ODE and phase data of the fixed primary column, before performing any signed update. All equalities concern primitive inputs.

• slope : ℕ → ℝ

  Slope of Dynamics, of type ℕ → ℝ.

• angular : SignedWaveUpdate.AngularInputs (HarmonicWaveInteraction.productStrip s) p.directions p.base p.matrix p.target request p.mask p.fundamental p.normalMotion p.action p.cutoff self.slope
• angular_direction : p.directions.angular = (0, 1)
• angular_frequency (n : ℕ) : p.base.frequency n * self.slope n = ↑(p.angularFrequency n)
• angular_nonzero (n : ℕ) : p.angularFrequency n ≠ 0
• geometry (n : ℕ) : CurlClassBounds.CylindricalGeometry (HarmonicWaveInteraction.productStrip s).domain (p.base.radius n) (p.directions.radialField n) (fun (x : D × ℝ) => p.directions.angular) (p.directions.axialField (HarmonicWaveInteraction.productStrip s) n)
• matrix_frozen : SignedWaveUpdate.FrozenAlong p.directions.fast p.matrix
• target_frozen : SignedWaveUpdate.FrozenAlong p.directions.fast p.target
• request_frozen : SignedWaveUpdate.FrozenAlong p.directions.fast request
• mask_frozen : SignedWaveUpdate.FrozenAlong p.directions.fast p.mask
• frequency_nonzero (n : ℕ) : p.base.frequency n ≠ 0
• ode (n : ℕ) (x : D × ℝ) : x ∈ (HarmonicWaveInteraction.productStrip s).domain → HarmonicCalculus.along (p.directions.fastField n) (p.fundamental n) x = TangentProjection.projectedRhs (p.base.normal (HarmonicWaveInteraction.productStrip s) p.directions n x) (p.normalMotion n x) (p.fundamental n x) ((p.action n x) (p.fundamental n x)) 0 (s.epsilon n * p.base.frequency n ^ 2 * ‖p.base.normal (HarmonicWaveInteraction.productStrip s) p.directions n x‖ ^ 2)
• action_eq (n : ℕ) (x : D × ℝ) : x ∈ (HarmonicWaveInteraction.productStrip s).domain → CurlClassBounds.complexify ((p.action n x) (p.fundamental n x)) = LinearWaveResidual.shear (p.base.radius n) (p.base.frequencyBase n) (p.base.axialBase n) (p.directions.radialField n) (fun (y : D × ℝ) => CurlClassBounds.complexify (p.fundamental n y)) x
• cutoff_smooth (n : ℕ) : ContDiff ℝ (↑⊤) (p.cutoff n)

theorem NavierStokes.CorrectionStep.SignedParameters.Dynamics.phase_eq {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : SignedParameters D} {s : WeightedClasses.StripData D} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (h : p.Dynamics s request) (n : ℕ) (x : D) (θ : ℝ) : p.base.frequency n * p.base.phase n (x, θ) = p.base.frequency n * p.base.phase n (x, 0) + ↑(p.angularFrequency n) * θ

theorem NavierStokes.CorrectionStep.SignedParameters.Dynamics.good_represents {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : SignedParameters D} {s : WeightedClasses.StripData D} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (h : p.Dynamics s request) : (p.goodBlock s request).oscillation = fun (n : ℕ) (x : D × ℝ) (i : Fin 3) => ((p.coefficients s request).constructedGood (HarmonicWaveInteraction.productStrip s) p.directions p.cutoff n x i * HarmonicCalculus.carrier (p.base.frequency n) (p.base.phase n) x).re

theorem NavierStokes.CorrectionStep.SignedParameters.Dynamics.exact_represents {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : SignedParameters D} {s : WeightedClasses.StripData D} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (h : p.Dynamics s request) : have z := (p.coefficients s request).corrected (HarmonicWaveInteraction.productStrip s) p.directions p.cutoff; ((p.exactBlock s request).oscillation = fun (n : ℕ) (x : D × ℝ) (i : Fin 3) => (HarmonicCalculus.vectorMode (p.base.frequency n) (p.base.phase n) (z.amplitude n) x i).re) ∧ (p.exactBlock s request).oscillatoryPressure = fun (n : ℕ) (x : D × ℝ) => (HarmonicCalculus.mode (p.base.frequency n) (p.base.phase n) (z.pressure n) x).re

theorem NavierStokes.CorrectionStep.SignedParameters.Dynamics.linear_identity {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : SignedParameters D} {s : WeightedClasses.StripData D} {P₀ : ℕ → D × ℝ → ℝ} {P : ℕ → D → ℝ} {α₀ κ B : ℝ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (h : p.Dynamics s request) (hc : p.Control s P₀ P α₀ κ) (hR : ∀ (i : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) (B - 1 / 2 - κ) fun (n : ℕ) (x : D × ℝ) => request n x i) : have z := p.coefficients s request; ∀ (n : ℕ), ∀ x ∈ (HarmonicWaveInteraction.productStrip s).domain, (z.corrected (HarmonicWaveInteraction.productStrip s) p.directions p.cutoff).harmonicResidual (HarmonicWaveInteraction.productStrip s) p.directions n x = fun (i : Fin 3) => (z.constructedGood (HarmonicWaveInteraction.productStrip s) p.directions p.cutoff n x i + LinearWaveBounds.excludedSlotError p.directions p.cutoff z.amplitude 0 n x i) * HarmonicCalculus.carrier (p.base.frequency n) (p.base.phase n) x

theorem NavierStokes.CorrectionStep.productStrip_domain {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (s : WeightedClasses.StripData D) : (HarmonicWaveInteraction.productStrip s).domain = HarmonicResidual.liftDomain s.domain

theorem NavierStokes.CorrectionStep.withCarrier_of_same {D : Type} {a b : CorrectionState.HarmonicBlock D} (h : SameCarrier a b) : HarmonicWaveInteraction.withCarrier a b = b

theorem NavierStokes.CorrectionStep.SignedParameters.frame_corrected {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : SignedParameters D) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) {c : CorrectionState.Context D} (h : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) p.directions p.base) : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) p.directions ((p.coefficients s request).corrected (HarmonicWaveInteraction.productStrip s) p.directions p.cutoff)

noncomputable def NavierStokes.CorrectionStep.SignedParameters.gaussianBlock {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : SignedParameters D) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : CorrectionState.HarmonicBlock D

Gaussian block, given by SignedWaveUpdate.gaussianBlock (p.coefficients s request) p.directions p.cutoff p.angularFrequency.

Equations

• p.gaussianBlock s request = NavierStokes.SignedWaveUpdate.gaussianBlock (p.coefficients s request) p.directions p.cutoff p.angularFrequency

theorem NavierStokes.CorrectionStep.SignedParameters.exactBlock_pressure_zero {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : SignedParameters D) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) (n : ℕ) : ((p.exactBlock s request).pressure n).coeff 0 = 0

theorem NavierStokes.CorrectionStep.SignedParameters.Dynamics.gaussian_represents {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : SignedParameters D} {s : WeightedClasses.StripData D} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (h : p.Dynamics s request) : (p.gaussianBlock s request).oscillation = fun (n : ℕ) (x : D × ℝ) (i : Fin 3) => (LinearWaveBounds.excludedSlotError p.directions p.cutoff (p.coefficients s request).amplitude 0 n x i * HarmonicCalculus.carrier (p.base.frequency n) (p.base.phase n) x).re

theorem NavierStokes.CorrectionStep.SignedParameters.Dynamics.context_linear_identity {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : SignedParameters D} {s : WeightedClasses.StripData D} {P₀ : ℕ → D × ℝ → ℝ} {P : ℕ → D → ℝ} {α₀ κ B : ℝ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (h : p.Dynamics s request) (hc : p.Control s P₀ P α₀ κ) (hR : ∀ (i : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) (B - 1 / 2 - κ) fun (n : ℕ) (x : D × ℝ) => request n x i) (c : CorrectionState.Context D) (hB : MeanIncrementBounds.SmoothTriple s.domain c.base) (hmatch : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) p.directions p.base) (a : CorrectionState.HarmonicBlock D) (hcarrier : SameCarrier a (p.exactBlock s request)) (n : ℕ) (x : D × ℝ) (hx : x.1 ∈ s.domain) : linearBlockField c a (p.exactBlock s request) n x = (p.goodBlock s request).oscillation n x + (p.gaussianBlock s request).oscillation n x

The actual signed field, with the literal Context operators, has the computed good residual plus its computed Gaussian error.

theorem NavierStokes.CorrectionStep.SignedParameters.Dynamics.linearGood_bounds {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : SignedParameters D} {s : WeightedClasses.StripData D} {P₀ : ℕ → D × ℝ → ℝ} {P : ℕ → D → ℝ} {α₀ κ B : ℝ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (h : p.Dynamics s request) (hc : p.Control s P₀ P α₀ κ) (hR : ∀ (i : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) (B - 1 / 2 - κ) fun (n : ℕ) (x : D × ℝ) => request n x i) (c : CorrectionState.Context D) (hB : MeanIncrementBounds.SmoothTriple s.domain c.base) (hmatch : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) p.directions p.base) (a : CorrectionState.HarmonicBlock D) (hcarrier : SameCarrier a (p.exactBlock s request)) : CorrectionState.HarmonicBlock.WaveBounds s P (B + 1 / 2 - 4 * κ) (HarmonicWaveInteraction.linearGoodBlock c a (p.exactBlock s request) (p.gaussianBlock s request).velocity)

The literal harmonic linear remainder has the gain proved for the constructed signed coefficient. No output residual class is an input.

structure NavierStokes.CorrectionStep.SignedParameters.GaussianControl {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : SignedParameters D) (s : WeightedClasses.StripData D) (P : ℕ → D → ℝ) : Type

Primitive localization data for the already chosen signed cutoff.

• slot : GaussianTailFlat.SlotFamily (HarmonicWaveInteraction.productStrip s)

  Slot of GaussianControl, of type GaussianTailFlat.SlotFamily (HarmonicWaveInteraction.productStrip s).

• cutoff : p.cutoff = self.slot.cutoff
• fast (n : ℕ) : (self.slot.linear n) (p.directions.fastScale n • p.directions.fast) = (self.slot.length n)⁻¹
• edges : GaussianTailFlat.FlatEdges (HarmonicWaveInteraction.productStrip s)

  Edges of GaussianControl, of type GaussianTailFlat.FlatEdges (HarmonicWaveInteraction.productStrip s).

• scales : GaussianTailFlat.BandScaleControl (HarmonicWaveInteraction.productStrip s)

  Scales of GaussianControl, of type GaussianTailFlat.BandScaleControl (HarmonicWaveInteraction.productStrip s).

• rate : ℝ

  Rate of GaussianControl, of type ℝ.

• rate_pos : 0 < self.rate
• envelope (n : ℕ) (x : D × ℝ) : x ∈ (HarmonicWaveInteraction.productStrip s).domain → P n x.1 ≤ Real.exp (-self.rate * (self.slot.coordinate n x - 1 / 2) ^ 2 * self.slot.length n)

theorem NavierStokes.CorrectionStep.SignedParameters.GaussianControl.coefficient_flat {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : SignedParameters D} {s : WeightedClasses.StripData D} {P₀ : ℕ → D × ℝ → ℝ} {P : ℕ → D → ℝ} {α₀ κ B : ℝ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (h : p.GaussianControl s P) (hc : p.Control s P₀ P α₀ κ) (hR : ∀ (i : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) (B - 1 / 2 - κ) fun (n : ℕ) (x : D × ℝ) => request n x i) (N : ℝ) : WeightedClasses.UnweightedClass (HarmonicWaveInteraction.productStrip s) N (LinearWaveBounds.excludedSlotError p.directions p.cutoff (p.coefficients s request).amplitude 0)

theorem NavierStokes.CorrectionStep.SignedParameters.GaussianControl.block_flat {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : SignedParameters D} {s : WeightedClasses.StripData D} {P₀ : ℕ → D × ℝ → ℝ} {P : ℕ → D → ℝ} {α₀ κ B : ℝ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (h : p.GaussianControl s P) (hc : p.Control s P₀ P α₀ κ) (hR : ∀ (i : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) (B - 1 / 2 - κ) fun (n : ℕ) (x : D × ℝ) => request n x i) (N : ℝ) (i : Fin 3) (j : ℤ) : WeightedClasses.UnweightedClass s N fun (n : ℕ) (x : D) => ((p.gaussianBlock s request).velocity n i).coeff j x

theorem NavierStokes.CorrectionStep.SignedParameters.Dynamics.full_divergence_zero {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : SignedParameters D} {s : WeightedClasses.StripData D} {P₀ : ℕ → D × ℝ → ℝ} {P : ℕ → D → ℝ} {α₀ κ B : ℝ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (h : p.Dynamics s request) (hc : p.Control s P₀ P α₀ κ) (hR : ∀ (i : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) (B - 1 / 2 - κ) fun (n : ℕ) (x : D × ℝ) => request n x i) (ht : ∀ (n : ℕ), ∀ x ∈ (HarmonicWaveInteraction.productStrip s).domain, inner ℝ (p.base.normal (HarmonicWaveInteraction.productStrip s) p.directions n x) (p.fundamental n x) = 0) (c : CorrectionState.Context D) (hmatch : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) p.directions p.base) (n : ℕ) (x : D × ℝ) (hx : x.1 ∈ s.domain) : HarmonicCalculus.cylindricalDivergence (fun (q : D × ℝ) => c.operators.radius q.1) (radialDirection c n) angularDirection (axialDirection c n) (fun (q : D × ℝ) (i : Fin 3) => ↑((p.exactBlock s request).oscillation n q i)) x = 0

theorem NavierStokes.CorrectionStep.SignedParameters.Dynamics.modeSolenoidal {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : SignedParameters D} {s : WeightedClasses.StripData D} {P₀ : ℕ → D × ℝ → ℝ} {P : ℕ → D → ℝ} {α₀ κ B : ℝ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (h : p.Dynamics s request) (hc : p.Control s P₀ P α₀ κ) (hR : ∀ (i : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) (B - 1 / 2 - κ) fun (n : ℕ) (x : D × ℝ) => request n x i) (ht : ∀ (n : ℕ), ∀ x ∈ (HarmonicWaveInteraction.productStrip s).domain, inner ℝ (p.base.normal (HarmonicWaveInteraction.productStrip s) p.directions n x) (p.fundamental n x) = 0) (c : CorrectionState.Context D) (hmatch : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) p.directions p.base) : HarmonicWaveInteraction.ModeSolenoidal s c (p.exactBlock s request)

theorem NavierStokes.CorrectionStep.slow_directional_zero_on {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {s : WeightedClasses.StripData (PressureStream.Lift S)} {U : Set S} (hU : ∀ x ∈ s.domain, x.2.1 ∈ U) {f : ScalarField (PressureStream.Lift S)} (hf : MeanIncrementBounds.SmoothOn s.domain f) (hslow : LocalRankDefect.IsSlowOn U f) (v : PressureStream.Plane) (n : ℕ) {x : PressureStream.Lift S} (hx : x ∈ s.domain) : (fderiv ℝ (f n) x) (0, 0, v) = 0

theorem NavierStokes.CorrectionStep.gaugeRankStage_mean_gain {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] {s : WeightedClasses.StripData (PressureStream.Lift S)} {U : Set S} (hU : IsOpen U) (hSU : ∀ x ∈ s.domain, x.2.1 ∈ U) (g : VariableGaugeMean.GaugeData S) (r : CorrectionState.RankData S) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (hg : LocalRankDefect.RankGeometry g r U c u) {a b : ℝ} (ha : 0 < a) (hab : a < b) (hleft : ∀ (n : ℕ), ∀ p ∈ U, a ≤ r.length n p * r.inner) (hright : ∀ (n : ℕ), ∀ p ∈ U, r.length n p * r.outer ≤ b) {H κ β : ℝ} (v : PressureStream.Plane) (hfast : c.operators.vT = (0, 0, v)) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hb : MeanIncrementBounds.BaseBounds s c.base) (hu : CorrectionState.CumulativeBounds s u) (hi : MeanIncrementBounds.IncrementBounds s H (VariableGaugeMean.rankIncrementState g r axial c u)) (hdp : WeightedClasses.MeanClass s H (gaugeRankPressureChange g r axial c u)) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn s.domain (u.covariance i j)) (A : ScalarField (PressureStream.Lift S)) (hθ : WeightedClasses.MeanClass s β (u.thetaResidual c)) (hz : WeightedClasses.MeanClass s β (u.axialResidual c - A)) (hH : 9 / 10 ≤ H) (hβ : β ≤ H + 1 - 2 * κ) : WeightedClasses.MeanClass s β ((VariableGaugeMean.rankStageState g r axial c u).thetaResidual c) ∧ WeightedClasses.MeanClass s β ((VariableGaugeMean.rankStageState g r axial c u).axialResidual c - A)

Slow rank increments preserve an already subtracted temporal alias. The slow axial identity comes from the constructed zero-mass stream.

theorem NavierStokes.CorrectionStep.gaugeRankStage_next_mean {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] [FiniteDimensional ℝ S] {s : WeightedClasses.StripData (PressureStream.Lift S)} {U : Set S} (hU : IsOpen U) (hSU : ∀ x ∈ s.domain, x.2.1 ∈ U) (g : VariableGaugeMean.GaugeData S) (r : CorrectionState.RankData S) (axial : S × PressureStream.Plane) (c : CorrectionState.Context (PressureStream.Lift S)) (u : CorrectionState.State (PressureStream.Lift S)) (hg : LocalRankDefect.RankGeometry g r U c u) {a b : ℝ} (ha : 0 < a) (hab : a < b) (hleft : ∀ (n : ℕ), ∀ p ∈ U, a ≤ r.length n p * r.inner) (hright : ∀ (n : ℕ), ∀ p ∈ U, r.length n p * r.outer ≤ b) {σ κ : ℝ} (hσ : 1 / 5 ≤ σ) (hκ : κ ≤ 1 / 100000) (v : PressureStream.Plane) (hfast : c.operators.vT = (0, 0, v)) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hb : MeanIncrementBounds.BaseBounds s c.base) (hu : CorrectionState.CumulativeBounds s u) (hi : MeanIncrementBounds.IncrementBounds s (ExponentLedger.meanUpdateExponent σ κ) (VariableGaugeMean.rankIncrementState g r axial c u)) (hdp : WeightedClasses.MeanClass s (ExponentLedger.meanUpdateExponent σ κ) (gaugeRankPressureChange g r axial c u)) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn s.domain (u.covariance i j)) (A : ScalarField (PressureStream.Lift S)) (hθ : WeightedClasses.MeanClass s (ExponentLedger.meanExponent (σ + 1 / 10)) (u.thetaResidual c)) (hz : WeightedClasses.MeanClass s (ExponentLedger.meanExponent (σ + 1 / 10)) (u.axialResidual c - A)) : WeightedClasses.MeanClass s (ExponentLedger.meanExponent (σ + 1 / 10)) ((VariableGaugeMean.rankStageState g r axial c u).thetaResidual c) ∧ WeightedClasses.MeanClass s (ExponentLedger.meanExponent (σ + 1 / 10)) ((VariableGaugeMean.rankStageState g r axial c u).axialResidual c - A)

def NavierStokes.CorrectionStep.GaugeSupported {S : Type} (a b : ℝ) (ell : S → ℝ) (U : Set S) (f : ScalarField (PressureStream.Lift S)) : Prop

Gauge supported, given by ∀ n, SupportedGauge a b ell U (f n).

Equations

• NavierStokes.CorrectionStep.GaugeSupported a b ell U f = ∀ (n : ℕ), NavierStokes.VariableGaugeMean.SupportedGauge a b ell U (f n)

theorem NavierStokes.CorrectionStep.GaugeSupported.zero {S : Type} {a b : ℝ} {ell : S → ℝ} {U : Set S} : GaugeSupported a b ell U 0

theorem NavierStokes.CorrectionStep.GaugeSupported.add {S : Type} {a b : ℝ} {ell : S → ℝ} {U : Set S} {f g : ScalarField (PressureStream.Lift S)} (hf : GaugeSupported a b ell U f) (hg : GaugeSupported a b ell U g) : GaugeSupported a b ell U (f + g)

theorem NavierStokes.CorrectionStep.GaugeSupported.neg {S : Type} {a b : ℝ} {ell : S → ℝ} {U : Set S} {f : ScalarField (PressureStream.Lift S)} (hf : GaugeSupported a b ell U f) : GaugeSupported a b ell U (-f)

theorem NavierStokes.CorrectionStep.GaugeSupported.sub {S : Type} {a b : ℝ} {ell : S → ℝ} {U : Set S} {f g : ScalarField (PressureStream.Lift S)} (hf : GaugeSupported a b ell U f) (hg : GaugeSupported a b ell U g) : GaugeSupported a b ell U (f - g)

theorem NavierStokes.CorrectionStep.GaugeSupported.mul_right {S : Type} {a b : ℝ} {ell : S → ℝ} {U : Set S} {f : ScalarField (PressureStream.Lift S)} (hf : GaugeSupported a b ell U f) (g : ScalarField (PressureStream.Lift S)) : GaugeSupported a b ell U (f * g)

theorem NavierStokes.CorrectionStep.GaugeSupported.mul_left {S : Type} {a b : ℝ} {ell : S → ℝ} {U : Set S} {f : ScalarField (PressureStream.Lift S)} (hf : GaugeSupported a b ell U f) (g : ScalarField (PressureStream.Lift S)) : GaugeSupported a b ell U (g * f)

theorem NavierStokes.CorrectionStep.GaugeSupported.smul {S : Type} {a b : ℝ} {ell : S → ℝ} {U : Set S} {f : ScalarField (PressureStream.Lift S)} (hf : GaugeSupported a b ell U f) (t : ℝ) : GaugeSupported a b ell U (t • f)

theorem NavierStokes.CorrectionStep.GaugeSupported.directional {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {a b : ℝ} {ell : S → ℝ} {U : Set S} {f : ScalarField (PressureStream.Lift S)} (hf : GaugeSupported a b ell U f) (hU : IsOpen U) (hell : ContinuousOn ell U) (v : PressureStream.Lift S) : GaugeSupported a b ell U fun (n : ℕ) (x : PressureStream.Lift S) => (fderiv ℝ (f n) x) v

theorem NavierStokes.CorrectionStep.GaugeSupported.dr {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {a b : ℝ} {ell : S → ℝ} {U : Set S} {f : ScalarField (PressureStream.Lift S)} (hf : GaugeSupported a b ell U f) (hU : IsOpen U) (hell : ContinuousOn ell U) (o : MeanIncrementBounds.Operators (PressureStream.Lift S)) : GaugeSupported a b ell U (o.dr f)

theorem NavierStokes.CorrectionStep.GaugeSupported.dz {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {a b : ℝ} {ell : S → ℝ} {U : Set S} {f : ScalarField (PressureStream.Lift S)} (hf : GaugeSupported a b ell U f) (hU : IsOpen U) (hell : ContinuousOn ell U) (o : MeanIncrementBounds.Operators (PressureStream.Lift S)) : GaugeSupported a b ell U (o.dz f)

theorem NavierStokes.CorrectionStep.GaugeSupported.time {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {a b : ℝ} {ell : S → ℝ} {U : Set S} {f : ScalarField (PressureStream.Lift S)} (hf : GaugeSupported a b ell U f) (hU : IsOpen U) (hell : ContinuousOn ell U) (o : MeanIncrementBounds.Operators (PressureStream.Lift S)) : GaugeSupported a b ell U (o.time f)

theorem NavierStokes.CorrectionStep.GaugeSupported.radialDiv {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {a b : ℝ} {ell : S → ℝ} {U : Set S} {f : ScalarField (PressureStream.Lift S)} (hf : GaugeSupported a b ell U f) (hU : IsOpen U) (hell : ContinuousOn ell U) (o : MeanIncrementBounds.Operators (PressureStream.Lift S)) (t : ℝ) : GaugeSupported a b ell U (o.radialDiv t f)

theorem NavierStokes.CorrectionStep.GaugeSupported.viscosity {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {a b : ℝ} {ell : S → ℝ} {U : Set S} {f : ScalarField (PressureStream.Lift S)} (hf : GaugeSupported a b ell U f) (hU : IsOpen U) (hell : ContinuousOn ell U) (o : MeanIncrementBounds.Operators (PressureStream.Lift S)) (t : ℝ) : GaugeSupported a b ell U (o.viscosity t f)

structure NavierStokes.CorrectionStep.GaugeSupportedTriple {S : Type} (a b : ℝ) (ell : S → ℝ) (U : Set S) (m : MeanIncrementBounds.Triple (PressureStream.Lift S)) : Prop

Gauge supported triple data, collecting radial, angular, axial.

• radial : GaugeSupported a b ell U m.radial
• angular : GaugeSupported a b ell U m.angular
• axial : GaugeSupported a b ell U m.axial

theorem NavierStokes.CorrectionStep.GaugeSupportedTriple.updated {S : Type} {a b : ℝ} {ell : S → ℝ} {U : Set S} {m h : MeanIncrementBounds.Triple (PressureStream.Lift S)} (hm : GaugeSupportedTriple a b ell U m) (hh : GaugeSupportedTriple a b ell U h) : GaugeSupportedTriple a b ell U (MeanIncrementBounds.updated m h)

theorem NavierStokes.CorrectionStep.gr_supportedGauge {S : Type} [NormedAddCommGroup S] [NormedSpace ℝ S] {a b : ℝ} {ell : S → ℝ} {U : Set S} (hU : IsOpen U) (hell : ContinuousOn ell U) (o : MeanIncrementBounds.Operators (PressureStream.Lift S)) (base m : MeanIncrementBounds.Triple (PressureStream.Lift S)) (W : Tensor (PressureStream.Lift S)) (hm : GaugeSupportedTriple a b ell U m) (hW : ∀ (i j : Fin 3), GaugeSupported a b ell U (W i j)) : GaugeSupported a b ell U (MeanIncrementBounds.gr o base m W)

theorem NavierStokes.CorrectionStep.state_gr_moving_regular {coord a b : ℝ} (U : LocalSignedRequest.SlowRegion coord) (ha : 0 < a) (hab : a < b) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) (ho : LocalRankDefect.LocalOperators U.carrier c.operators) (hb : MeanIncrementBounds.SmoothTriple (LocalRankDefect.positiveDomain U.carrier) c.base) (hm : MeanIncrementBounds.SmoothTriple (PhysicalMeanDomain.slowDomain U.carrier) u.mean) (hms : GaugeSupportedTriple a b (VariableGaugeMean.qLength coord) U.carrier u.mean) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn (PhysicalMeanDomain.slowDomain U.carrier) (u.covariance i j)) (hWs : ∀ (i j : Fin 3), GaugeSupported a b (VariableGaugeMean.qLength coord) U.carrier (u.covariance i j)) : MeanIncrementBounds.SmoothOn (PhysicalMeanDomain.slowDomain U.carrier) (u.gr c) ∧ GaugeSupported a b (VariableGaugeMean.qLength coord) U.carrier (u.gr c)

The containing fixed annulus supplies smoothness only. The precise support conclusion retains the same moving physical edges.

theorem NavierStokes.CorrectionStep.reconstructedMeanStage_pressure_change_mem {coord cL cR : ℝ} (U : LocalSignedRequest.SlowRegion coord) (g : VariableGaugeMean.GaugeData PressureStream.Plane) (ha : 0 < g.radial.inner) (hd : 0 < g.radial.exponent) (hcL : 0 < cL) (hcR : 0 < cR) (ε L : ℕ → ℝ) (hε : ∀ (n : ℕ), 0 < ε n) (hεone : ∀ (n : ℕ), ε n ≤ 1) (hL : ∀ (n : ℕ), 1 ≤ L n) (hell : ∀ (n : ℕ), g.length n = VariableGaugeMean.qLength coord) (c : CorrectionState.Context LocalSignedRequest.Point) (u v : CorrectionState.State LocalSignedRequest.Point) (inc : MeanIncrementBounds.Triple LocalSignedRequest.Point) (hme : v.mean = MeanIncrementBounds.updated u.mean inc) (hce : v.covariance = u.covariance) (hfixed : (VariableGaugeMean.reconstructState g c u).pressure = u.pressure) {H κ : ℝ} (hH : 9 / 10 ≤ H) (hκ : 2 * κ ≤ 9 / 10) (ho : MeanIncrementBounds.OperatorBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) c.operators κ) (hb : MeanIncrementBounds.BaseBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) c.base) (hu : CorrectionState.CumulativeBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) u) (hi : MeanIncrementBounds.IncrementBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) H inc) (hop : LocalRankDefect.LocalOperators U.carrier c.operators) (hbase : MeanIncrementBounds.SmoothTriple (LocalRankDefect.positiveDomain U.carrier) c.base) (hm : MeanIncrementBounds.SmoothTriple (PhysicalMeanDomain.slowDomain U.carrier) u.mean) (him : MeanIncrementBounds.SmoothTriple (PhysicalMeanDomain.slowDomain U.carrier) inc) (hms : GaugeSupportedTriple g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier u.mean) (his : GaugeSupportedTriple g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier inc) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn (PhysicalMeanDomain.slowDomain U.carrier) (u.covariance i j)) (hWs : ∀ (i j : Fin 3), GaugeSupported g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier (u.covariance i j)) : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) H ((VariableGaugeMean.reconstructState g c v).pressure - u.pressure)

The pressure difference is computed by the same variable-gauge integral. Both radial-source regularity statements and its class follow from the actual updated mean and unchanged covariance.

theorem NavierStokes.CorrectionStep.gaugeTemporalStage_pressure_change_mem {coord cL cR : ℝ} (U : LocalSignedRequest.SlowRegion coord) (g : VariableGaugeMean.GaugeData PressureStream.Plane) (ha : 0 < g.radial.inner) (hd : 0 < g.radial.exponent) (hcL : 0 < cL) (hcR : 0 < cR) (ε L : ℕ → ℝ) (hε : ∀ (n : ℕ), 0 < ε n) (hεone : ∀ (n : ℕ), ε n ≤ 1) (hL : ∀ (n : ℕ), 1 ≤ L n) (hell : ∀ (n : ℕ), g.length n = VariableGaugeMean.qLength coord) (h : ℝ) (index : ℕ → ℕ) (axial : PressureStream.Plane × PressureStream.Plane) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) (hfixed : (VariableGaugeMean.reconstructState g c u).pressure = u.pressure) {H κ : ℝ} (hH : 9 / 10 ≤ H) (hκ : 2 * κ ≤ 9 / 10) (ho : MeanIncrementBounds.OperatorBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) c.operators κ) (hb : MeanIncrementBounds.BaseBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) c.base) (hu : CorrectionState.CumulativeBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) u) (hi : MeanIncrementBounds.IncrementBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) H (VariableGaugeMean.temporalIncrementState g h index axial c u)) (hop : LocalRankDefect.LocalOperators U.carrier c.operators) (hbase : MeanIncrementBounds.SmoothTriple (LocalRankDefect.positiveDomain U.carrier) c.base) (hm : MeanIncrementBounds.SmoothTriple (PhysicalMeanDomain.slowDomain U.carrier) u.mean) (him : MeanIncrementBounds.SmoothTriple (PhysicalMeanDomain.slowDomain U.carrier) (VariableGaugeMean.temporalIncrementState g h index axial c u)) (hms : GaugeSupportedTriple g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier u.mean) (his : GaugeSupportedTriple g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier (VariableGaugeMean.temporalIncrementState g h index axial c u)) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn (PhysicalMeanDomain.slowDomain U.carrier) (u.covariance i j)) (hWs : ∀ (i j : Fin 3), GaugeSupported g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier (u.covariance i j)) : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) H (gaugeTemporalPressureChange g h index axial c u)

Direct pressure bound for the literal temporal stage. No class of a pressure source or pressure output is supplied as a hypothesis.

theorem NavierStokes.CorrectionStep.gaugeRankStage_pressure_change_mem {coord cL cR : ℝ} (U : LocalSignedRequest.SlowRegion coord) (g : VariableGaugeMean.GaugeData PressureStream.Plane) (ha : 0 < g.radial.inner) (hd : 0 < g.radial.exponent) (hcL : 0 < cL) (hcR : 0 < cR) (ε L : ℕ → ℝ) (hε : ∀ (n : ℕ), 0 < ε n) (hεone : ∀ (n : ℕ), ε n ≤ 1) (hL : ∀ (n : ℕ), 1 ≤ L n) (hell : ∀ (n : ℕ), g.length n = VariableGaugeMean.qLength coord) (r : CorrectionState.RankData PressureStream.Plane) (axial : PressureStream.Plane × PressureStream.Plane) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) (hfixed : (VariableGaugeMean.reconstructState g c u).pressure = u.pressure) {H κ : ℝ} (hH : 9 / 10 ≤ H) (hκ : 2 * κ ≤ 9 / 10) (ho : MeanIncrementBounds.OperatorBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) c.operators κ) (hb : MeanIncrementBounds.BaseBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) c.base) (hu : CorrectionState.CumulativeBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) u) (hi : MeanIncrementBounds.IncrementBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) H (VariableGaugeMean.rankIncrementState g r axial c u)) (hop : LocalRankDefect.LocalOperators U.carrier c.operators) (hbase : MeanIncrementBounds.SmoothTriple (LocalRankDefect.positiveDomain U.carrier) c.base) (hm : MeanIncrementBounds.SmoothTriple (PhysicalMeanDomain.slowDomain U.carrier) u.mean) (him : MeanIncrementBounds.SmoothTriple (PhysicalMeanDomain.slowDomain U.carrier) (VariableGaugeMean.rankIncrementState g r axial c u)) (hms : GaugeSupportedTriple g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier u.mean) (his : GaugeSupportedTriple g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier (VariableGaugeMean.rankIncrementState g r axial c u)) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn (PhysicalMeanDomain.slowDomain U.carrier) (u.covariance i j)) (hWs : ∀ (i j : Fin 3), GaugeSupported g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier (u.covariance i j)) : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) H (gaugeRankPressureChange g r axial c u)

The same integral update for the literal rank stage, with its full centrifugal source change derived by the nonlinear mean identity.

theorem NavierStokes.CorrectionStep.gaugeTemporalIncrement_smooth {coord : ℝ} (U : LocalSignedRequest.SlowRegion coord) (g : VariableGaugeMean.GaugeData PressureStream.Plane) (ha : 0 < g.radial.inner) (hd : 0 < g.radial.exponent) (hell : ∀ (n : ℕ), g.length n = VariableGaugeMean.qLength coord) (h : ℝ) (index : ℕ → ℕ) (axial : PressureStream.Plane × PressureStream.Plane) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) (hθ : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.thetaResidual c n) (PhysicalMeanDomain.slowDomain U.carrier)) (hz : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.axialResidual c n) (PhysicalMeanDomain.slowDomain U.carrier)) (hpθ : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn U.carrier (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn U.carrier (u.axialResidual c n)) (hsz : GaugeSupported g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier (u.axialResidual c)) : MeanIncrementBounds.SmoothTriple (PhysicalMeanDomain.slowDomain U.carrier) (VariableGaugeMean.temporalIncrementState g h index axial c u)

Full local smoothness of the actual temporal stream components, including the axis where the annular support makes the quotients zero.

structure NavierStokes.CorrectionStep.PeriodizedSignedParameters (D I : Type) [NormedAddCommGroup D] [NormedSpace ℝ D] : Type

The primitive native data of one signed spatial label. Every copy uses the same carrier, base, and graph directions.

• base : LinearWaveBounds.WaveCoefficients (D × ℝ)

  Base wave coefficients for the periodized signed correction.

• directions : LinearWaveBounds.GraphDirections (D × ℝ)

  Directions of PeriodizedSignedParameters, of type LinearWaveBounds.GraphDirections (D × ℝ).

• matrix : I → ℕ → D × ℝ → SignedWaveUpdate.Mat2

  Matrix of PeriodizedSignedParameters, of type I → ℕ → D × ℝ → SignedWaveUpdate.Mat2.

• target : I → ℕ → D × ℝ → SignedWaveUpdate.Vec2

  Target of PeriodizedSignedParameters, of type I → ℕ → D × ℝ → SignedWaveUpdate.Vec2.

• mask : I → ℕ → D × ℝ → ℝ

  Mask of PeriodizedSignedParameters, of type I → ℕ → D × ℝ → ℝ.

• fundamental : I → ℕ → D × ℝ → ProblemStatement.Space

  Fundamental of PeriodizedSignedParameters, of type I → ℕ → D × ℝ → ProblemStatement.Space.

• normalMotion : I → ℕ → D × ℝ → ProblemStatement.Space

  Normal motion of PeriodizedSignedParameters, of type I → ℕ → D × ℝ → ProblemStatement.Space.

• action : I → ℕ → D × ℝ → ProblemStatement.Space →L[ℝ] ProblemStatement.Space

  Action of PeriodizedSignedParameters, of type I → ℕ → D × ℝ → ProblemStatement.Space →L[ℝ] ProblemStatement.Space.

• cutoff : I → ℕ → D × ℝ → ℝ

  Cutoff of PeriodizedSignedParameters, of type I → ℕ → D × ℝ → ℝ.

• angularFrequency : ℕ → ℤ

  Angular frequency of PeriodizedSignedParameters, of type ℕ → ℤ.

• column : Fin 2

  Column of PeriodizedSignedParameters, of type Fin 2.

noncomputable def NavierStokes.CorrectionStep.PeriodizedSignedParameters.native {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {I : Type} (p : PeriodizedSignedParameters D I) (i : I) : SignedParameters D

Native, bundling base, directions, matrix, target and the required compatibility proofs.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.PeriodizedSignedParameters.copyData {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {I : Type} (p : PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : PeriodizedWaveBounds.CopyData (D × ℝ) I

The native fields are evaluated from the signed quotient and projected homogeneous pressure before the one native cutoff is applied.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.copyData_raw {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {I : Type} (p : PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) (i : I) : (p.copyData s request).raw i = (p.native i).coefficients s request

noncomputable def NavierStokes.CorrectionStep.PeriodizedSignedParameters.exactBlock {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {I : Type} (p : PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : CorrectionState.HarmonicBlock D

Exact block, constructed using SignedWaveUpdate.blockOfCoefficients.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.PeriodizedSignedParameters.tangentBlock {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {I : Type} (p : PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : CorrectionState.HarmonicBlock D

Tangent block, given by SignedWaveUpdate.blockOfCoefficients (p.copyData s request).common p.angularFrequency.

Equations

• p.tangentBlock s request = NavierStokes.SignedWaveUpdate.blockOfCoefficients (p.copyData s request).common p.angularFrequency

noncomputable def NavierStokes.CorrectionStep.PeriodizedSignedParameters.curlBlock {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {I : Type} (p : PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : CorrectionState.HarmonicBlock D

Curl block, given by subBlock (p.exactBlock s request) (p.tangentBlock s request).

Equations

• p.curlBlock s request = NavierStokes.CorrectionStep.subBlock (p.exactBlock s request) (p.tangentBlock s request)

noncomputable def NavierStokes.CorrectionStep.PeriodizedSignedParameters.goodBlock {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {I : Type} (p : PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : CorrectionState.HarmonicBlock D

Good block, constructed using SignedWaveUpdate.coefficientBlock.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.PeriodizedSignedParameters.gaussianBlock {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {I : Type} (p : PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : CorrectionState.HarmonicBlock D

Gaussian block, constructed using SignedWaveUpdate.coefficientBlock.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.exact_tangent_carrier {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {I : Type} (p : PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : SameCarrier (p.exactBlock s request) (p.tangentBlock s request)

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.exactBlock_split {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {I : Type} (p : PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : (p.exactBlock s request).oscillation = (p.tangentBlock s request).oscillation + (p.curlBlock s request).oscillation

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.exactBlock_band {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {I : Type} (p : PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : (p.exactBlock s request).BandLimited 1

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.tangentBlock_band {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {I : Type} (p : PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : (p.tangentBlock s request).BandLimited 1

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.gaussianBlock_band {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {I : Type} (p : PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : (p.gaussianBlock s request).BandLimited 1

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.gaussian_source_zero {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {I : Type} (p : PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : (p.copyData s request).globalGaussian p.directions = (p.copyData s request).globalTail p.directions

structure NavierStokes.CorrectionStep.ParticularParameters (P : Type) [NormedAddCommGroup P] [NormedSpace ℝ P] : Type

Primitive per-band data of the actual complex Volterra inverse. The interval may vary with the physical clock. No solved field is stored.

• tangent : ℤ → ℕ → CommonCoverSolve.TangentData P ProblemStatement.Space

  Tangent of ParticularParameters, of type ℤ → ℕ → CommonCoverSolve.TangentData P ProblemStatement.Space.

• geometry : ℕ → CommonCoverSolve.Geometry

  Geometry of ParticularParameters, of type ℕ → CommonCoverSolve.Geometry.

• length : ℕ → ℝ

  Length of ParticularParameters, of type ℕ → ℝ.

• length_pos (n : ℕ) : 0 < self.length n
• cutoff : ℕ → TorusInverse.Plane → ℝ

  Cutoff of ParticularParameters, of type ℕ → TorusInverse.Plane → ℝ.

• background : LinearWaveBounds.WaveCoefficients ((P × ℝ) × TorusInverse.Plane)

  Background of ParticularParameters, of type LinearWaveBounds.WaveCoefficients ((P × ℝ) × TorusInverse.Plane).

• directions : LinearWaveBounds.GraphDirections ((P × ℝ) × TorusInverse.Plane)

  Directions of ParticularParameters, of type LinearWaveBounds.GraphDirections ((P × ℝ) × TorusInverse.Plane).

noncomputable def NavierStokes.CorrectionStep.ParticularParameters.copyData {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] (p : ParticularParameters P) (c : CorrectionState.Context (P × TorusInverse.Plane)) (u : CorrectionState.State (P × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (P × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (P × TorusInverse.Plane)) (j : ℤ) : PeriodizedWaveBounds.CopyData ((P × ℝ) × TorusInverse.Plane) TorusInverse.Frequency

Copy data, bundling background, amplitude, pressure, cutoff and the required compatibility proofs.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.ParticularParameters.nativeStrip {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] (s : WeightedClasses.StripData (P × TorusInverse.Plane)) : WeightedClasses.StripData ((P × ℝ) × TorusInverse.Plane)

Native strip, given by ParticularWaveBounds.reindexStrip ParticularWaveAssembly.angleShuffle.symm (HarmonicWaveInteraction.productStrip s).

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.ParticularParameters.wave {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] (p : ParticularParameters P) (s : WeightedClasses.StripData (P × TorusInverse.Plane)) (c : CorrectionState.Context (P × TorusInverse.Plane)) (u : CorrectionState.State (P × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (P × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (P × TorusInverse.Plane)) (j : ℤ) : LinearWaveBounds.WaveCoefficients ((P × ℝ) × TorusInverse.Plane)

Wave, given by (p.copyData c u b G A j).commonCorrected (nativeStrip s) p.directions.

Equations

• p.wave s c u b G A j = (p.copyData c u b G A j).commonCorrected (NavierStokes.CorrectionStep.ParticularParameters.nativeStrip s) p.directions

noncomputable def NavierStokes.CorrectionStep.ParticularParameters.updateBlock {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] (p : ParticularParameters P) (s : WeightedClasses.StripData (P × TorusInverse.Plane)) (c : CorrectionState.Context (P × TorusInverse.Plane)) (u : CorrectionState.State (P × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (P × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (P × TorusInverse.Plane)) (N : ℕ) : CorrectionState.HarmonicBlock (P × TorusInverse.Plane)

Update block, constructed using ParticularWaveAssembly.assembledBlock.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.ParticularParameters.goodBlock {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] (p : ParticularParameters P) (s : WeightedClasses.StripData (P × TorusInverse.Plane)) (c : CorrectionState.Context (P × TorusInverse.Plane)) (u : CorrectionState.State (P × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (P × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (P × TorusInverse.Plane)) (N : ℕ) : CorrectionState.HarmonicBlock (P × TorusInverse.Plane)

Good block, constructed using ParticularWaveAssembly.assembledBlock.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.ParticularParameters.gaussianBlock {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] (p : ParticularParameters P) (c : CorrectionState.Context (P × TorusInverse.Plane)) (u : CorrectionState.State (P × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (P × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (P × TorusInverse.Plane)) (N : ℕ) : CorrectionState.HarmonicBlock (P × TorusInverse.Plane)

Gaussian block, constructed using ParticularWaveAssembly.assembledBlock.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.ParticularParameters.updateBlock_band {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] (p : ParticularParameters P) (s : WeightedClasses.StripData (P × TorusInverse.Plane)) (c : CorrectionState.Context (P × TorusInverse.Plane)) (u : CorrectionState.State (P × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (P × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (P × TorusInverse.Plane)) (N : ℕ) : (p.updateBlock s c u b G A N).BandLimited N

theorem NavierStokes.CorrectionStep.ParticularParameters.gaussianBlock_band {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] (p : ParticularParameters P) (c : CorrectionState.Context (P × TorusInverse.Plane)) (u : CorrectionState.State (P × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (P × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (P × TorusInverse.Plane)) (N : ℕ) : (p.gaussianBlock c u b G A N).BandLimited N

theorem NavierStokes.CorrectionStep.ParticularParameters.source_eq_residual {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] (p : ParticularParameters P) (c : CorrectionState.Context (P × TorusInverse.Plane)) (u : CorrectionState.State (P × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (P × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (P × TorusInverse.Plane)) (j : ℤ) (n : ℕ) (x : (P × ℝ) × TorusInverse.Plane) (i : Fin 3) : (p.copyData c u b G A j).source n x i = ((HarmonicResidual.residualBlock c u b G A).velocity n i).coeff j (x.1.1, x.2)

@[reducible, inline]

abbrev NavierStokes.CorrectionStep.CyclePoint : Type

Cycle point: an abbreviation for LocalSignedRequest.Point.

Equations

• NavierStokes.CorrectionStep.CyclePoint = NavierStokes.LocalSignedRequest.Point

@[reducible, inline]

abbrev NavierStokes.CorrectionStep.CycleSlow : Type

Cycle slow: an abbreviation for ℝ × PressureStream.Plane.

Equations

• NavierStokes.CorrectionStep.CycleSlow = (ℝ × NavierStokes.PressureStream.Plane)

noncomputable def NavierStokes.CorrectionStep.cycleAssoc : CyclePoint ≃ₗᵢ[ℝ] CycleSlow × TorusInverse.Plane

Cycle assoc, given by ParticularWaveBounds.liftAssoc PressureStream.Plane.

Equations

• NavierStokes.CorrectionStep.cycleAssoc = NavierStokes.ParticularWaveBounds.liftAssoc NavierStokes.PressureStream.Plane

structure NavierStokes.CorrectionStep.CycleCoefficients (ι : Type) : Type

Finite labeled coefficient data of the current fields. Correct representation is a separate invariant, not part of the construction.

• labels : ℕ → Finset ι

  Label type of CycleCoefficients, of type ℕ → Finset ι.

• blocks : ι → CorrectionState.HarmonicBlock CyclePoint

  Blocks of CycleCoefficients, of type ι → HarmonicBlock CyclePoint.

• gaussian : ι → HarmonicResidual.BlockCoefficients CyclePoint

  Gaussian residual coefficients indexed by harmonic label.

• aliasCoefficients : ι → HarmonicResidual.BlockCoefficients CyclePoint

  Alias coefficients of CycleCoefficients, of type ι → HarmonicResidual.BlockCoefficients CyclePoint.

• residualBand : ℕ

  Residual band of CycleCoefficients, of type ℕ.

structure NavierStokes.CorrectionStep.CycleParameters (ι : Type) : Type

Fixed geometric and primitive solver data for an actual correction cycle. The only state-dependent source is computed inside the stages.

• gauge : VariableGaugeMean.GaugeData PressureStream.Plane

  Gauge of CycleParameters, of type GaugeData PressureStream.Plane.

• strip : WeightedClasses.StripData CyclePoint

  Strip of CycleParameters, of type StripData CyclePoint.

• patch : SignedStressPrimitive.Patch

  Patch of CycleParameters, of type SignedStressPrimitive.Patch.

• coordinate : ℝ

  Coordinate of CycleParameters, of type ℝ.

• timeExponent : ℝ

  Time exponent of CycleParameters, of type ℝ.

• commonIndex : ℕ → ℕ

  Common index of CycleParameters, of type ℕ → ℕ.

• axial : PressureStream.Plane × PressureStream.Plane

  Axial of CycleParameters, of type PressureStream.Plane × PressureStream.Plane.

• particular : ι → ParticularParameters CycleSlow

  Particular of CycleParameters, of type ι → ParticularParameters CycleSlow.

• signed : ι → PeriodizedSignedParameters CyclePoint TorusInverse.Frequency

  Signed of CycleParameters, of type ι → PeriodizedSignedParameters CyclePoint TorusInverse.Frequency.

• rank : CorrectionState.RankData PressureStream.Plane

  Rank of CycleParameters, of type RankData PressureStream.Plane.

noncomputable def NavierStokes.CorrectionStep.CycleParameters.particularBlock {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (l : ι) : CorrectionState.HarmonicBlock CyclePoint

Particular block, constructed using StateReindex.block.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.CycleParameters.particularGaussianBlock {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (l : ι) : CorrectionState.HarmonicBlock CyclePoint

Particular gaussian block, constructed using StateReindex.block.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.CycleParameters.particularVelocity {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : CorrectionState.Oscillation CyclePoint

Particular velocity, given by LabelSumBounds.fieldSum v.labels (fun l => (p.particularBlock v c u l).oscillation).

Equations

• p.particularVelocity v c u = NavierStokes.LabelSumBounds.fieldSum v.labels fun (l : ι) => (p.particularBlock v c u l).oscillation

noncomputable def NavierStokes.CorrectionStep.CycleParameters.particularPressure {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : CorrectionState.OscillatoryScalar CyclePoint

Particular pressure, defined pointwise by ∑ l ∈ v.labels n, (p.particularBlock v c u l).oscillatoryPressure n x.

Equations

• p.particularPressure v c u n x = ∑ l ∈ v.labels n, (p.particularBlock v c u l).oscillatoryPressure n x

noncomputable def NavierStokes.CorrectionStep.CycleParameters.particularGaussian {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : CorrectionState.Oscillation CyclePoint

Particular gaussian, given by LabelSumBounds.fieldSum v.labels (fun l => (p.particularGaussianBlock v c u l).oscillation).

Equations

• p.particularGaussian v c u = NavierStokes.LabelSumBounds.fieldSum v.labels fun (l : ι) => (p.particularGaussianBlock v c u l).oscillation

noncomputable def NavierStokes.CorrectionStep.CycleParameters.afterParticular {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : CorrectionState.State CyclePoint

After particular, given by gaugeWaveStage p.gauge c u (p.particularVelocity v c u) (p.particularPressure v c u) ⟨0, p.particularGaussian v c u, 0⟩.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.CycleParameters.signedRequest {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : ℕ → CyclePoint × ℝ → SignedWaveUpdate.Vec2

The signed request is recomputed from the actual state after the particular solve; it is not supplied independently.

Equations

• p.signedRequest v c u = NavierStokes.LocalSignedRequest.fullRequest p.strip p.patch p.coordinate c (p.afterParticular v c u)

noncomputable def NavierStokes.CorrectionStep.CycleParameters.signedBlock {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (l : ι) : CorrectionState.HarmonicBlock CyclePoint

Signed block, given by (p.signed l).exactBlock p.strip (p.signedRequest v c u).

Equations

• p.signedBlock v c u l = (p.signed l).exactBlock p.strip (p.signedRequest v c u)

noncomputable def NavierStokes.CorrectionStep.CycleParameters.signedGaussianBlock {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (l : ι) : CorrectionState.HarmonicBlock CyclePoint

Signed gaussian block, given by (p.signed l).gaussianBlock p.strip (p.signedRequest v c u).

Equations

• p.signedGaussianBlock v c u l = (p.signed l).gaussianBlock p.strip (p.signedRequest v c u)

noncomputable def NavierStokes.CorrectionStep.CycleParameters.signedVelocity {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : CorrectionState.Oscillation CyclePoint

Signed velocity, given by LabelSumBounds.fieldSum v.labels (fun l => (p.signedBlock v c u l).oscillation).

Equations

• p.signedVelocity v c u = NavierStokes.LabelSumBounds.fieldSum v.labels fun (l : ι) => (p.signedBlock v c u l).oscillation

noncomputable def NavierStokes.CorrectionStep.CycleParameters.signedPressure {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : CorrectionState.OscillatoryScalar CyclePoint

Signed pressure, defined pointwise by ∑ l ∈ v.labels n, (p.signedBlock v c u l).oscillatoryPressure n x.

Equations

• p.signedPressure v c u n x = ∑ l ∈ v.labels n, (p.signedBlock v c u l).oscillatoryPressure n x

noncomputable def NavierStokes.CorrectionStep.CycleParameters.signedGaussian {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : CorrectionState.Oscillation CyclePoint

Signed gaussian, given by LabelSumBounds.fieldSum v.labels (fun l => (p.signedGaussianBlock v c u l).oscillation).

Equations

• p.signedGaussian v c u = NavierStokes.LabelSumBounds.fieldSum v.labels fun (l : ι) => (p.signedGaussianBlock v c u l).oscillation

noncomputable def NavierStokes.CorrectionStep.CycleParameters.afterSigned {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : CorrectionState.State CyclePoint

After signed, constructed using gaugeWaveStage.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.CycleParameters.temporalIncrement {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : MeanIncrementBounds.Triple CyclePoint

Temporal increment, given by temporalIncrementState p.gauge p.timeExponent p.commonIndex p.axial c (p.afterSigned v c u).

Equations

• p.temporalIncrement v c u = NavierStokes.VariableGaugeMean.temporalIncrementState p.gauge p.timeExponent p.commonIndex p.axial c (p.afterSigned v c u)

noncomputable def NavierStokes.CorrectionStep.CycleParameters.afterTemporal {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : CorrectionState.State CyclePoint

After temporal, given by temporalStageState p.gauge p.timeExponent p.commonIndex p.axial c (p.afterSigned v c u).

Equations

• p.afterTemporal v c u = NavierStokes.VariableGaugeMean.temporalStageState p.gauge p.timeExponent p.commonIndex p.axial c (p.afterSigned v c u)

noncomputable def NavierStokes.CorrectionStep.CycleParameters.rankIncrement {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : MeanIncrementBounds.Triple CyclePoint

Rank increment, given by rankIncrementState p.gauge p.rank p.axial c (p.afterTemporal v c u).

Equations

• p.rankIncrement v c u = NavierStokes.VariableGaugeMean.rankIncrementState p.gauge p.rank p.axial c (p.afterTemporal v c u)

noncomputable def NavierStokes.CorrectionStep.CycleParameters.afterRank {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : CorrectionState.State CyclePoint

After rank, given by rankStageState p.gauge p.rank p.axial c (p.afterTemporal v c u).

Equations

• p.afterRank v c u = NavierStokes.VariableGaugeMean.rankStageState p.gauge p.rank p.axial c (p.afterTemporal v c u)

noncomputable def NavierStokes.CorrectionStep.CycleParameters.next {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : CorrectionState.State CyclePoint

Four literal updates followed by replacement of the obsolete radial pressure alias. The current radial alias is recorded exactly once.

Equations

• p.next v c u = NavierStokes.CorrectionStep.gaugeRefreshPressureAlias p.gauge c u (p.afterRank v c u)

noncomputable def NavierStokes.CorrectionStep.CycleParameters.finalBlock {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (l : ι) : CorrectionState.HarmonicBlock CyclePoint

Final block, given by addBlock (addBlock (v.blocks l) (p.particularBlock v c u l)) (p.signedBlock v c u l).

Equations

• p.finalBlock v c u l = NavierStokes.CorrectionStep.addBlock (NavierStokes.CorrectionStep.addBlock (v.blocks l) (p.particularBlock v c u l)) (p.signedBlock v c u l)

theorem NavierStokes.CorrectionStep.CycleParameters.particularBlock_band {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (l : ι) : (p.particularBlock v c u l).BandLimited v.residualBand

theorem NavierStokes.CorrectionStep.CycleParameters.particularGaussianBlock_band {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (l : ι) : (p.particularGaussianBlock v c u l).BandLimited v.residualBand

theorem NavierStokes.CorrectionStep.CycleParameters.finalBlock_band {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) {N : ℕ} (hb : ∀ (l : ι), (v.blocks l).BandLimited N) (l : ι) : (p.finalBlock v c u l).BandLimited (max (max N v.residualBand) 1)

theorem NavierStokes.CorrectionStep.CycleParameters.next_oscillation {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : (p.next v c u).oscillation = u.oscillation + p.particularVelocity v c u + p.signedVelocity v c u

theorem NavierStokes.CorrectionStep.CycleParameters.next_oscillatoryPressure {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : (p.next v c u).oscillatoryPressure = u.oscillatoryPressure + p.particularPressure v c u + p.signedPressure v c u

theorem NavierStokes.CorrectionStep.CycleParameters.next_mean {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : (p.next v c u).mean = MeanIncrementBounds.updated (MeanIncrementBounds.updated u.mean (p.temporalIncrement v c u)) (p.rankIncrement v c u)

theorem NavierStokes.CorrectionStep.CycleParameters.next_base_error {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : (p.next v c u).errors.base = u.errors.base

theorem NavierStokes.CorrectionStep.CycleParameters.next_gaussian_error {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : (p.next v c u).errors.gaussian = u.errors.gaussian + p.particularGaussian v c u + p.signedGaussian v c u

theorem NavierStokes.CorrectionStep.CycleParameters.next_alias_error {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : (p.next v c u).errors.aliasError = u.errors.aliasError + VariableGaugeMean.temporalAliasState p.gauge p.timeExponent p.commonIndex c (p.afterSigned v c u) + (VariableGaugeMean.pressureAliasState p.gauge c (p.afterRank v c u) - VariableGaugeMean.pressureAliasState p.gauge c u)

theorem NavierStokes.CorrectionStep.CycleParameters.next_reconstructed {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : (VariableGaugeMean.reconstructState p.gauge c (p.next v c u)).pressure = (p.next v c u).pressure

theorem NavierStokes.CorrectionStep.gaugeTemporalStage_constructed {coord cL cR : ℝ} (U : LocalSignedRequest.SlowRegion coord) (g : VariableGaugeMean.GaugeData PressureStream.Plane) (ha : 0 < g.radial.inner) (hd : 0 < g.radial.exponent) (hcL : 0 < cL) (hcR : 0 < cR) (ε L : ℕ → ℝ) (hε : ∀ (n : ℕ), 0 < ε n) (hεone : ∀ (n : ℕ), ε n ≤ 1) (hL : ∀ (n : ℕ), 1 ≤ L n) (hell : ∀ (n : ℕ), g.length n = VariableGaugeMean.qLength coord) {h H κ β : ℝ} (hh : 0 ≤ h) (hscale : ∀ (n : ℕ), ChartScales.S n ≤ L n) (index : ℕ → ℕ) (gap : ℕ) (hgap : ∀ (n : ℕ), ChartScales.nativeIndex h n ≤ index n + gap) (axial : PressureStream.Plane × PressureStream.Plane) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) (heps : c.operators.epsilon = ε) (hv : c.operators.vT = (0, 0, TorusInverse.vector TorusInverse.Direction.temporal)) (hfast : ∀ (n : ℕ), c.operators.fastCoefficient n = ChartScales.Tg ^ index n * ChartScales.Q n ^ (1 + h)) (hfixed : (VariableGaugeMean.reconstructState g c u).pressure = u.pressure) (hH : 9 / 10 ≤ H) (hκ : 2 * κ ≤ 9 / 10) (hβ : β ≤ H + 1 - 2 * κ) (ho : MeanIncrementBounds.OperatorBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) c.operators κ) (hb : MeanIncrementBounds.BaseBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) c.base) (hu : CorrectionState.CumulativeBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) u) (hop : LocalRankDefect.LocalOperators U.carrier c.operators) (hbase : MeanIncrementBounds.SmoothTriple (LocalRankDefect.positiveDomain U.carrier) c.base) (hm : MeanIncrementBounds.SmoothTriple (PhysicalMeanDomain.slowDomain U.carrier) u.mean) (hms : GaugeSupportedTriple g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier u.mean) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn (PhysicalMeanDomain.slowDomain U.carrier) (u.covariance i j)) (hWs : ∀ (i j : Fin 3), GaugeSupported g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier (u.covariance i j)) (hθ : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.thetaResidual c n) (PhysicalMeanDomain.slowDomain U.carrier)) (hz : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.axialResidual c n) (PhysicalMeanDomain.slowDomain U.carrier)) (hpθ : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn U.carrier (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn U.carrier (u.axialResidual c n)) (hsθ : GaugeSupported g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier (u.thetaResidual c)) (hsz : GaugeSupported g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier (u.axialResidual c)) (hcθ : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) H (u.thetaResidual c)) (hcz : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) H (u.axialResidual c)) (hbarθ : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) β (meanBar (u.thetaResidual c))) (hbarz : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) β (meanBar (u.axialResidual c))) : MeanIncrementBounds.IncrementBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) H (VariableGaugeMean.temporalIncrementState g h index axial c u) ∧ WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) H (gaugeTemporalPressureChange g h index axial c u) ∧ CorrectionState.CumulativeBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (VariableGaugeMean.temporalStageState g h index axial c u) ∧ MeanIncrementBounds.SmoothTriple (PhysicalMeanDomain.slowDomain U.carrier) (VariableGaugeMean.temporalStageState g h index axial c u).mean ∧ GaugeSupportedTriple g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier (VariableGaugeMean.temporalStageState g h index axial c u).mean ∧ WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) β ((VariableGaugeMean.temporalStageState g h index axial c u).thetaResidual c) ∧ WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) β fun (n : ℕ) (x : LocalSignedRequest.Point) => (VariableGaugeMean.temporalStageState g h index axial c u).axialResidual c n x - VariableGaugeMean.temporalAliasState g h index c u n (x, 0) 2

Full mean-step bound for the constructed temporal inverse and stream. The increment and pressure-change classes are conclusions.

theorem NavierStokes.CorrectionStep.gaugeRankStage_constructed {coord cL cR A B : ℝ} (U : LocalSignedRequest.SlowRegion coord) (g : VariableGaugeMean.GaugeData PressureStream.Plane) (r : CorrectionState.RankData PressureStream.Plane) (ha : 0 < g.radial.inner) (hd : 0 < g.radial.exponent) (hcL : 0 < cL) (hcR : 0 < cR) (ε L : ℕ → ℝ) (hε : ∀ (n : ℕ), 0 < ε n) (hεone : ∀ (n : ℕ), ε n ≤ 1) (hL : ∀ (n : ℕ), 1 ≤ L n) (hell : ∀ (n : ℕ), g.length n = VariableGaugeMean.qLength coord) (axial : PressureStream.Plane × PressureStream.Plane) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) (hg : LocalRankDefect.RankGeometry g r U.carrier c u) (hparam : RankStateBounds.NormalizedParameters coord A B r U.carrier) (hB : B ≠ 0) (hleft : g.radial.inner < r.inner) (hright : r.outer < g.radial.outer) {H κ β : ℝ} (hH : 9 / 10 ≤ H) (hκ : 2 * κ ≤ 9 / 10) (hβ : β ≤ H + 1 - 2 * κ) (hfast : c.operators.vT = (0, 0, TorusInverse.vector TorusInverse.Direction.temporal)) (hfixed : (VariableGaugeMean.reconstructState g c u).pressure = u.pressure) (ho : MeanIncrementBounds.OperatorBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) c.operators κ) (hb : MeanIncrementBounds.BaseBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) c.base) (hu : CorrectionState.CumulativeBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) u) (hop : LocalRankDefect.LocalOperators U.carrier c.operators) (hbase : MeanIncrementBounds.SmoothTriple (LocalRankDefect.positiveDomain U.carrier) c.base) (hm : MeanIncrementBounds.SmoothTriple (PhysicalMeanDomain.slowDomain U.carrier) u.mean) (hms : GaugeSupportedTriple g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier u.mean) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn (PhysicalMeanDomain.slowDomain U.carrier) (u.covariance i j)) (hWs : ∀ (i j : Fin 3), GaugeSupported g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier (u.covariance i j)) (hdebt : WeightedClasses.UnweightedClass (PhysicalMeanDomain.localSlowStripData U.carrier ⋯ ε L hε hεone hL) H (CorrectionState.debt c u)) (aliasField : ScalarField LocalSignedRequest.Point) (hθ : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) β (u.thetaResidual c)) (hz : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) β (u.axialResidual c - aliasField)) : MeanIncrementBounds.IncrementBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) H (VariableGaugeMean.rankIncrementState g r axial c u) ∧ WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) H (gaugeRankPressureChange g r axial c u) ∧ CorrectionState.CumulativeBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (VariableGaugeMean.rankStageState g r axial c u) ∧ MeanIncrementBounds.SmoothTriple (PhysicalMeanDomain.slowDomain U.carrier) (VariableGaugeMean.rankStageState g r axial c u).mean ∧ GaugeSupportedTriple g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier (VariableGaugeMean.rankStageState g r axial c u).mean ∧ WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) β ((VariableGaugeMean.rankStageState g r axial c u).thetaResidual c) ∧ WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) β ((VariableGaugeMean.rankStageState g r axial c u).axialResidual c - aliasField)

The actual rank increment and its pressure change are derived from the measured debt. The previous temporal alias stays subtracted.

theorem NavierStokes.CorrectionStep.CycleParameters.afterParticular_mean {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : (p.afterParticular v c u).mean = u.mean

theorem NavierStokes.CorrectionStep.CycleParameters.afterSigned_mean {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : (p.afterSigned v c u).mean = u.mean

theorem NavierStokes.CorrectionStep.CycleParameters.next_preserve_masses {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) {coord : ℝ} (U : LocalSignedRequest.SlowRegion coord) (ha : 0 < p.gauge.radial.inner) (hd : 0 < p.gauge.radial.exponent) (hell : ∀ (n : ℕ), p.gauge.length n = VariableGaugeMean.qLength coord) (hm : MeanIncrementBounds.SmoothTriple (PhysicalMeanDomain.slowDomain U.carrier) u.mean) (hms : GaugeSupportedTriple p.gauge.radial.inner p.gauge.radial.outer (VariableGaugeMean.qLength coord) U.carrier u.mean) (hθ : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) ((p.afterSigned v c u).thetaResidual c n) (PhysicalMeanDomain.slowDomain U.carrier)) (hz : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) ((p.afterSigned v c u).axialResidual c n) (PhysicalMeanDomain.slowDomain U.carrier)) (hpθ : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn U.carrier ((p.afterSigned v c u).thetaResidual c n)) (hpz : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn U.carrier ((p.afterSigned v c u).axialResidual c n)) (hsθ : GaugeSupported p.gauge.radial.inner p.gauge.radial.outer (VariableGaugeMean.qLength coord) U.carrier ((p.afterSigned v c u).thetaResidual c)) (hsz : GaugeSupported p.gauge.radial.inner p.gauge.radial.outer (VariableGaugeMean.qLength coord) U.carrier ((p.afterSigned v c u).axialResidual c)) (hg : LocalRankDefect.RankGeometry p.gauge p.rank U.carrier c (p.afterTemporal v c u)) (hrlength : ∀ (n : ℕ), ∀ x ∈ U.carrier, p.rank.length n x = VariableGaugeMean.qLength coord x) (hleft : p.gauge.radial.inner ≤ p.rank.inner) (hright : p.rank.outer ≤ p.gauge.radial.outer) (n : ℕ) {x : PressureStream.Plane} (hx : x ∈ U.carrier) : CorrectionState.radialMoment 2 (p.next v c u).mean.angular n x = CorrectionState.radialMoment 2 u.mean.angular n x ∧ CorrectionState.radialMoment 1 (p.next v c u).mean.axial n x = CorrectionState.radialMoment 1 u.mean.axial n x

Both actual conserved masses survive all four stages. All radial integrals are evaluated on the valid local slow region.

theorem NavierStokes.CorrectionStep.CycleParameters.finish_mean_stages {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) {coord cL cR A B : ℝ} (U : LocalSignedRequest.SlowRegion coord) (ha : 0 < p.gauge.radial.inner) (hd : 0 < p.gauge.radial.exponent) (hcL : 0 < cL) (hcR : 0 < cR) (ε L : ℕ → ℝ) (hε : ∀ (n : ℕ), 0 < ε n) (hεone : ∀ (n : ℕ), ε n ≤ 1) (hL : ∀ (n : ℕ), 1 ≤ L n) (hell : ∀ (n : ℕ), p.gauge.length n = VariableGaugeMean.qLength coord) {σ κ : ℝ} (hσ : 1 / 5 ≤ σ) (hκsmall : κ ≤ 1 / 100000) (hh : 0 ≤ p.timeExponent) (hscale : ∀ (n : ℕ), ChartScales.S n ≤ L n) (gap : ℕ) (hgap : ∀ (n : ℕ), ChartScales.nativeIndex p.timeExponent n ≤ p.commonIndex n + gap) (hv : c.operators.vT = (0, 0, TorusInverse.vector TorusInverse.Direction.temporal)) (hfast : ∀ (n : ℕ), c.operators.fastCoefficient n = ChartScales.Tg ^ p.commonIndex n * ChartScales.Q n ^ (1 + p.timeExponent)) (ho : MeanIncrementBounds.OperatorBounds (LocalSignedRequest.movingStripData U p.gauge.radial.inner p.gauge.radial.outer cL cR ha hcL hcR ε L hε hεone hL) c.operators κ) (hb : MeanIncrementBounds.BaseBounds (LocalSignedRequest.movingStripData U p.gauge.radial.inner p.gauge.radial.outer cL cR ha hcL hcR ε L hε hεone hL) c.base) (hsigned : CorrectionState.CumulativeBounds (LocalSignedRequest.movingStripData U p.gauge.radial.inner p.gauge.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (p.afterSigned v c u)) (hop : LocalRankDefect.LocalOperators U.carrier c.operators) (hbase : MeanIncrementBounds.SmoothTriple (LocalRankDefect.positiveDomain U.carrier) c.base) (hV : LocalRankDefect.IsSlowOn U.carrier c.base.angular) (hG : LocalRankDefect.IsSlowOn U.carrier c.base.axial) (hm : MeanIncrementBounds.SmoothTriple (PhysicalMeanDomain.slowDomain U.carrier) (p.afterSigned v c u).mean) (hms : GaugeSupportedTriple p.gauge.radial.inner p.gauge.radial.outer (VariableGaugeMean.qLength coord) U.carrier (p.afterSigned v c u).mean) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn (PhysicalMeanDomain.slowDomain U.carrier) ((p.afterSigned v c u).covariance i j)) (hWs : ∀ (i j : Fin 3), GaugeSupported p.gauge.radial.inner p.gauge.radial.outer (VariableGaugeMean.qLength coord) U.carrier ((p.afterSigned v c u).covariance i j)) (hθ : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) ((p.afterSigned v c u).thetaResidual c n) (PhysicalMeanDomain.slowDomain U.carrier)) (hz : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) ((p.afterSigned v c u).axialResidual c n) (PhysicalMeanDomain.slowDomain U.carrier)) (hpθ : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn U.carrier ((p.afterSigned v c u).thetaResidual c n)) (hpz : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn U.carrier ((p.afterSigned v c u).axialResidual c n)) (hsθ : GaugeSupported p.gauge.radial.inner p.gauge.radial.outer (VariableGaugeMean.qLength coord) U.carrier ((p.afterSigned v c u).thetaResidual c)) (hsz : GaugeSupported p.gauge.radial.inner p.gauge.radial.outer (VariableGaugeMean.qLength coord) U.carrier ((p.afterSigned v c u).axialResidual c)) (hcθ : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U p.gauge.radial.inner p.gauge.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (1 + σ - 2 * κ) ((p.afterSigned v c u).thetaResidual c)) (hcz : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U p.gauge.radial.inner p.gauge.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (1 + σ - 2 * κ) ((p.afterSigned v c u).axialResidual c)) (hbarθ : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U p.gauge.radial.inner p.gauge.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (1 + σ + 17 / 100) (meanBar ((p.afterSigned v c u).thetaResidual c))) (hbarz : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U p.gauge.radial.inner p.gauge.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (1 + σ + 17 / 100) (meanBar ((p.afterSigned v c u).axialResidual c))) (hdebt : ∀ (i : Fin 3), WeightedClasses.UnweightedClass (PhysicalMeanDomain.localSlowStripData U.carrier ⋯ ε L hε hεone hL) (1 + σ - 2 * κ) fun (n : ℕ) (x : LocalSignedRequest.Plane) => CorrectionState.debt c (p.afterSigned v c u) n x i) (hg : LocalRankDefect.RankGeometry p.gauge p.rank U.carrier c (p.afterTemporal v c u)) (hparam : RankStateBounds.NormalizedParameters coord A B p.rank U.carrier) (hB : B ≠ 0) (hleft : p.gauge.radial.inner < p.rank.inner) (hright : p.rank.outer < p.gauge.radial.outer) : CorrectionState.CumulativeBounds (LocalSignedRequest.movingStripData U p.gauge.radial.inner p.gauge.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (p.next v c u) ∧ CorrectionState.DefectBounds (PhysicalMeanDomain.localSlowStripData U.carrier ⋯ ε L hε hεone hL) (σ + 1 / 10) c (p.next v c u) ∧ WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U p.gauge.radial.inner p.gauge.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (1 + (σ + 1 / 10)) ((p.next v c u).thetaResidual c) ∧ WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U p.gauge.radial.inner p.gauge.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (1 + (σ + 1 / 10)) ((p.next v c u).axialResidual c - fun (n : ℕ) (x : PressureStream.Lift PressureStream.Plane) => VariableGaugeMean.temporalAliasState p.gauge p.timeExponent p.commonIndex c (p.afterSigned v c u) n (x, 0) 2)

The two actual mean stages complete the σ+1/10 mean and debt gains. Every increment and pressure-change estimate is derived internally from the post-signed residuals and measured debts.

noncomputable def NavierStokes.CorrectionStep.nativeBackground {D I : Type} (a : LinearWaveBounds.WaveCoefficients D) : LocalizedWaveBounds.WaveFamily D I

Only primitive background fields remain in this native family. Its amplitude and pressure are zero, so its bounds assume no constructed output.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.localInput_of_coefficients {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (a : PeriodizedWaveBounds.CopyData D I) {s : WeightedClasses.StripData D} {K : ℕ → I → Set D} {P : ℕ → D → ℝ} {α κ : ℝ} {d : LinearWaveBounds.GraphDirections D} (h : LocalizedWaveBounds.InputBounds s K (fun (n : ℕ) (x : I) => P n) 0 κ d (nativeBackground a.background)) (hP : ∀ (n : ℕ), ∀ x ∈ s.domain, 0 ≤ P n x) (ha : PeriodizedWaveBounds.LocalJets s (fun (n : ℕ) (x : D) => √(s.zeta x) * P n x) α K a.amplitude) (hp : PeriodizedWaveBounds.LocalJets s (fun (n : ℕ) (x : D) => √(s.zeta x) * P n x) (α + 1 / 2) K a.pressure) : LocalizedWaveBounds.InputBounds s K (fun (n : ℕ) (x : I) => P n) α κ d (LocalizedWaveBounds.rawFamily a)

structure NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeControl {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (P : ℕ → D → ℝ) (κ : ℝ) : Type

Uniform native-copy input data for the signed quotient. The current request is deliberately absent; it is supplied from the measured residual.

• cells : PeriodizedWaveBounds.Cells (D × ℝ) I

  Cells of NativeControl, of type PeriodizedWaveBounds.Cells (D × ℝ) I.

• phasePatch : ℕ → I → Set (D × ℝ)

  Phase patch of NativeControl, of type ℕ → I → Set (D × ℝ).

• background : LocalizedWaveBounds.InputBounds (HarmonicWaveInteraction.productStrip s) self.phasePatch (fun (n : ℕ) (x : I) (x_1 : D × ℝ) => P n x_1.1) 0 κ p.directions (nativeBackground p.base)
• covariance : SignedCopyBounds.NativeCovariance (HarmonicWaveInteraction.productStrip s) self.phasePatch p.matrix p.target

  Covariance supplied by NativeControl.

• mask : PeriodizedWaveBounds.LocalJets (HarmonicWaveInteraction.productStrip s) (fun (x : ℕ) (x_1 : D × ℝ) => 1) 0 self.phasePatch fun (n : ℕ) (i : I) => p.mask i n
• fundamental : PeriodizedWaveBounds.LocalJets (HarmonicWaveInteraction.productStrip s) (fun (n : ℕ) (x : D × ℝ) => P n x.1) 0 self.phasePatch fun (n : ℕ) (i : I) => p.fundamental i n
• normalMotion : PeriodizedWaveBounds.LocalJets (HarmonicWaveInteraction.productStrip s) (fun (x : ℕ) (x_1 : D × ℝ) => 1) 0 self.phasePatch fun (n : ℕ) (i : I) => p.normalMotion i n
• action : PeriodizedWaveBounds.LocalJets (HarmonicWaveInteraction.productStrip s) (fun (x : ℕ) (x_1 : D × ℝ) => 1) 0 self.phasePatch fun (n : ℕ) (i : I) => p.action i n
• cutoff : PeriodizedWaveBounds.LocalJets (HarmonicWaveInteraction.productStrip s) (fun (x : ℕ) (x_1 : D × ℝ) => 1) 0 self.phasePatch fun (n : ℕ) (i : I) => p.cutoff i n
• cutoff_support (n : ℕ) (i : I) : Function.support (p.cutoff i n) ⊆ self.cells.carrier n i
• phase_cover (n : ℕ) (i : I) (x : D × ℝ) : x ∈ (HarmonicWaveInteraction.productStrip s).domain → x ∈ self.cells.carrier n i → x ∈ self.phasePatch n i ∨ (p.cutoff i n =ᶠ[nhds x] fun (x : D × ℝ) => 0) ∨ p.mask i n =ᶠ[nhds x] fun (x : D × ℝ) => 0
• envelope_nonneg (n : ℕ) (x : D) : x ∈ s.domain → 0 ≤ P n x
• lower : ℝ

  Lower of NativeControl, of type ℝ.

• upper : ℝ

  Upper of NativeControl, of type ℝ.

• lower_pos : 0 < self.lower
• normal_lower (n : ℕ) (i : I) (x : D × ℝ) : x ∈ (HarmonicWaveInteraction.productStrip s).domain → x ∈ self.phasePatch n i → self.lower ≤ ‖p.base.normal (HarmonicWaveInteraction.productStrip s) p.directions n x‖
• normal_upper (n : ℕ) (i : I) (x : D × ℝ) : x ∈ (HarmonicWaveInteraction.productStrip s).domain → x ∈ self.phasePatch n i → ‖p.base.normal (HarmonicWaveInteraction.productStrip s) p.directions n x‖ ≤ self.upper
• inverse_frequency : WeightedClasses.BandBound (HarmonicWaveInteraction.productStrip s) (1 / 2) fun (n : ℕ) => 1 / p.base.frequency n

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.raw_zero_of_mask {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) (n : ℕ) (i : I) (x : D × ℝ) (hm : p.mask i n x = 0) : (p.copyData s request).amplitude n i x = 0 ∧ (p.copyData s request).pressure n i x = 0

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.localized_zero_of_mask {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) {n : ℕ} {i : I} {x : D × ℝ} (hm : p.mask i n =ᶠ[nhds x] fun (x : D × ℝ) => 0) : (((p.copyData s request).localized i).amplitude n =ᶠ[nhds x] fun (x : D × ℝ) => 0) ∧ ((p.copyData s request).localized i).pressure n =ᶠ[nhds x] fun (x : D × ℝ) => 0

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeControl.raw_jets {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ β : ℝ} (h : p.NativeControl s P κ) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) (hR : ∀ (j : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) β fun (n : ℕ) (x : D × ℝ) => request n x j) : PeriodizedWaveBounds.LocalJets (HarmonicWaveInteraction.productStrip s) (fun (n : ℕ) (x : D × ℝ) => √(s.zeta x.1) * P n x.1) (β + 1 / 2) h.phasePatch (p.copyData s request).amplitude ∧ PeriodizedWaveBounds.LocalJets (HarmonicWaveInteraction.productStrip s) (fun (n : ℕ) (x : D × ℝ) => √(s.zeta x.1) * P n x.1) (β + 1) h.phasePatch (p.copyData s request).pressure

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeControl.global_bounds {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ β : ℝ} (h : p.NativeControl s P κ) (hκ : κ ≤ 1 / 2) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) (hR : ∀ (j : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) β fun (n : ℕ) (x : D × ℝ) => request n x j) : WeightedClasses.WaveClass (HarmonicWaveInteraction.productStrip s) (fun (n : ℕ) (x : D × ℝ) => P n x.1) (β + 1 / 2) (p.copyData s request).common.amplitude ∧ WeightedClasses.WaveClass (HarmonicWaveInteraction.productStrip s) (fun (n : ℕ) (x : D × ℝ) => P n x.1) (β + 1 / 2) ((p.copyData s request).commonCorrected (HarmonicWaveInteraction.productStrip s) p.directions).amplitude ∧ WeightedClasses.WaveClass (HarmonicWaveInteraction.productStrip s) (fun (n : ℕ) (x : D × ℝ) => P n x.1) (β + 1) (p.copyData s request).common.pressure ∧ WeightedClasses.WaveClass (HarmonicWaveInteraction.productStrip s) (fun (n : ℕ) (x : D × ℝ) => P n x.1) (β + 1 - κ) ((p.copyData s request).common.curlCorrection (HarmonicWaveInteraction.productStrip s) p.directions) ∧ WeightedClasses.WaveClass (HarmonicWaveInteraction.productStrip s) (fun (n : ℕ) (x : D × ℝ) => P n x.1) (β + 1 - 3 * κ) ((p.copyData s request).globalGood (HarmonicWaveInteraction.productStrip s) p.directions)

All five full-lift classes are obtained from the actual quotient and uniform native data. Background estimates are used only on the cells.

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeControl.block_bounds {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ β : ℝ} (h : p.NativeControl s P κ) (hκ : κ ≤ 1 / 2) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) (hR : ∀ (j : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) β fun (n : ℕ) (x : D × ℝ) => request n x j) : CorrectionState.HarmonicBlock.WaveBounds s P (β + 1 / 2) (p.tangentBlock s request) ∧ CorrectionState.HarmonicBlock.WaveBounds s P (β + 1 / 2) (p.exactBlock s request) ∧ CorrectionState.HarmonicBlock.PressureBounds s P (β + 1) (p.exactBlock s request) ∧ CorrectionState.HarmonicBlock.WaveBounds s P (β + 1 - κ) (p.curlBlock s request) ∧ CorrectionState.HarmonicBlock.WaveBounds s P (β + 1 - 3 * κ) (p.goodBlock s request)

noncomputable def NavierStokes.CorrectionStep.ParticularParameters.nativeTangent {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] (p : ParticularParameters Q) (j : ℤ) : ℕ → CommonCoverSolve.TangentData (Q × ℝ) ProblemStatement.Space

Native tangent, defined pointwise by ParticularWaveAssembly.angleTangent (p.tangent j n).

Equations

• p.nativeTangent j n = NavierStokes.ParticularWaveAssembly.angleTangent (p.tangent j n)

structure NavierStokes.CorrectionStep.ParticularParameters.NativeControl {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] (p : ParticularParameters Q) (s : WeightedClasses.StripData (Q × TorusInverse.Plane)) (c : CorrectionState.Context (Q × TorusInverse.Plane)) (u : CorrectionState.State (Q × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)) (j : ℤ) (W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ) (α κ : ℝ) : Type

Input bounds for the actual complex Volterra solve on all of its native cells. The modal forcing is the literal current residual source.

• cells : PeriodizedWaveBounds.Cells ((Q × ℝ) × TorusInverse.Plane) TorusInverse.Frequency

  Cells of NativeControl, of type PeriodizedWaveBounds.Cells ((Q × ℝ) × Plane) Frequency.

• phasePatch : ℕ → TorusInverse.Frequency → Set ((Q × ℝ) × TorusInverse.Plane)

  Phase patch of NativeControl, of type ℕ → Frequency → Set ((Q × ℝ) × Plane).

• background : LocalizedWaveBounds.InputBounds (nativeStrip s) self.phasePatch (fun (n : ℕ) (x : TorusInverse.Frequency) => W n) 0 κ p.directions (nativeBackground (p.copyData c u b G A j).background)
• frame : ℕ → PrimaryODE.FrameData ((Q × ℝ) × ℝ)

  Frame of NativeControl, of type ℕ → PrimaryODE.FrameData ((Q × ℝ) × ℝ).

• envelope : ℕ → ℝ → ℝ

  Envelope of NativeControl, of type ℕ → ℝ → ℝ.

• realControl : ParticularCopyBounds.ModalControl (nativeStrip s) α self.frame (fun (n : ℕ) => ParticularWaveBounds.realData (p.nativeTangent j n) ((p.copyData c u b G A j).source n)) j p.geometry p.length self.envelope self.phasePatch

  Real control supplied by NativeControl.

• imagControl : ParticularCopyBounds.ModalControl (nativeStrip s) α self.frame (fun (n : ℕ) => ParticularWaveBounds.imagData (p.nativeTangent j n) ((p.copyData c u b G A j).source n)) j p.geometry p.length self.envelope self.phasePatch

  Imag control supplied by NativeControl.

• envelope_nonneg (n : ℕ) (x : (Q × ℝ) × TorusInverse.Plane) : x ∈ (nativeStrip s).domain → 0 ≤ W n x
• envelope_compare (n : ℕ) (i : TorusInverse.Frequency) (x : (Q × ℝ) × TorusInverse.Plane) : x ∈ (nativeStrip s).domain → x ∈ self.phasePatch n i → self.envelope n ((p.geometry n).coordinates i x.2).2 ≤ W n x
• normal : PeriodizedWaveBounds.LocalJets (nativeStrip s) (fun (x : ℕ) (x_1 : (Q × ℝ) × TorusInverse.Plane) => 1) 0 self.phasePatch fun (n : ℕ) (i : TorusInverse.Frequency) (x : (Q × ℝ) × TorusInverse.Plane) => (p.nativeTangent j n).normal (ParticularWaveBounds.nativePoint (p.geometry n) i x)
• normalMotion : PeriodizedWaveBounds.LocalJets (nativeStrip s) (fun (x : ℕ) (x_1 : (Q × ℝ) × TorusInverse.Plane) => 1) 0 self.phasePatch fun (n : ℕ) (i : TorusInverse.Frequency) (x : (Q × ℝ) × TorusInverse.Plane) => (p.nativeTangent j n).normalDot (ParticularWaveBounds.nativePoint (p.geometry n) i x)
• action : PeriodizedWaveBounds.LocalJets (nativeStrip s) (fun (x : ℕ) (x_1 : (Q × ℝ) × TorusInverse.Plane) => 1) 0 self.phasePatch fun (n : ℕ) (i : TorusInverse.Frequency) (x : (Q × ℝ) × TorusInverse.Plane) => (p.nativeTangent j n).action (ParticularWaveBounds.nativePoint (p.geometry n) i x)
• source : PeriodizedWaveBounds.LocalJets (nativeStrip s) (fun (n : ℕ) (x : (Q × ℝ) × TorusInverse.Plane) => √((nativeStrip s).zeta x) * W n x) α self.phasePatch fun (n : ℕ) (x : TorusInverse.Frequency) => (p.copyData c u b G A j).source n
• cutoff : PeriodizedWaveBounds.LocalJets (nativeStrip s) (fun (x : ℕ) (x_1 : (Q × ℝ) × TorusInverse.Plane) => 1) 0 self.phasePatch (p.copyData c u b G A j).cutoff
• cutoff_support (n : ℕ) (i : TorusInverse.Frequency) : Function.support ((p.copyData c u b G A j).cutoff n i) ⊆ self.cells.carrier n i
• phase_cover (n : ℕ) (i : TorusInverse.Frequency) (x : (Q × ℝ) × TorusInverse.Plane) : x ∈ (nativeStrip s).domain → x ∈ self.cells.carrier n i → x ∈ self.phasePatch n i ∨ ∀ᶠ (y : (Q × ℝ) × TorusInverse.Plane) in nhds x, ((p.geometry n).coordinates i y.2).2 ∈ Set.Icc 0 (p.length n) ∧ ∀ v ∈ Set.Icc 0 (p.length n), (p.copyData c u b G A j).source n (y.1, (p.geometry n).path i y.2 v) = 0
• lower : ℝ

  Lower of NativeControl, of type ℝ.

• upper : ℝ

  Upper of NativeControl, of type ℝ.

• lower_pos : 0 < self.lower
• normal_lower (n : ℕ) (i : TorusInverse.Frequency) (x : (Q × ℝ) × TorusInverse.Plane) : x ∈ (nativeStrip s).domain → x ∈ self.phasePatch n i → self.lower ≤ ‖(p.nativeTangent j n).normal (ParticularWaveBounds.nativePoint (p.geometry n) i x)‖
• normal_upper (n : ℕ) (i : TorusInverse.Frequency) (x : (Q × ℝ) × TorusInverse.Plane) : x ∈ (nativeStrip s).domain → x ∈ self.phasePatch n i → ‖(p.nativeTangent j n).normal (ParticularWaveBounds.nativePoint (p.geometry n) i x)‖ ≤ self.upper
• normal_match (n : ℕ) (i : TorusInverse.Frequency) (x : (Q × ℝ) × TorusInverse.Plane) : x ∈ (nativeStrip s).domain → x ∈ self.phasePatch n i → (p.copyData c u b G A j).background.normal (nativeStrip s) p.directions n x = (p.nativeTangent j n).normal (ParticularWaveBounds.nativePoint (p.geometry n) i x)
• inverse_frequency : WeightedClasses.BandBound (nativeStrip s) (1 / 2) fun (n : ℕ) => 1 / (p.copyData c u b G A j).background.frequency n

theorem NavierStokes.CorrectionStep.ParticularParameters.raw_zero_of_source_path {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {p : ParticularParameters Q} {c : CorrectionState.Context (Q × TorusInverse.Plane)} {u : CorrectionState.State (Q × TorusInverse.Plane)} {b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)} {G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)} {j : ℤ} {n : ℕ} {i : TorusInverse.Frequency} {x : (Q × ℝ) × TorusInverse.Plane} (hf : ∀ᶠ (y : (Q × ℝ) × TorusInverse.Plane) in nhds x, ((p.geometry n).coordinates i y.2).2 ∈ Set.Icc 0 (p.length n) ∧ ∀ v ∈ Set.Icc 0 (p.length n), (p.copyData c u b G A j).source n (y.1, (p.geometry n).path i y.2 v) = 0) : ((p.copyData c u b G A j).amplitude n i =ᶠ[nhds x] fun (x : (Q × ℝ) × TorusInverse.Plane) => 0) ∧ ((p.copyData c u b G A j).pressure n i =ᶠ[nhds x] fun (x : (Q × ℝ) × TorusInverse.Plane) => 0) ∧ (p.copyData c u b G A j).source n =ᶠ[nhds x] fun (x : (Q × ℝ) × TorusInverse.Plane) => 0

theorem NavierStokes.CorrectionStep.ParticularParameters.localized_zero_of_source_path {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {p : ParticularParameters Q} {c : CorrectionState.Context (Q × TorusInverse.Plane)} {u : CorrectionState.State (Q × TorusInverse.Plane)} {b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)} {G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)} {j : ℤ} {n : ℕ} {i : TorusInverse.Frequency} {x : (Q × ℝ) × TorusInverse.Plane} (hf : ∀ᶠ (y : (Q × ℝ) × TorusInverse.Plane) in nhds x, ((p.geometry n).coordinates i y.2).2 ∈ Set.Icc 0 (p.length n) ∧ ∀ v ∈ Set.Icc 0 (p.length n), (p.copyData c u b G A j).source n (y.1, (p.geometry n).path i y.2 v) = 0) : (((p.copyData c u b G A j).localized i).amplitude n =ᶠ[nhds x] fun (x : (Q × ℝ) × TorusInverse.Plane) => 0) ∧ ((p.copyData c u b G A j).localized i).pressure n =ᶠ[nhds x] fun (x : (Q × ℝ) × TorusInverse.Plane) => 0

theorem NavierStokes.CorrectionStep.ParticularParameters.NativeControl.raw_jets {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {p : ParticularParameters Q} {s : WeightedClasses.StripData (Q × TorusInverse.Plane)} {c : CorrectionState.Context (Q × TorusInverse.Plane)} {u : CorrectionState.State (Q × TorusInverse.Plane)} {b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)} {G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)} {j : ℤ} {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} (h : p.NativeControl s c u b G A j W α κ) : PeriodizedWaveBounds.LocalJets (nativeStrip s) (fun (n : ℕ) (x : (Q × ℝ) × TorusInverse.Plane) => √((nativeStrip s).zeta x) * W n x) α h.phasePatch (p.copyData c u b G A j).amplitude ∧ PeriodizedWaveBounds.LocalJets (nativeStrip s) (fun (n : ℕ) (x : (Q × ℝ) × TorusInverse.Plane) => √((nativeStrip s).zeta x) * W n x) (α + 1 / 2) h.phasePatch (p.copyData c u b G A j).pressure

theorem NavierStokes.CorrectionStep.ParticularParameters.NativeControl.global_bounds {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {p : ParticularParameters Q} {s : WeightedClasses.StripData (Q × TorusInverse.Plane)} {c : CorrectionState.Context (Q × TorusInverse.Plane)} {u : CorrectionState.State (Q × TorusInverse.Plane)} {b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)} {G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)} {j : ℤ} {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} (h : p.NativeControl s c u b G A j W α κ) (hκ : κ ≤ 1 / 2) : WeightedClasses.WaveClass (nativeStrip s) W α (p.copyData c u b G A j).common.amplitude ∧ WeightedClasses.WaveClass (nativeStrip s) W α (p.wave s c u b G A j).amplitude ∧ WeightedClasses.WaveClass (nativeStrip s) W (α + 1 / 2) (p.copyData c u b G A j).common.pressure ∧ WeightedClasses.WaveClass (nativeStrip s) W (α + 1 / 2 - κ) ((p.copyData c u b G A j).common.curlCorrection (nativeStrip s) p.directions) ∧ WeightedClasses.WaveClass (nativeStrip s) W (α + 1 / 2 - 3 * κ) ((p.copyData c u b G A j).globalGood (nativeStrip s) p.directions)

The global amplitude, pressure, exact curl, and retained linear error are derived from native modal inputs for the same actual residual solve.

theorem NavierStokes.CorrectionStep.ParticularParameters.sectionStrip_nativeStrip {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] (s : WeightedClasses.StripData (Q × TorusInverse.Plane)) : ParticularWaveAssembly.sectionStrip (nativeStrip s) = s

theorem NavierStokes.CorrectionStep.ParticularParameters.assembled_bounds {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] (p : ParticularParameters Q) (s : WeightedClasses.StripData (Q × TorusInverse.Plane)) (c : CorrectionState.Context (Q × TorusInverse.Plane)) (u : CorrectionState.State (Q × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)) (N : ℕ) {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} (C : (j : ℤ) → j ∈ ParticularWaveAssembly.modes N → p.NativeControl s c u b G A j W α κ) (hW : ∀ (n : ℕ), ∀ x ∈ (nativeStrip s).domain, 0 ≤ W n x) (hκ : κ ≤ 1 / 2) : CorrectionState.HarmonicBlock.WaveBounds s (fun (n : ℕ) (x : Q × TorusInverse.Plane) => W n (ParticularWaveAssembly.angleShuffle (x, 0))) α (p.updateBlock s c u b G A N) ∧ CorrectionState.HarmonicBlock.PressureBounds s (fun (n : ℕ) (x : Q × TorusInverse.Plane) => W n (ParticularWaveAssembly.angleShuffle (x, 0))) (α + 1 / 2) (p.updateBlock s c u b G A N) ∧ CorrectionState.HarmonicBlock.WaveBounds s (fun (n : ℕ) (x : Q × TorusInverse.Plane) => W n (ParticularWaveAssembly.angleShuffle (x, 0))) (α + 1 / 2 - 3 * κ) (p.goodBlock s c u b G A N)

theorem NavierStokes.CorrectionStep.localClass_contDiffOn_inter {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E] {s : WeightedClasses.StripData D} {C : ℕ → I → Set D} {w : ℕ → I → D → ℝ} {α : ℝ} {f : ℕ → I → D → E} (hf : LocalizedWaveBounds.LocalClass s C w α f) (hC : ∀ (n : ℕ) (i : I), IsOpen (C n i)) (n : ℕ) (i : I) : ContDiffOn ℝ (↑⊤) (f n i) (s.domain ∩ C n i)

structure NavierStokes.CorrectionStep.NativeAngularGeometry {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (a : PeriodizedWaveBounds.CopyData D I) (s : WeightedClasses.StripData D) (d : LinearWaveBounds.GraphDirections D) (C : ℕ → I → Set D) : Prop

Angular and radial geometry of the actual raw copies. The analytic bounds on the normal and material defect remain restricted to C.

• open_patch (n : ℕ) (i : I) : IsOpen (C n i)
• phase_smooth (n : ℕ) : ContDiffOn ℝ (↑⊤) (a.background.phase n) s.domain
• radius_nonzero (n : ℕ) (i : I) (x : D) : x ∈ s.domain → x ∈ C n i → a.background.radius n x ≠ 0
• radial_radius (n : ℕ) (i : I) (x : D) : x ∈ s.domain → x ∈ C n i → HarmonicCalculus.along (d.radialField n) (a.background.radius n) x = 1
• radius (n : ℕ) : CopyAngularInvariance.Invariant d.angular (a.background.radius n)
• radial_base (n : ℕ) : CopyAngularInvariance.Invariant d.angular (a.background.radialBase n)
• frequency_base (n : ℕ) : CopyAngularInvariance.Invariant d.angular (a.background.frequencyBase n)
• axial_base (n : ℕ) : CopyAngularInvariance.Invariant d.angular (a.background.axialBase n)
• radial_field (n : ℕ) : CopyAngularInvariance.Invariant d.angular (d.radialField n)
• phase (n : ℕ) : ∃ (m : ℝ), CopyAngularInvariance.AffinePhase d.angular m (a.background.phase n)
• amplitude (i : I) (n : ℕ) : CopyAngularInvariance.Invariant d.angular (a.amplitude n i)
• pressure (i : I) (n : ℕ) : CopyAngularInvariance.Invariant d.angular (a.pressure n i)
• cutoff (i : I) (n : ℕ) : CopyAngularInvariance.Invariant d.angular (a.cutoff n i)

theorem NavierStokes.CorrectionStep.NativeAngularGeometry.exactOn {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {a : PeriodizedWaveBounds.CopyData D I} {s : WeightedClasses.StripData D} {d : LinearWaveBounds.GraphDirections D} {C : ℕ → I → Set D} {P : ℕ → I → D → ℝ} {α κ lower upper : ℝ} (g : NativeAngularGeometry a s d C) (h : LocalizedWaveBounds.InputBounds s C P α κ d (LocalizedWaveBounds.rawFamily a)) (hψ : LocalizedWaveBounds.LocalUnweighted s C 0 a.cutoff) (hκ : κ ≤ 1 / 2) (hlower : 0 < lower) (hlo : ∀ (n : ℕ) (i : I), ∀ x ∈ s.domain, x ∈ C n i → lower ≤ ‖a.background.normal s d n x‖) (hhi : ∀ (n : ℕ) (i : I), ∀ x ∈ s.domain, x ∈ C n i → ‖a.background.normal s d n x‖ ≤ upper) (hfreq : LocalizedWaveBounds.LocalUnweighted s C (1 / 2) fun (n : ℕ) (x : I) (x_1 : D) => 1 / a.background.frequency n) (n : ℕ) (i : I) : LocalizedWaveBounds.ExactOn (a.corrected s d i) s d n (s.domain ∩ C n i)

theorem NavierStokes.CorrectionStep.native_cancellation_of_principal {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {a : PeriodizedWaveBounds.CopyData D I} {s : WeightedClasses.StripData D} {d : LinearWaveBounds.GraphDirections D} {C : ℕ → I → Set D} {P : ℕ → I → D → ℝ} {α κ lower upper : ℝ} (g : NativeAngularGeometry a s d C) (h : LocalizedWaveBounds.InputBounds s C P α κ d (LocalizedWaveBounds.rawFamily a)) (hψ : LocalizedWaveBounds.LocalUnweighted s C 0 a.cutoff) (hκ : κ ≤ 1 / 2) (hlower : 0 < lower) (hlo : ∀ (n : ℕ) (i : I), ∀ x ∈ s.domain, x ∈ C n i → lower ≤ ‖a.background.normal s d n x‖) (hhi : ∀ (n : ℕ) (i : I), ∀ x ∈ s.domain, x ∈ C n i → ‖a.background.normal s d n x‖ ≤ upper) (hfreq : LocalizedWaveBounds.LocalUnweighted s C (1 / 2) fun (n : ℕ) (x : I) (x_1 : D) => 1 / a.background.frequency n) (n : ℕ) (i : I) {x : D} (hx : x ∈ s.domain) (hi : x ∈ C n i) (hsolve : (a.raw i).principal s d n x = -a.source n x) : ((a.corrected s d i).harmonicResidual s d n x + fun (j : Fin 3) => a.source n x j * HarmonicCalculus.carrier (a.background.frequency n) (a.background.phase n) x) = fun (j : Fin 3) => (a.localGood s d n i x j + a.localGaussian d n i x j) * HarmonicCalculus.carrier (a.background.frequency n) (a.background.phase n) x

The generic local identity is applied only after the primitive raw principal equation has been proved by its actual ODE constructor.

theorem NavierStokes.CorrectionStep.harmonicResidual_zero_germ {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (a : LinearWaveBounds.WaveCoefficients D) (s : WeightedClasses.StripData D) (d : LinearWaveBounds.GraphDirections D) {n : ℕ} {x : D} (ha : a.amplitude n =ᶠ[nhds x] fun (x : D) => 0) (hp : a.pressure n =ᶠ[nhds x] fun (x : D) => 0) : a.harmonicResidual s d n =ᶠ[nhds x] fun (x : D) => 0

theorem NavierStokes.CorrectionStep.local_cancellation_of_zero_germs {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (a : PeriodizedWaveBounds.CopyData D I) (s : WeightedClasses.StripData D) (d : LinearWaveBounds.GraphDirections D) {n : ℕ} {i : I} {x : D} (ha : (a.localized i).amplitude n =ᶠ[nhds x] fun (x : D) => 0) (hp : (a.localized i).pressure n =ᶠ[nhds x] fun (x : D) => 0) (hg : a.localGaussian d n i =ᶠ[nhds x] fun (x : D) => 0) (hf : a.source n =ᶠ[nhds x] fun (x : D) => 0) : ((a.corrected s d i).harmonicResidual s d n x + fun (j : Fin 3) => a.source n x j * HarmonicCalculus.carrier (a.background.frequency n) (a.background.phase n) x) = fun (j : Fin 3) => (a.localGood s d n i x j + a.localGaussian d n i x j) * HarmonicCalculus.carrier (a.background.frequency n) (a.background.phase n) x

structure NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeDynamics {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ : ℝ} (h : p.NativeControl s P κ) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : Type

Primitive angular identities and the fixed unit fundamental's ODE. The signed principal equation and every cutoff/curl identity are derived.

• slope : ℕ → ℝ

  Slope of NativeDynamics, of type ℕ → ℝ.

• angular (i : I) : SignedWaveUpdate.AngularInputs (HarmonicWaveInteraction.productStrip s) p.directions p.base (p.matrix i) (p.target i) request (p.mask i) (p.fundamental i) (p.normalMotion i) (p.action i) (p.cutoff i) self.slope
• open_patch (n : ℕ) (i : I) : IsOpen (h.phasePatch n i)
• radius_nonzero (n : ℕ) (i : I) (x : D × ℝ) : x ∈ (HarmonicWaveInteraction.productStrip s).domain → x ∈ h.phasePatch n i → p.base.radius n x ≠ 0
• radial_radius (n : ℕ) (i : I) (x : D × ℝ) : x ∈ (HarmonicWaveInteraction.productStrip s).domain → x ∈ h.phasePatch n i → HarmonicCalculus.along (p.directions.radialField n) (p.base.radius n) x = 1
• matrix_frozen (i : I) : SignedWaveUpdate.FrozenAlong p.directions.fast (p.matrix i)
• target_frozen (i : I) : SignedWaveUpdate.FrozenAlong p.directions.fast (p.target i)
• request_frozen : SignedWaveUpdate.FrozenAlong p.directions.fast request
• mask_frozen (i : I) : SignedWaveUpdate.FrozenAlong p.directions.fast (p.mask i)
• frequency_nonzero (n : ℕ) : p.base.frequency n ≠ 0
• ode (n : ℕ) (i : I) (x : D × ℝ) : x ∈ (HarmonicWaveInteraction.productStrip s).domain → x ∈ h.phasePatch n i → HarmonicCalculus.along (p.directions.fastField n) (p.fundamental i n) x = TangentProjection.projectedRhs (p.base.normal (HarmonicWaveInteraction.productStrip s) p.directions n x) (p.normalMotion i n x) (p.fundamental i n x) ((p.action i n x) (p.fundamental i n x)) 0 (s.epsilon n * p.base.frequency n ^ 2 * ‖p.base.normal (HarmonicWaveInteraction.productStrip s) p.directions n x‖ ^ 2)
• action_eq (n : ℕ) (i : I) (x : D × ℝ) : x ∈ (HarmonicWaveInteraction.productStrip s).domain → x ∈ h.phasePatch n i → CurlClassBounds.complexify ((p.action i n x) (p.fundamental i n x)) = LinearWaveResidual.shear (p.base.radius n) (p.base.frequencyBase n) (p.base.axialBase n) (p.directions.radialField n) (fun (y : D × ℝ) => CurlClassBounds.complexify (p.fundamental i n y)) x

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeDynamics.angularGeometry {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ : ℝ} {h : p.NativeControl s P κ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (d : NativeDynamics h request) (i₀ : I) : NativeAngularGeometry (p.copyData s request) (HarmonicWaveInteraction.productStrip s) p.directions h.phasePatch

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeDynamics.principal {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ β : ℝ} {h : p.NativeControl s P κ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (d : NativeDynamics h request) (hR : ∀ (j : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) β fun (n : ℕ) (x : D × ℝ) => request n x j) (n : ℕ) (i : I) {x : D × ℝ} (hx : x ∈ (HarmonicWaveInteraction.productStrip s).domain) (hi : x ∈ h.phasePatch n i) : ((p.copyData s request).raw i).principal (HarmonicWaveInteraction.productStrip s) p.directions n x = 0

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeDynamics.local_equation {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ β : ℝ} {h : p.NativeControl s P κ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (d : NativeDynamics h request) (hκ : κ ≤ 1 / 2) (hR : ∀ (j : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) β fun (n : ℕ) (x : D × ℝ) => request n x j) (n : ℕ) (i : I) {x : D × ℝ} (hx : x ∈ (HarmonicWaveInteraction.productStrip s).domain) (hi : x ∈ h.phasePatch n i) : (((p.copyData s request).corrected (HarmonicWaveInteraction.productStrip s) p.directions i).harmonicResidual (HarmonicWaveInteraction.productStrip s) p.directions n x + fun (j : Fin 3) => (p.copyData s request).source n x j * HarmonicCalculus.carrier (p.base.frequency n) (p.base.phase n) x) = fun (j : Fin 3) => ((p.copyData s request).localGood (HarmonicWaveInteraction.productStrip s) p.directions n i x j + (p.copyData s request).localGaussian p.directions n i x j) * HarmonicCalculus.carrier (p.base.frequency n) (p.base.phase n) x

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeDynamics.common_equation {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ β : ℝ} {h : p.NativeControl s P κ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (d : NativeDynamics h request) (hκ : κ ≤ 1 / 2) (hR : ∀ (j : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) β fun (n : ℕ) (x : D × ℝ) => request n x j) (n : ℕ) {x : D × ℝ} (hx : x ∈ (HarmonicWaveInteraction.productStrip s).domain) : ((p.copyData s request).commonCorrected (HarmonicWaveInteraction.productStrip s) p.directions).harmonicResidual (HarmonicWaveInteraction.productStrip s) p.directions n x = fun (j : Fin 3) => ((p.copyData s request).globalGood (HarmonicWaveInteraction.productStrip s) p.directions n x j + (p.copyData s request).globalGaussian p.directions n x j) * HarmonicCalculus.carrier (p.base.frequency n) (p.base.phase n) x

The literal signed common curl has its actual retained good term and Gaussian derivative tail on the entire lift. Native ODE input is needed only on the supported phase patches.

structure NavierStokes.CorrectionStep.ParticularParameters.NativeDynamics {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {p : ParticularParameters Q} {s : WeightedClasses.StripData (Q × TorusInverse.Plane)} {c : CorrectionState.Context (Q × TorusInverse.Plane)} {u : CorrectionState.State (Q × TorusInverse.Plane)} {b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)} {G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)} {j : ℤ} {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} (h : p.NativeControl s c u b G A j W α κ) : Prop

Native dynamics data, collecting background, open_patch, frequency_nonzero, damping, fast, action.

• background : ParticularWaveAssembly.BackgroundControl (nativeStrip s) p.directions p.background b j
• open_patch (n : ℕ) (i : TorusInverse.Frequency) : IsOpen (h.phasePatch n i)
• frequency_nonzero (n : ℕ) : ↑j * b.frequency n ≠ 0
• damping (n : ℕ) (i : TorusInverse.Frequency) (x : (Q × ℝ) × TorusInverse.Plane) : x ∈ (nativeStrip s).domain → x ∈ h.phasePatch n i → (p.nativeTangent j n).damping (ParticularWaveBounds.nativePoint (p.geometry n) i x) = s.epsilon n * (↑j * b.frequency n) ^ 2 * ‖(p.copyData c u b G A j).background.normal (nativeStrip s) p.directions n x‖ ^ 2
• fast (n : ℕ) : p.directions.fastScale n • p.directions.fast = (0, ParticularWaveBounds.slotDirection (p.geometry n))
• action (n : ℕ) (i : TorusInverse.Frequency) (x : (Q × ℝ) × TorusInverse.Plane) : x ∈ (nativeStrip s).domain → x ∈ h.phasePatch n i → ∀ (z : ProblemStatement.Space), CurlClassBounds.complexify (((p.nativeTangent j n).action (ParticularWaveBounds.nativePoint (p.geometry n) i x)) z) = LinearWaveResidual.shear (p.background.radius n) (p.background.frequencyBase n) (p.background.axialBase n) (p.directions.radialField n) (fun (x : (Q × ℝ) × TorusInverse.Plane) => CurlClassBounds.complexify z) x

theorem NavierStokes.CorrectionStep.ParticularParameters.NativeDynamics.angularGeometry {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {p : ParticularParameters Q} {s : WeightedClasses.StripData (Q × TorusInverse.Plane)} {c : CorrectionState.Context (Q × TorusInverse.Plane)} {u : CorrectionState.State (Q × TorusInverse.Plane)} {b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)} {G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)} {j : ℤ} {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} {h : p.NativeControl s c u b G A j W α κ} (d : NativeDynamics h) : NativeAngularGeometry (p.copyData c u b G A j) (nativeStrip s) p.directions h.phasePatch

theorem NavierStokes.CorrectionStep.ParticularParameters.NativeDynamics.principal {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {p : ParticularParameters Q} {s : WeightedClasses.StripData (Q × TorusInverse.Plane)} {c : CorrectionState.Context (Q × TorusInverse.Plane)} {u : CorrectionState.State (Q × TorusInverse.Plane)} {b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)} {G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)} {j : ℤ} {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} {h : p.NativeControl s c u b G A j W α κ} (d : NativeDynamics h) (n : ℕ) (i : TorusInverse.Frequency) {x : (Q × ℝ) × TorusInverse.Plane} (hx : x ∈ (nativeStrip s).domain) (hi : x ∈ h.phasePatch n i) : ((p.copyData c u b G A j).raw i).principal (nativeStrip s) p.directions n x = -(p.copyData c u b G A j).source n x

theorem NavierStokes.CorrectionStep.ParticularParameters.NativeDynamics.local_equation {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {p : ParticularParameters Q} {s : WeightedClasses.StripData (Q × TorusInverse.Plane)} {c : CorrectionState.Context (Q × TorusInverse.Plane)} {u : CorrectionState.State (Q × TorusInverse.Plane)} {b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)} {G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)} {j : ℤ} {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} {h : p.NativeControl s c u b G A j W α κ} (d : NativeDynamics h) (hκ : κ ≤ 1 / 2) (n : ℕ) (i : TorusInverse.Frequency) {x : (Q × ℝ) × TorusInverse.Plane} (hx : x ∈ (nativeStrip s).domain) (hi : x ∈ h.phasePatch n i) : (((p.copyData c u b G A j).corrected (nativeStrip s) p.directions i).harmonicResidual (nativeStrip s) p.directions n x + fun (k : Fin 3) => (p.copyData c u b G A j).source n x k * HarmonicCalculus.carrier (↑j * b.frequency n) ((ParticularWaveAssembly.actualCarrier p.background b j).phase n) x) = fun (k : Fin 3) => ((p.copyData c u b G A j).localGood (nativeStrip s) p.directions n i x k + (p.copyData c u b G A j).localGaussian p.directions n i x k) * HarmonicCalculus.carrier (↑j * b.frequency n) ((ParticularWaveAssembly.actualCarrier p.background b j).phase n) x

theorem NavierStokes.CorrectionStep.ParticularParameters.NativeDynamics.common_equation {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {p : ParticularParameters Q} {s : WeightedClasses.StripData (Q × TorusInverse.Plane)} {c : CorrectionState.Context (Q × TorusInverse.Plane)} {u : CorrectionState.State (Q × TorusInverse.Plane)} {b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)} {G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)} {j : ℤ} {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} {h : p.NativeControl s c u b G A j W α κ} (d : NativeDynamics h) (hκ : κ ≤ 1 / 2) (n : ℕ) {x : (Q × ℝ) × TorusInverse.Plane} (hx : x ∈ (nativeStrip s).domain) : ((p.wave s c u b G A j).harmonicResidual (nativeStrip s) p.directions n x + fun (k : Fin 3) => (p.copyData c u b G A j).source n x k * HarmonicCalculus.carrier (↑j * b.frequency n) ((ParticularWaveAssembly.actualCarrier p.background b j).phase n) x) = fun (k : Fin 3) => ((p.copyData c u b G A j).globalGood (nativeStrip s) p.directions n x k + (p.copyData c u b G A j).globalGaussian p.directions n x k) * HarmonicCalculus.carrier (↑j * b.frequency n) ((ParticularWaveAssembly.actualCarrier p.background b j).phase n) x

The actual inhomogeneous common wave cancels the literal HR source on the whole lift, including the uncovered-source term in its Gaussian.

theorem NavierStokes.CorrectionStep.NativeAngularGeometry.common_amplitude {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {a : PeriodizedWaveBounds.CopyData D I} {s : WeightedClasses.StripData D} {d : LinearWaveBounds.GraphDirections D} {C : ℕ → I → Set D} (g : NativeAngularGeometry a s d C) (n : ℕ) : CopyAngularInvariance.Invariant d.angular (a.common.amplitude n)

theorem NavierStokes.CorrectionStep.NativeAngularGeometry.common_pressure {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {a : PeriodizedWaveBounds.CopyData D I} {s : WeightedClasses.StripData D} {d : LinearWaveBounds.GraphDirections D} {C : ℕ → I → Set D} (g : NativeAngularGeometry a s d C) (n : ℕ) : CopyAngularInvariance.Invariant d.angular (a.common.pressure n)

theorem NavierStokes.CorrectionStep.NativeAngularGeometry.corrected_amplitude {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {a : PeriodizedWaveBounds.CopyData D I} {s : WeightedClasses.StripData D} {d : LinearWaveBounds.GraphDirections D} {C : ℕ → I → Set D} (g : NativeAngularGeometry a s d C) (n : ℕ) : CopyAngularInvariance.Invariant d.angular ((a.commonCorrected s d).amplitude n)

theorem NavierStokes.CorrectionStep.NativeAngularGeometry.good {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {a : PeriodizedWaveBounds.CopyData D I} {s : WeightedClasses.StripData D} {d : LinearWaveBounds.GraphDirections D} {C : ℕ → I → Set D} (g : NativeAngularGeometry a s d C) (n : ℕ) : CopyAngularInvariance.Invariant d.angular (a.globalGood s d n)

theorem NavierStokes.CorrectionStep.NativeAngularGeometry.gaussian {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {a : PeriodizedWaveBounds.CopyData D I} {s : WeightedClasses.StripData D} {d : LinearWaveBounds.GraphDirections D} {C : ℕ → I → Set D} (g : NativeAngularGeometry a s d C) (hf : ∀ (n : ℕ), CopyAngularInvariance.Invariant d.angular (a.source n)) (n : ℕ) : CopyAngularInvariance.Invariant d.angular (a.globalGaussian d n)

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeDynamics.phase_eq {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ : ℝ} {h : p.NativeControl s P κ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (d : NativeDynamics h request) (i₀ : I) (hθ : p.directions.angular = (0, 1)) (hkp : ∀ (n : ℕ), p.base.frequency n * d.slope n = ↑(p.angularFrequency n)) (n : ℕ) (x : D) (θ : ℝ) : p.base.frequency n * p.base.phase n (x, θ) = p.base.frequency n * p.base.phase n (x, 0) + ↑(p.angularFrequency n) * θ

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeDynamics.exact_represents {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ : ℝ} {h : p.NativeControl s P κ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (d : NativeDynamics h request) (i₀ : I) (hθ : p.directions.angular = (0, 1)) (hkp : ∀ (n : ℕ), p.base.frequency n * d.slope n = ↑(p.angularFrequency n)) : have z := (p.copyData s request).commonCorrected (HarmonicWaveInteraction.productStrip s) p.directions; ((p.exactBlock s request).oscillation = fun (n : ℕ) (x : D × ℝ) (i : Fin 3) => (HarmonicCalculus.vectorMode (p.base.frequency n) (p.base.phase n) (z.amplitude n) x i).re) ∧ (p.exactBlock s request).oscillatoryPressure = fun (n : ℕ) (x : D × ℝ) => (HarmonicCalculus.mode (p.base.frequency n) (p.base.phase n) (z.pressure n) x).re

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeDynamics.good_represents {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ : ℝ} {h : p.NativeControl s P κ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (d : NativeDynamics h request) (i₀ : I) (hθ : p.directions.angular = (0, 1)) (hkp : ∀ (n : ℕ), p.base.frequency n * d.slope n = ↑(p.angularFrequency n)) : (p.goodBlock s request).oscillation = fun (n : ℕ) (x : D × ℝ) (i : Fin 3) => ((p.copyData s request).globalGood (HarmonicWaveInteraction.productStrip s) p.directions n x i * HarmonicCalculus.carrier (p.base.frequency n) (p.base.phase n) x).re

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeDynamics.gaussian_represents {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ : ℝ} {h : p.NativeControl s P κ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (d : NativeDynamics h request) (i₀ : I) (hθ : p.directions.angular = (0, 1)) (hkp : ∀ (n : ℕ), p.base.frequency n * d.slope n = ↑(p.angularFrequency n)) : (p.gaussianBlock s request).oscillation = fun (n : ℕ) (x : D × ℝ) (i : Fin 3) => ((p.copyData s request).globalGaussian p.directions n x i * HarmonicCalculus.carrier (p.base.frequency n) (p.base.phase n) x).re

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.frame_common {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) {c : CorrectionState.Context D} (hm : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) p.directions p.base) : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) p.directions ((p.copyData s request).commonCorrected (HarmonicWaveInteraction.productStrip s) p.directions)

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.exactBlock_zero {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) : HarmonicWaveInteraction.ZeroMode (p.exactBlock s request)

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.exactBlock_pressure_zero {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) (n : ℕ) : ((p.exactBlock s request).pressure n).coeff 0 = 0

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeDynamics.context_linear_identity {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ β : ℝ} {h : p.NativeControl s P κ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (d : NativeDynamics h request) (i₀ : I) (hκ : κ ≤ 1 / 2) (hR : ∀ (i : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) β fun (n : ℕ) (x : D × ℝ) => request n x i) (hkp : ∀ (n : ℕ), p.base.frequency n * d.slope n = ↑(p.angularFrequency n)) (c : CorrectionState.Context D) (hB : MeanIncrementBounds.SmoothTriple s.domain c.base) (hrad : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (HarmonicResidual.contextFrame c n).radial s.domain) (hm : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) p.directions p.base) (a : CorrectionState.HarmonicBlock D) (hcarrier : SameCarrier a (p.exactBlock s request)) (n : ℕ) (x : D × ℝ) (hx : x.1 ∈ s.domain) : linearBlockField c a (p.exactBlock s request) n x = (p.goodBlock s request).oscillation n x + (p.gaussianBlock s request).oscillation n x

The periodized signed update satisfies the actual context linear operator, with the computed Gaussian term retained.

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeDynamics.linearGood_bounds {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ β : ℝ} {h : p.NativeControl s P κ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (d : NativeDynamics h request) (i₀ : I) (hκ : κ ≤ 1 / 2) (hR : ∀ (i : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) β fun (n : ℕ) (x : D × ℝ) => request n x i) (hkp : ∀ (n : ℕ), p.base.frequency n * d.slope n = ↑(p.angularFrequency n)) (hkpne : ∀ (n : ℕ), p.angularFrequency n ≠ 0) (c : CorrectionState.Context D) (hB : MeanIncrementBounds.SmoothTriple s.domain c.base) (hrad : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (HarmonicResidual.contextFrame c n).radial s.domain) (hm : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) p.directions p.base) (a : CorrectionState.HarmonicBlock D) (hcarrier : SameCarrier a (p.exactBlock s request)) : CorrectionState.HarmonicBlock.WaveBounds s P (β + 1 - 3 * κ) (HarmonicWaveInteraction.linearGoodBlock c a (p.exactBlock s request) (p.gaussianBlock s request).velocity)

This is the literal HWI linear remainder of the constructed common signed block; its class follows from the native quotient and unit ODE.

theorem NavierStokes.CorrectionStep.harmonicResidual_reindex {D E : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] [NormedAddCommGroup E] [NormedSpace ℝ E] (e : D ≃ₗᵢ[ℝ] E) (a : LinearWaveBounds.WaveCoefficients E) (s : WeightedClasses.StripData E) (d : LinearWaveBounds.GraphDirections E) (n : ℕ) (x : D) : (ParticularWaveBounds.reindexCoefficients e a).harmonicResidual (ParticularWaveBounds.reindexStrip e s) (ParticularWaveBounds.reindexDirections e d) n x = a.harmonicResidual s d n (e x)

theorem NavierStokes.CorrectionStep.ParticularParameters.NativeDynamics.frequency_ne {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {p : ParticularParameters Q} {s : WeightedClasses.StripData (Q × TorusInverse.Plane)} {c : CorrectionState.Context (Q × TorusInverse.Plane)} {u : CorrectionState.State (Q × TorusInverse.Plane)} {b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)} {G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)} {j : ℤ} {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} {h : p.NativeControl s c u b G A j W α κ} (d : NativeDynamics h) (n : ℕ) : b.frequency n ≠ 0

theorem NavierStokes.CorrectionStep.ParticularParameters.NativeDynamics.good_invariant {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {p : ParticularParameters Q} {s : WeightedClasses.StripData (Q × TorusInverse.Plane)} {c : CorrectionState.Context (Q × TorusInverse.Plane)} {u : CorrectionState.State (Q × TorusInverse.Plane)} {b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)} {G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)} {j : ℤ} {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} {h : p.NativeControl s c u b G A j W α κ} (d : NativeDynamics h) (n : ℕ) : CopyAngularInvariance.Invariant p.directions.angular ((p.copyData c u b G A j).globalGood (nativeStrip s) p.directions n)

theorem NavierStokes.CorrectionStep.ParticularParameters.NativeDynamics.gaussian_invariant {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {p : ParticularParameters Q} {s : WeightedClasses.StripData (Q × TorusInverse.Plane)} {c : CorrectionState.Context (Q × TorusInverse.Plane)} {u : CorrectionState.State (Q × TorusInverse.Plane)} {b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)} {G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)} {j : ℤ} {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} {h : p.NativeControl s c u b G A j W α κ} (d : NativeDynamics h) (n : ℕ) : CopyAngularInvariance.Invariant p.directions.angular ((p.copyData c u b G A j).globalGaussian p.directions n)

theorem NavierStokes.CorrectionStep.ParticularParameters.NativeDynamics.section_equation {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {p : ParticularParameters Q} {s : WeightedClasses.StripData (Q × TorusInverse.Plane)} {c : CorrectionState.Context (Q × TorusInverse.Plane)} {u : CorrectionState.State (Q × TorusInverse.Plane)} {b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)} {G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)} {j : ℤ} {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} {h : p.NativeControl s c u b G A j W α κ} (d : NativeDynamics h) (hκ : κ ≤ 1 / 2) (n : ℕ) (x : (Q × TorusInverse.Plane) × ℝ) (hx : x.1 ∈ s.domain) (i : Fin 3) : (p.wave s c u b G A j).harmonicResidual (nativeStrip s) p.directions n (ParticularWaveAssembly.angleShuffle x) i + ParticularWaveAssembly.residualSource c u b G A j n x.1 i * HarmonicFields.character j (b.frequency n * b.phase n x.1 + ↑(b.angularFrequency n) * x.2) = ((p.copyData c u b G A j).globalGood (nativeStrip s) p.directions n (ParticularWaveAssembly.angleShuffle (x.1, 0)) i + (p.copyData c u b G A j).globalGaussian p.directions n (ParticularWaveAssembly.angleShuffle (x.1, 0)) i) * HarmonicFields.character j (b.frequency n * b.phase n x.1 + ↑(b.angularFrequency n) * x.2)

theorem NavierStokes.CorrectionStep.ParticularParameters.NativeDynamics.wave_smooth {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {p : ParticularParameters Q} {s : WeightedClasses.StripData (Q × TorusInverse.Plane)} {c : CorrectionState.Context (Q × TorusInverse.Plane)} {u : CorrectionState.State (Q × TorusInverse.Plane)} {b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)} {G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)} {j : ℤ} {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} {h : p.NativeControl s c u b G A j W α κ} (d : NativeDynamics h) (hκ : κ ≤ 1 / 2) (n : ℕ) (i : Fin 3) : ContDiffOn ℝ (↑⊤) (fun (x : (Q × TorusInverse.Plane) × ℝ) => HarmonicCalculus.vectorMode ((p.wave s c u b G A j).frequency n) ((p.wave s c u b G A j).phase n) ((p.wave s c u b G A j).amplitude n) (ParticularWaveAssembly.angleShuffle x) i) (HarmonicResidual.liftDomain s.domain)

theorem NavierStokes.CorrectionStep.ParticularParameters.NativeDynamics.pressure_smooth {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {p : ParticularParameters Q} {s : WeightedClasses.StripData (Q × TorusInverse.Plane)} {c : CorrectionState.Context (Q × TorusInverse.Plane)} {u : CorrectionState.State (Q × TorusInverse.Plane)} {b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)} {G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)} {j : ℤ} {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} {h : p.NativeControl s c u b G A j W α κ} (d : NativeDynamics h) (hκ : κ ≤ 1 / 2) (n : ℕ) : ContDiffOn ℝ (↑⊤) (fun (x : (Q × TorusInverse.Plane) × ℝ) => HarmonicCalculus.mode ((p.wave s c u b G A j).frequency n) ((p.wave s c u b G A j).phase n) ((p.wave s c u b G A j).pressure n) (ParticularWaveAssembly.angleShuffle x)) (HarmonicResidual.liftDomain s.domain)

theorem NavierStokes.CorrectionStep.ParticularParameters.angleStrip_nativeStrip {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] (s : WeightedClasses.StripData (Q × TorusInverse.Plane)) : ParticularWaveBounds.reindexStrip ParticularWaveAssembly.angleShuffle (nativeStrip s) = HarmonicWaveInteraction.productStrip s

theorem NavierStokes.CorrectionStep.ParticularParameters.frame_wave {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] (p : ParticularParameters Q) (s : WeightedClasses.StripData (Q × TorusInverse.Plane)) (c : CorrectionState.Context (Q × TorusInverse.Plane)) (u : CorrectionState.State (Q × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)) (j : ℤ) (hm : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) (ParticularWaveBounds.reindexDirections ParticularWaveAssembly.angleShuffle p.directions) (ParticularWaveBounds.reindexCoefficients ParticularWaveAssembly.angleShuffle p.background)) : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) (ParticularWaveBounds.reindexDirections ParticularWaveAssembly.angleShuffle p.directions) (ParticularWaveBounds.reindexCoefficients ParticularWaveAssembly.angleShuffle (p.wave s c u b G A j))

theorem NavierStokes.CorrectionStep.ParticularParameters.native_context_residual {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] (p : ParticularParameters Q) (s : WeightedClasses.StripData (Q × TorusInverse.Plane)) (c : CorrectionState.Context (Q × TorusInverse.Plane)) (u : CorrectionState.State (Q × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)) (j : ℤ) (hm : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) (ParticularWaveBounds.reindexDirections ParticularWaveAssembly.angleShuffle p.directions) (ParticularWaveBounds.reindexCoefficients ParticularWaveAssembly.angleShuffle p.background)) (n : ℕ) (x : (Q × TorusInverse.Plane) × ℝ) : (p.wave s c u b G A j).harmonicResidual (nativeStrip s) p.directions n (ParticularWaveAssembly.angleShuffle x) = LinearWaveResidual.linearResidual (c.operators.epsilon n) (fun (y : (Q × TorusInverse.Plane) × ℝ) => c.operators.radius y.1) (radialDirection c n) angularDirection (axialDirection c n) (timeDirection c n) (complexBase c n) (fun (y : (Q × TorusInverse.Plane) × ℝ) => HarmonicCalculus.vectorMode ((p.wave s c u b G A j).frequency n) ((p.wave s c u b G A j).phase n) ((p.wave s c u b G A j).amplitude n) (ParticularWaveAssembly.angleShuffle y)) (fun (y : (Q × TorusInverse.Plane) × ℝ) => HarmonicCalculus.mode ((p.wave s c u b G A j).frequency n) ((p.wave s c u b G A j).phase n) ((p.wave s c u b G A j).pressure n) (ParticularWaveAssembly.angleShuffle y)) x

theorem NavierStokes.CorrectionStep.ParticularParameters.update_represents {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} (p : ParticularParameters Q) (s : WeightedClasses.StripData (Q × TorusInverse.Plane)) (c : CorrectionState.Context (Q × TorusInverse.Plane)) (u : CorrectionState.State (Q × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)) (N : ℕ) (C : (j : ℤ) → j ∈ ParticularWaveAssembly.modes N → p.NativeControl s c u b G A j W α κ) (dyn : ∀ (j : ℤ) (hj : j ∈ ParticularWaveAssembly.modes N), NativeDynamics (C j hj)) : ((p.updateBlock s c u b G A N).oscillation = fun (n : ℕ) (x : (Q × TorusInverse.Plane) × ℝ) (i : Fin 3) => ∑ j ∈ ParticularWaveAssembly.modes N, (HarmonicCalculus.vectorMode ((p.wave s c u b G A j).frequency n) ((p.wave s c u b G A j).phase n) ((p.wave s c u b G A j).amplitude n) (ParticularWaveAssembly.angleShuffle x) i).re) ∧ (p.updateBlock s c u b G A N).oscillatoryPressure = fun (n : ℕ) (x : (Q × TorusInverse.Plane) × ℝ) => ∑ j ∈ ParticularWaveAssembly.modes N, (HarmonicCalculus.mode ((p.wave s c u b G A j).frequency n) ((p.wave s c u b G A j).phase n) ((p.wave s c u b G A j).pressure n) (ParticularWaveAssembly.angleShuffle x)).re

theorem NavierStokes.CorrectionStep.ParticularParameters.cancellation_sum {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} (p : ParticularParameters Q) (s : WeightedClasses.StripData (Q × TorusInverse.Plane)) (c : CorrectionState.Context (Q × TorusInverse.Plane)) (u : CorrectionState.State (Q × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)) (N : ℕ) (C : (j : ℤ) → j ∈ ParticularWaveAssembly.modes N → p.NativeControl s c u b G A j W α κ) (dyn : ∀ (j : ℤ) (hj : j ∈ ParticularWaveAssembly.modes N), NativeDynamics (C j hj)) (hκ : κ ≤ 1 / 2) (hN : (HarmonicResidual.residualBlock c u b G A).BandLimited N) (n : ℕ) (x : (Q × TorusInverse.Plane) × ℝ) (hx : x.1 ∈ s.domain) : (fun (i : Fin 3) => ∑ j ∈ ParticularWaveAssembly.modes N, ((p.wave s c u b G A j).harmonicResidual (nativeStrip s) p.directions n (ParticularWaveAssembly.angleShuffle x) i).re) + (HarmonicResidual.residualBlock c u b G A).oscillation n x = (p.goodBlock s c u b G A N).oscillation n x + (p.gaussianBlock c u b G A N).oscillation n x

theorem NavierStokes.CorrectionStep.ParticularParameters.context_linear_sum {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} (p : ParticularParameters Q) (s : WeightedClasses.StripData (Q × TorusInverse.Plane)) (c : CorrectionState.Context (Q × TorusInverse.Plane)) (u : CorrectionState.State (Q × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)) (N : ℕ) (C : (j : ℤ) → j ∈ ParticularWaveAssembly.modes N → p.NativeControl s c u b G A j W α κ) (dyn : ∀ (j : ℤ) (hj : j ∈ ParticularWaveAssembly.modes N), NativeDynamics (C j hj)) (hκ : κ ≤ 1 / 2) (hB : MeanIncrementBounds.SmoothTriple s.domain c.base) (hrad : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (HarmonicResidual.contextFrame c n).radial s.domain) (hm : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) (ParticularWaveBounds.reindexDirections ParticularWaveAssembly.angleShuffle p.directions) (ParticularWaveBounds.reindexCoefficients ParticularWaveAssembly.angleShuffle p.background)) (n : ℕ) (x : (Q × TorusInverse.Plane) × ℝ) (hx : x.1 ∈ s.domain) : linearBlockField c b (p.updateBlock s c u b G A N) n x = fun (i : Fin 3) => ∑ j ∈ ParticularWaveAssembly.modes N, ((p.wave s c u b G A j).harmonicResidual (nativeStrip s) p.directions n (ParticularWaveAssembly.angleShuffle x) i).re

theorem NavierStokes.CorrectionStep.ParticularParameters.context_linear_cancellation {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} (p : ParticularParameters Q) (s : WeightedClasses.StripData (Q × TorusInverse.Plane)) (c : CorrectionState.Context (Q × TorusInverse.Plane)) (u : CorrectionState.State (Q × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)) (N : ℕ) (C : (j : ℤ) → j ∈ ParticularWaveAssembly.modes N → p.NativeControl s c u b G A j W α κ) (dyn : ∀ (j : ℤ) (hj : j ∈ ParticularWaveAssembly.modes N), NativeDynamics (C j hj)) (hκ : κ ≤ 1 / 2) (hN : (HarmonicResidual.residualBlock c u b G A).BandLimited N) (hB : MeanIncrementBounds.SmoothTriple s.domain c.base) (hrad : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (HarmonicResidual.contextFrame c n).radial s.domain) (hm : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) (ParticularWaveBounds.reindexDirections ParticularWaveAssembly.angleShuffle p.directions) (ParticularWaveBounds.reindexCoefficients ParticularWaveAssembly.angleShuffle p.background)) (n : ℕ) (x : (Q × TorusInverse.Plane) × ℝ) (hx : x.1 ∈ s.domain) : linearBlockField c b (p.updateBlock s c u b G A N) n x + (HarmonicResidual.residualBlock c u b G A).oscillation n x = (p.goodBlock s c u b G A N).oscillation n x + (p.gaussianBlock c u b G A N).oscillation n x

theorem NavierStokes.CorrectionStep.ParticularParameters.linearGood_bounds {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} (p : ParticularParameters Q) (s : WeightedClasses.StripData (Q × TorusInverse.Plane)) (c : CorrectionState.Context (Q × TorusInverse.Plane)) (u : CorrectionState.State (Q × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)) (N : ℕ) (C : (j : ℤ) → j ∈ ParticularWaveAssembly.modes N → p.NativeControl s c u b G A j W α κ) (dyn : ∀ (j : ℤ) (hj : j ∈ ParticularWaveAssembly.modes N), NativeDynamics (C j hj)) (hκ : κ ≤ 1 / 2) (hN : (HarmonicResidual.residualBlock c u b G A).BandLimited N) (hB : MeanIncrementBounds.SmoothTriple s.domain c.base) (hrad : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (HarmonicResidual.contextFrame c n).radial s.domain) (hm : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) (ParticularWaveBounds.reindexDirections ParticularWaveAssembly.angleShuffle p.directions) (ParticularWaveBounds.reindexCoefficients ParticularWaveAssembly.angleShuffle p.background)) (hphase : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (b.phase n) s.domain) (hkp : ∀ (n : ℕ), b.angularFrequency n ≠ 0) (hW : ∀ (n : ℕ), ∀ x ∈ (nativeStrip s).domain, 0 ≤ W n x) (i : Fin 3) (j : ℤ) : j ≠ 0 → WeightedClasses.WaveClass s (fun (n : ℕ) (x : Q × TorusInverse.Plane) => W n (ParticularWaveAssembly.angleShuffle (x, 0))) (α + 1 / 2 - 3 * κ) fun (n : ℕ) (x : Q × TorusInverse.Plane) => ((HarmonicResidual.residualBlock c u b G A).velocity n i).coeff j x + ((HarmonicWaveInteraction.linearGoodBlock c b (p.updateBlock s c u b G A N) (p.gaussianBlock c u b G A N).velocity).velocity n i).coeff j x

The current residual is cancelled by the actual finite inverse. The remaining coefficient is precisely the computed retained-good block.

theorem NavierStokes.CorrectionStep.waveStage_residual_mem_local {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {C : ℕ → Set D} {P : ℕ → D → ℝ} {κ α β H γ : ℝ} (c : CorrectionState.Context D) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hκ : κ ≤ 1 / 2) (hR : ∀ x ∈ s.domain, 0 < c.operators.radius x) (u v : CorrectionState.State D) (hmean : v.mean = u.mean) (hm : MeanIncrementBounds.IncrementBounds s H u.mean) (hbase : MeanIncrementBounds.SmoothTriple s.domain c.base) (a b : CorrectionState.HarmonicBlock D) {M N : ℕ} (ha : CorrectionState.HarmonicBlock.WaveBounds s P α a) (hb : CorrectionState.HarmonicBlock.WaveBounds s P β b) (ha0 : HarmonicWaveInteraction.ZeroMode a) (hb0 : HarmonicWaveInteraction.ZeroMode b) (hM : a.BandLimited M) (hN : b.BandLimited N) (hΦ : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (a.phase n) s.domain) (hk : ∀ (n : ℕ), a.frequency n ≠ 0) (hkp : ∀ (n : ℕ), a.angularFrequency n ≠ 0) (hda : HarmonicWaveInteraction.ModeSolenoidal s c a) (hdb : HarmonicWaveInteraction.ModeSolenoidal s c (HarmonicWaveInteraction.withCarrier a b)) (hNormal : ∀ (i : Fin 3), LocalizedWaveBounds.LocalUnweighted s (fun (n : ℕ) (x : Unit) => C n) 0 fun (n : ℕ) (x : Unit) (x_1 : D) => (HarmonicMeanInteraction.slowNormal c ho hR a.phase n x_1).ofLp i) (hFreq : WeightedClasses.BandBound s (-(1 / 2)) a.frequency) (hAng : WeightedClasses.BandBound s (-(1 / 2)) fun (n : ℕ) => ↑(a.angularFrequency n)) (hz : ∀ (n : ℕ), ∀ x ∈ s.domain, x ∉ C n → ∀ (i : Fin 3) (j : ℤ), j ≠ 0 → (b.velocity n i).coeff j =ᶠ[nhds x] fun (x : D) => 0) (hP0 : ∀ (n : ℕ), ∀ x ∈ s.domain, 0 ≤ P n x) (hP1 : ∀ (n : ℕ), ∀ x ∈ s.domain, P n x ≤ 1) (hpa : ∀ (n : ℕ), HarmonicResidual.SmoothCoefficients s.domain (a.pressure n)) (hpb : ∀ (n : ℕ), HarmonicResidual.SmoothCoefficients s.domain (b.pressure n)) (G g A₀ A₁ : HarmonicResidual.BlockCoefficients D) (hA : ∀ (n : ℕ) (i : Fin 3), HarmonicFields.BandLimited (A₁ n i - A₀ n i) 0) (hlinear : ∀ (i : Fin 3) (j : ℤ), j ≠ 0 → WeightedClasses.WaveClass s P γ fun (n : ℕ) (x : D) => ((HarmonicResidual.residualBlock c u a G A₀).velocity n i).coeff j x + ((HarmonicWaveInteraction.linearGoodBlock c a b g).velocity n i).coeff j x) (hγm : γ ≤ β + H - 1 / 2) (hγc : γ ≤ α + β - κ) (hγs : γ ≤ β + β - κ) : CorrectionState.HarmonicBlock.WaveBounds s P γ (HarmonicResidual.residualBlock c v (HarmonicWaveInteraction.addBlock a b) (G + g) A₁)

@[reducible, inline]

abbrev NavierStokes.CorrectionStep.AxisymmetricAlias : Type

Axisymmetric alias: an abbreviation for ℕ → CyclePoint → Fin 3 → ℝ.

Equations

• NavierStokes.CorrectionStep.AxisymmetricAlias = (ℕ → NavierStokes.CorrectionStep.CyclePoint → Fin 3 → ℝ)

noncomputable def NavierStokes.CorrectionStep.coefficientField (b : CorrectionState.HarmonicBlock CyclePoint) (a : HarmonicResidual.BlockCoefficients CyclePoint) : CorrectionState.Oscillation CyclePoint

Coefficient field, defined pointwise by (HarmonicFields.field (a n i) (b.frequency n) (b.phase n) (b.angularFrequency n) x).re.

Equations

• NavierStokes.CorrectionStep.coefficientField b a n x i = (NavierStokes.HarmonicFields.field (a n i) (b.frequency n) (b.phase n) (b.angularFrequency n) x).re

structure NavierStokes.CorrectionStep.CycleRepresentation {ι : Type} (v : CycleCoefficients ι) (u : CorrectionState.State CyclePoint) (axis : AxisymmetricAlias) : Prop

The axisymmetric alias is kept separately from the spatial labels. No slot support is imposed on a zero angular mode.

• velocity (n : ℕ) (x : CyclePoint × ℝ) (i : Fin 3) : u.oscillation n x i = ∑ l ∈ v.labels n, (v.blocks l).oscillation n x i
• pressure (n : ℕ) (x : CyclePoint × ℝ) : u.oscillatoryPressure n x = ∑ l ∈ v.labels n, (v.blocks l).oscillatoryPressure n x
• gaussian (n : ℕ) (x : CyclePoint × ℝ) (i : Fin 3) : u.errors.gaussian n x i = ∑ l ∈ v.labels n, coefficientField (v.blocks l) (v.gaussian l) n x i
• aliasError (n : ℕ) (x : CyclePoint × ℝ) (i : Fin 3) : u.errors.aliasError n x i = ∑ l ∈ v.labels n, coefficientField (v.blocks l) (v.aliasCoefficients l) n x i + axis n x.1 i

structure NavierStokes.CorrectionStep.CoefficientBands {ι : Type} (v : CycleCoefficients ι) : Prop

A common integer bound for stored coefficient values, including errors.

• velocityPressure (l : ι) : (v.blocks l).BandLimited v.residualBand
• gaussian (l : ι) (n : ℕ) (i : Fin 3) : HarmonicFields.BandLimited (v.gaussian l n i) v.residualBand
• aliasError (l : ι) (n : ℕ) (i : Fin 3) : HarmonicFields.BandLimited (v.aliasCoefficients l n i) v.residualBand

theorem NavierStokes.CorrectionStep.CycleParameters.particular_carrier {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (l : ι) : SameCarrier (v.blocks l) (p.particularBlock v c u l)

theorem NavierStokes.CorrectionStep.CycleParameters.particularGaussian_carrier {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (l : ι) : SameCarrier (v.blocks l) (p.particularGaussianBlock v c u l)

noncomputable def NavierStokes.CorrectionStep.CycleParameters.nextCoefficients {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : CycleCoefficients ι

The new nonzero harmonic data are literal sums of the old and constructed coefficients. All new mean aliases remain in the separate field.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.CycleParameters.nextAxisymmetricAlias {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (axis : AxisymmetricAlias) : AxisymmetricAlias

Next axisymmetric alias as an element of AxisymmetricAlias.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.CycleParameters.finalBlock_oscillation {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (hc : ∀ (l : ι), SameCarrier (v.blocks l) (p.signedBlock v c u l)) (l : ι) : (p.finalBlock v c u l).oscillation = (v.blocks l).oscillation + (p.particularBlock v c u l).oscillation + (p.signedBlock v c u l).oscillation

theorem NavierStokes.CorrectionStep.CycleParameters.finalBlock_pressure {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (hc : ∀ (l : ι), SameCarrier (v.blocks l) (p.signedBlock v c u l)) (l : ι) : (p.finalBlock v c u l).oscillatoryPressure = (v.blocks l).oscillatoryPressure + (p.particularBlock v c u l).oscillatoryPressure + (p.signedBlock v c u l).oscillatoryPressure

theorem NavierStokes.CorrectionStep.CycleParameters.nextCoefficients_gaussian_field {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (hc : ∀ (l : ι), SameCarrier (v.blocks l) (p.signedBlock v c u l)) (l : ι) (n : ℕ) (x : CyclePoint × ℝ) (i : Fin 3) : coefficientField ((p.nextCoefficients v c u).blocks l) ((p.nextCoefficients v c u).gaussian l) n x i = coefficientField (v.blocks l) (v.gaussian l) n x i + (p.particularGaussianBlock v c u l).oscillation n x i + (p.signedGaussianBlock v c u l).oscillation n x i

theorem NavierStokes.CorrectionStep.CycleParameters.next_representation {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) {axis : AxisymmetricAlias} (hrep : CycleRepresentation v u axis) (hc : ∀ (l : ι), SameCarrier (v.blocks l) (p.signedBlock v c u l)) : CycleRepresentation (p.nextCoefficients v c u) (p.next v c u) (p.nextAxisymmetricAlias v c u axis)

theorem NavierStokes.CorrectionStep.CycleParameters.next_coefficient_bands {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (h : CoefficientBands v) : CoefficientBands (p.nextCoefficients v c u)

theorem NavierStokes.CorrectionStep.CycleParameters.next_residual_band {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (h : CoefficientBands v) (l : ι) : (HarmonicResidual.residualBlock c (p.next v c u) ((p.nextCoefficients v c u).blocks l) ((p.nextCoefficients v c u).gaussian l) ((p.nextCoefficients v c u).aliasCoefficients l)).BandLimited (p.nextCoefficients v c u).residualBand

The residual value bound of the next actual state is derived from stored coefficient bands, independently of a norm estimate.

structure NavierStokes.CorrectionStep.CycleState (ι : Type) : Type

The represented state and its literal coefficient data evolve together.

• state : CorrectionState.State CyclePoint

  State of CycleState, of type State CyclePoint.

• coefficients : CycleCoefficients ι

  Coefficients of CycleState, of type CycleCoefficients ι.

• axisymmetricAlias : AxisymmetricAlias

  Axisymmetric alias of CycleState, of type AxisymmetricAlias.

noncomputable def NavierStokes.CorrectionStep.CycleState.step {ι : Type} (p : CycleParameters ι) (c : CorrectionState.Context CyclePoint) (u : CycleState ι) : CycleState ι

Step, bundling state, coefficients, axisymmetricAlias.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.CycleState.iterate {ι : Type} (p : ℕ → CycleParameters ι) (c : CorrectionState.Context CyclePoint) (seed : CycleState ι) : ℕ → CycleState ι

Iterate as an element of ℕ → CycleState ι | 0 => seed | n + 1 => (iterate p c seed n).step (p n) c.

Equations

• NavierStokes.CorrectionStep.CycleState.iterate p c seed 0 = seed
• NavierStokes.CorrectionStep.CycleState.iterate p c seed n.succ = NavierStokes.CorrectionStep.CycleState.step (p n) c (NavierStokes.CorrectionStep.CycleState.iterate p c seed n)

theorem NavierStokes.CorrectionStep.CycleState.iterate_zero {ι : Type} (p : ℕ → CycleParameters ι) (c : CorrectionState.Context CyclePoint) (seed : CycleState ι) : iterate p c seed 0 = seed

theorem NavierStokes.CorrectionStep.CycleState.iterate_succ {ι : Type} (p : ℕ → CycleParameters ι) (c : CorrectionState.Context CyclePoint) (seed : CycleState ι) (n : ℕ) : iterate p c seed (n + 1) = step (p n) c (iterate p c seed n)

theorem NavierStokes.CorrectionStep.CycleState.iterate_representation {ι : Type} (p : ℕ → CycleParameters ι) (c : CorrectionState.Context CyclePoint) (seed : CycleState ι) (hseed : CycleRepresentation seed.coefficients seed.state seed.axisymmetricAlias) (hc : ∀ (n : ℕ) (l : ι), have v := iterate p c seed n; SameCarrier (v.coefficients.blocks l) ((p n).signedBlock v.coefficients c v.state l)) (n : ℕ) : have v := iterate p c seed n; CycleRepresentation v.coefficients v.state v.axisymmetricAlias

theorem NavierStokes.CorrectionStep.CycleState.iterate_bands {ι : Type} (p : ℕ → CycleParameters ι) (c : CorrectionState.Context CyclePoint) (seed : CycleState ι) (hseed : CoefficientBands seed.coefficients) (n : ℕ) : CoefficientBands (iterate p c seed n).coefficients

theorem NavierStokes.CorrectionStep.CycleState.iterate_residual_band {ι : Type} (p : ℕ → CycleParameters ι) (c : CorrectionState.Context CyclePoint) (seed : CycleState ι) (hseed : CoefficientBands seed.coefficients) (n : ℕ) (l : ι) : have v := iterate p c seed (n + 1); (HarmonicResidual.residualBlock c v.state (v.coefficients.blocks l) (v.coefficients.gaussian l) (v.coefficients.aliasCoefficients l)).BandLimited v.coefficients.residualBand

theorem NavierStokes.CorrectionStep.cylindricalDivergence_reindex {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E] (e : D ≃ₗᵢ[ℝ] E) (R : E → ℝ) (Vr Vθ Vz : E → E) (a : E → HarmonicCalculus.ComplexVector) (x : D) : HarmonicCalculus.cylindricalDivergence (fun (y : D) => R (e y)) (StateReindex.vector e Vr) (StateReindex.vector e Vθ) (StateReindex.vector e Vz) (fun (y : D) => a (e y)) x = HarmonicCalculus.cylindricalDivergence R Vr Vθ Vz a (e x)

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeControl.amplitude_cover {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ : ℝ} (h : p.NativeControl s P κ) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) (n : ℕ) (i : I) (x : D × ℝ) (hx : x ∈ (HarmonicWaveInteraction.productStrip s).domain) (hi : x ∈ h.cells.carrier n i) : x ∈ h.phasePatch n i ∨ ((p.copyData s request).localized i).amplitude n =ᶠ[nhds x] fun (x : D × ℝ) => 0

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeDynamics.rawCurlData {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ β : ℝ} {h : p.NativeControl s P κ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (d : NativeDynamics h request) (hR : ∀ (j : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) β fun (n : ℕ) (x : D × ℝ) => request n x j) (G : ∀ (n : ℕ), CurlClassBounds.CylindricalGeometry (HarmonicWaveInteraction.productStrip s).domain (p.base.radius n) (p.directions.radialField n) (fun (x : D × ℝ) => p.directions.angular) (p.directions.axialField (HarmonicWaveInteraction.productStrip s) n)) (ht : ∀ (n : ℕ) (i : I), ∀ x ∈ (HarmonicWaveInteraction.productStrip s).domain, x ∈ h.phasePatch n i → inner ℝ (p.base.normal (HarmonicWaveInteraction.productStrip s) p.directions n x) (p.fundamental i n x) = 0) : LocalizedCurlRealization.RawData (p.copyData s request) (HarmonicWaveInteraction.productStrip s) p.directions h.phasePatch

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeDynamics.full_divergence_zero {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ β : ℝ} {h : p.NativeControl s P κ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (d : NativeDynamics h request) (i₀ : I) (hR : ∀ (j : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) β fun (n : ℕ) (x : D × ℝ) => request n x j) (G : ∀ (n : ℕ), CurlClassBounds.CylindricalGeometry (HarmonicWaveInteraction.productStrip s).domain (p.base.radius n) (p.directions.radialField n) (fun (x : D × ℝ) => p.directions.angular) (p.directions.axialField (HarmonicWaveInteraction.productStrip s) n)) (ht : ∀ (n : ℕ) (i : I), ∀ x ∈ (HarmonicWaveInteraction.productStrip s).domain, x ∈ h.phasePatch n i → inner ℝ (p.base.normal (HarmonicWaveInteraction.productStrip s) p.directions n x) (p.fundamental i n x) = 0) (hkp : ∀ (n : ℕ), p.base.frequency n * d.slope n = ↑(p.angularFrequency n)) (c : CorrectionState.Context D) (hm : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) p.directions p.base) (n : ℕ) (x : D × ℝ) (hx : x.1 ∈ s.domain) : HarmonicCalculus.cylindricalDivergence (fun (q : D × ℝ) => c.operators.radius q.1) (radialDirection c n) angularDirection (axialDirection c n) (fun (q : D × ℝ) (i : Fin 3) => ↑((p.exactBlock s request).oscillation n q i)) x = 0

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeDynamics.modeSolenoidal {D I : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {κ β : ℝ} {h : p.NativeControl s P κ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (d : NativeDynamics h request) (i₀ : I) (hκ : κ ≤ 1 / 2) (hR : ∀ (j : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) β fun (n : ℕ) (x : D × ℝ) => request n x j) (G : ∀ (n : ℕ), CurlClassBounds.CylindricalGeometry (HarmonicWaveInteraction.productStrip s).domain (p.base.radius n) (p.directions.radialField n) (fun (x : D × ℝ) => p.directions.angular) (p.directions.axialField (HarmonicWaveInteraction.productStrip s) n)) (ht : ∀ (n : ℕ) (i : I), ∀ x ∈ (HarmonicWaveInteraction.productStrip s).domain, x ∈ h.phasePatch n i → inner ℝ (p.base.normal (HarmonicWaveInteraction.productStrip s) p.directions n x) (p.fundamental i n x) = 0) (hkp : ∀ (n : ℕ), p.base.frequency n * d.slope n = ↑(p.angularFrequency n)) (hkpne : ∀ (n : ℕ), p.angularFrequency n ≠ 0) (c : CorrectionState.Context D) (hm : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) p.directions p.base) : HarmonicWaveInteraction.ModeSolenoidal s c (p.exactBlock s request)

theorem NavierStokes.CorrectionStep.ParticularParameters.NativeControl.amplitude_cover {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {p : ParticularParameters Q} {s : WeightedClasses.StripData (Q × TorusInverse.Plane)} {c : CorrectionState.Context (Q × TorusInverse.Plane)} {u : CorrectionState.State (Q × TorusInverse.Plane)} {b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)} {G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)} {j : ℤ} {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} (h : p.NativeControl s c u b G A j W α κ) (n : ℕ) (i : TorusInverse.Frequency) (x : (Q × ℝ) × TorusInverse.Plane) (hx : x ∈ (nativeStrip s).domain) (hi : x ∈ h.cells.carrier n i) : x ∈ h.phasePatch n i ∨ ((p.copyData c u b G A j).localized i).amplitude n =ᶠ[nhds x] fun (x : (Q × ℝ) × TorusInverse.Plane) => 0

theorem NavierStokes.CorrectionStep.ParticularParameters.NativeDynamics.rawCurlData {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {p : ParticularParameters Q} {s : WeightedClasses.StripData (Q × TorusInverse.Plane)} {c : CorrectionState.Context (Q × TorusInverse.Plane)} {u : CorrectionState.State (Q × TorusInverse.Plane)} {b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)} {G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)} {j : ℤ} {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} {h : p.NativeControl s c u b G A j W α κ} (d : NativeDynamics h) : LocalizedCurlRealization.RawData (p.copyData c u b G A j) (nativeStrip s) p.directions h.phasePatch

theorem NavierStokes.CorrectionStep.ParticularParameters.NativeDynamics.common_divergence_zero {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {p : ParticularParameters Q} {s : WeightedClasses.StripData (Q × TorusInverse.Plane)} {c : CorrectionState.Context (Q × TorusInverse.Plane)} {u : CorrectionState.State (Q × TorusInverse.Plane)} {b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)} {G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)} {j : ℤ} {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} {h : p.NativeControl s c u b G A j W α κ} (d : NativeDynamics h) (n : ℕ) {x : (Q × ℝ) × TorusInverse.Plane} (hx : x ∈ (nativeStrip s).domain) : HarmonicCalculus.cylindricalDivergence (p.background.radius n) (p.directions.radialField n) (fun (x : (Q × ℝ) × TorusInverse.Plane) => p.directions.angular) (p.directions.axialField (nativeStrip s) n) (HarmonicCalculus.vectorMode ((p.wave s c u b G A j).frequency n) ((p.wave s c u b G A j).phase n) ((p.wave s c u b G A j).amplitude n)) x = 0

theorem NavierStokes.CorrectionStep.ParticularParameters.native_context_divergence {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] (p : ParticularParameters Q) (s : WeightedClasses.StripData (Q × TorusInverse.Plane)) (c : CorrectionState.Context (Q × TorusInverse.Plane)) (hm : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) (ParticularWaveBounds.reindexDirections ParticularWaveAssembly.angleShuffle p.directions) (ParticularWaveBounds.reindexCoefficients ParticularWaveAssembly.angleShuffle p.background)) (a : (Q × ℝ) × TorusInverse.Plane → HarmonicCalculus.ComplexVector) (n : ℕ) (x : (Q × TorusInverse.Plane) × ℝ) : HarmonicCalculus.cylindricalDivergence (fun (y : (Q × TorusInverse.Plane) × ℝ) => c.operators.radius y.1) (radialDirection c n) angularDirection (axialDirection c n) (fun (y : (Q × TorusInverse.Plane) × ℝ) => a (ParticularWaveAssembly.angleShuffle y)) x = HarmonicCalculus.cylindricalDivergence (p.background.radius n) (p.directions.radialField n) (fun (x : (Q × ℝ) × TorusInverse.Plane) => p.directions.angular) (p.directions.axialField (nativeStrip s) n) a (ParticularWaveAssembly.angleShuffle x)

theorem NavierStokes.CorrectionStep.ParticularParameters.full_divergence_zero {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} (p : ParticularParameters Q) (s : WeightedClasses.StripData (Q × TorusInverse.Plane)) (c : CorrectionState.Context (Q × TorusInverse.Plane)) (u : CorrectionState.State (Q × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)) (N : ℕ) (C : (j : ℤ) → j ∈ ParticularWaveAssembly.modes N → p.NativeControl s c u b G A j W α κ) (dyn : ∀ (j : ℤ) (hj : j ∈ ParticularWaveAssembly.modes N), NativeDynamics (C j hj)) (hκ : κ ≤ 1 / 2) (hm : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) (ParticularWaveBounds.reindexDirections ParticularWaveAssembly.angleShuffle p.directions) (ParticularWaveBounds.reindexCoefficients ParticularWaveAssembly.angleShuffle p.background)) (n : ℕ) (x : (Q × TorusInverse.Plane) × ℝ) (hx : x.1 ∈ s.domain) : HarmonicCalculus.cylindricalDivergence (fun (y : (Q × TorusInverse.Plane) × ℝ) => c.operators.radius y.1) (radialDirection c n) angularDirection (axialDirection c n) (fun (y : (Q × TorusInverse.Plane) × ℝ) (i : Fin 3) => ↑((p.updateBlock s c u b G A N).oscillation n y i)) x = 0

theorem NavierStokes.CorrectionStep.ParticularParameters.modeSolenoidal {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} (p : ParticularParameters Q) (s : WeightedClasses.StripData (Q × TorusInverse.Plane)) (c : CorrectionState.Context (Q × TorusInverse.Plane)) (u : CorrectionState.State (Q × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)) (N : ℕ) (C : (j : ℤ) → j ∈ ParticularWaveAssembly.modes N → p.NativeControl s c u b G A j W α κ) (dyn : ∀ (j : ℤ) (hj : j ∈ ParticularWaveAssembly.modes N), NativeDynamics (C j hj)) (hκ : κ ≤ 1 / 2) (hW : ∀ (n : ℕ), ∀ x ∈ (nativeStrip s).domain, 0 ≤ W n x) (hm : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) (ParticularWaveBounds.reindexDirections ParticularWaveAssembly.angleShuffle p.directions) (ParticularWaveBounds.reindexCoefficients ParticularWaveAssembly.angleShuffle p.background)) (hphase : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (b.phase n) s.domain) (hkp : ∀ (n : ℕ), b.angularFrequency n ≠ 0) : HarmonicWaveInteraction.ModeSolenoidal s c (p.updateBlock s c u b G A N)

theorem NavierStokes.CorrectionStep.linearGoodBlock_cancel_uniform {D ι : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {P : ι → ℕ → D → ℝ} {γ : ℝ} (c : CorrectionState.Context D) (a b source good : ι → CorrectionState.HarmonicBlock D) (g : ι → HarmonicResidual.BlockCoefficients D) (hr : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (HarmonicResidual.contextFrame c n).radial s.domain) (hz : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (HarmonicResidual.contextFrame c n).axial s.domain) (hB : MeanIncrementBounds.SmoothTriple s.domain c.base) (hb : ∀ (l : ι) (n : ℕ) (i : Fin 3), HarmonicResidual.SmoothCoefficients s.domain ((b l).velocity n i)) (hp : ∀ (l : ι) (n : ℕ), HarmonicResidual.SmoothCoefficients s.domain ((b l).pressure n)) (hΦ : ∀ (l : ι) (n : ℕ), ContDiffOn ℝ (↑⊤) ((a l).phase n) s.domain) (hkp : ∀ (l : ι) (n : ℕ), (a l).angularFrequency n ≠ 0) (hs : ∀ (l : ι) (n : ℕ) (i : Fin 3), HarmonicFields.ConjugateSymmetric ((source l).velocity n i)) (hg : ∀ (l : ι) (n : ℕ) (i : Fin 3), HarmonicFields.ConjugateSymmetric ((good l).velocity n i)) (hgood : UniformHarmonicInteraction.UniformVelocity s P γ good) (hcancel : ∀ (l : ι) (n : ℕ), ∀ x ∈ s.domain, ∀ (θ : ℝ) (i : Fin 3), linearBlockField c (a l) (b l) n (x, θ) i + (HarmonicWaveInteraction.withCarrier (a l) (source l)).oscillation n (x, θ) i = (HarmonicWaveInteraction.withCarrier (a l) (good l)).oscillation n (x, θ) i + (HarmonicFields.field (g l n i) ((a l).frequency n) ((a l).phase n) ((a l).angularFrequency n) (x, θ)).re) (i : Fin 3) (j : ℤ) : j ≠ 0 → LabelSumBounds.UniformWaveClass s P γ fun (l : ι) (n : ℕ) (x : D) => ((source l).velocity n i).coeff j x + ((HarmonicWaveInteraction.linearGoodBlock c (a l) (b l) (g l)).velocity n i).coeff j x

Coefficient extraction preserves constants chosen before the spatial label. The identity concerns the actual linear field and retained Gaussian.

theorem NavierStokes.CorrectionStep.waveStage_residual_uniform {D ι : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {P : ι → ℕ → D → ℝ} {κ α β H γ : ℝ} {C : ℕ → ι → Set D} (c : CorrectionState.Context D) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hκ : κ ≤ 1 / 2) (hR : ∀ x ∈ s.domain, 0 < c.operators.radius x) (u v : CorrectionState.State D) (hmean : v.mean = u.mean) (hm : MeanIncrementBounds.IncrementBounds s H u.mean) (hbase : MeanIncrementBounds.SmoothTriple s.domain c.base) (a b : ι → CorrectionState.HarmonicBlock D) {M N : ℕ} (ha : UniformHarmonicInteraction.UniformVelocity s P α a) (hb : UniformHarmonicInteraction.UniformVelocity s P β b) (ha0 : ∀ (l : ι), HarmonicWaveInteraction.ZeroMode (a l)) (hb0 : ∀ (l : ι), HarmonicWaveInteraction.ZeroMode (b l)) (hM : ∀ (l : ι), (a l).BandLimited M) (hN : ∀ (l : ι), (b l).BandLimited N) (hΦ : ∀ (l : ι) (n : ℕ), ContDiffOn ℝ (↑⊤) ((a l).phase n) s.domain) (hk : ∀ (l : ι) (n : ℕ), (a l).frequency n ≠ 0) (hkp : ∀ (l : ι) (n : ℕ), (a l).angularFrequency n ≠ 0) (hda : ∀ (l : ι), HarmonicWaveInteraction.ModeSolenoidal s c (a l)) (hdb : ∀ (l : ι), HarmonicWaveInteraction.ModeSolenoidal s c (HarmonicWaveInteraction.withCarrier (a l) (b l))) (hNormal : ∀ (i : Fin 3), LocalizedWaveBounds.LocalUnweighted s C 0 fun (n : ℕ) (l : ι) (x : D) => (HarmonicMeanInteraction.slowNormal c ho hR (a l).phase n x).ofLp i) (hFreq : LocalizedWaveBounds.LocalUnweighted s C (-(1 / 2)) fun (n : ℕ) (l : ι) (x : D) => (a l).frequency n) (hAng : LocalizedWaveBounds.LocalUnweighted s C (-(1 / 2)) fun (n : ℕ) (l : ι) (x : D) => ↑((a l).angularFrequency n)) (hz : ∀ (n : ℕ) (l : ι), ∀ x ∈ s.domain, x ∉ C n l → ∀ (i : Fin 3) (j : ℤ), j ≠ 0 → ((b l).velocity n i).coeff j =ᶠ[nhds x] fun (x : D) => 0) (hP0 : ∀ (l : ι) (n : ℕ), ∀ x ∈ s.domain, 0 ≤ P l n x) (hP1 : ∀ (l : ι) (n : ℕ), ∀ x ∈ s.domain, P l n x ≤ 1) (hpa : ∀ (l : ι) (n : ℕ), HarmonicResidual.SmoothCoefficients s.domain ((a l).pressure n)) (hpb : ∀ (l : ι) (n : ℕ), HarmonicResidual.SmoothCoefficients s.domain ((b l).pressure n)) (G g A₀ A₁ : ι → HarmonicResidual.BlockCoefficients D) (hA : ∀ (l : ι) (n : ℕ) (i : Fin 3), HarmonicFields.BandLimited (A₁ l n i - A₀ l n i) 0) (hlinear : ∀ (i : Fin 3) (j : ℤ), j ≠ 0 → LabelSumBounds.UniformWaveClass s P γ fun (l : ι) (n : ℕ) (x : D) => ((HarmonicResidual.residualBlock c u (a l) (G l) (A₀ l)).velocity n i).coeff j x + ((HarmonicWaveInteraction.linearGoodBlock c (a l) (b l) (g l)).velocity n i).coeff j x) (hγm : γ ≤ β + H - 1 / 2) (hγc : γ ≤ α + β - κ) (hγs : γ ≤ 2 * β - κ) : UniformHarmonicInteraction.UniformVelocity s P γ fun (l : ι) => HarmonicResidual.residualBlock c v (HarmonicWaveInteraction.addBlock (a l) (b l)) (G l + g l) (A₁ l)

The exact nonlinear update preserves the joint label/band estimate. All three wave products and the support-local mean interaction are retained.

theorem NavierStokes.CorrectionStep.meanStage_residual_uniform {D ι : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {P : ι → ℕ → D → ℝ} {κ α H γ : ℝ} {C : ℕ → ι → Set D} (c : CorrectionState.Context D) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hκ : κ ≤ 1 / 2) (hR : ∀ x ∈ s.domain, 0 < c.operators.radius x) (u v : CorrectionState.State D) (h : MeanIncrementBounds.Triple D) (he : v.mean = MeanIncrementBounds.updated u.mean h) (hbase : MeanIncrementBounds.SmoothTriple s.domain c.base) (hm : MeanIncrementBounds.SmoothTriple s.domain u.mean) (hh : MeanIncrementBounds.IncrementBounds s H h) (b : ι → CorrectionState.HarmonicBlock D) (hb : UniformHarmonicInteraction.UniformVelocity s P α b) (hNormal : ∀ (i : Fin 3), LocalizedWaveBounds.LocalUnweighted s C 0 fun (n : ℕ) (l : ι) (x : D) => (HarmonicMeanInteraction.slowNormal c ho hR (b l).phase n x).ofLp i) (hFreq : LocalizedWaveBounds.LocalUnweighted s C (-(1 / 2)) fun (n : ℕ) (l : ι) (x : D) => (b l).frequency n) (hAng : LocalizedWaveBounds.LocalUnweighted s C (-(1 / 2)) fun (n : ℕ) (l : ι) (x : D) => ↑((b l).angularFrequency n)) (hz : ∀ (n : ℕ) (l : ι), ∀ x ∈ s.domain, x ∉ C n l → ∀ (i : Fin 3) (j : ℤ), j ≠ 0 → ((b l).velocity n i).coeff j =ᶠ[nhds x] fun (x : D) => 0) (G A₀ A₁ : ι → HarmonicResidual.BlockCoefficients D) (hA : ∀ (l : ι) (n : ℕ) (i : Fin 3), HarmonicFields.BandLimited (A₁ l n i - A₀ l n i) 0) (hold : UniformHarmonicInteraction.UniformVelocity s P γ fun (l : ι) => HarmonicResidual.residualBlock c u (b l) (G l) (A₀ l)) (hγ : γ ≤ α + H - 1 / 2) : UniformHarmonicInteraction.UniformVelocity s P γ fun (l : ι) => HarmonicResidual.residualBlock c v (b l) (G l) (A₁ l)

The unchanged oscillation retains a uniform residual estimate after an actual mean increment; pressure recomputation and axisymmetric aliases may change freely.

theorem NavierStokes.CorrectionStep.meanIncrement_of_cumulative {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {m : MeanIncrementBounds.Triple D} (h : MeanIncrementBounds.CumulativeBounds s m) : MeanIncrementBounds.IncrementBounds s (9 / 10) m

theorem NavierStokes.CorrectionStep.pressureBounds_smooth {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {α : ℝ} {b : CorrectionState.HarmonicBlock D} (h : CorrectionState.HarmonicBlock.PressureBounds s P α b) (hz : ∀ (n : ℕ), (b.pressure n).coeff 0 = 0) (n : ℕ) : HarmonicResidual.SmoothCoefficients s.domain (b.pressure n)

theorem NavierStokes.CorrectionStep.operator_radial_smooth {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {κ : ℝ} {c : CorrectionState.Context D} (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (n : ℕ) : ContDiffOn ℝ (↑⊤) (HarmonicResidual.contextFrame c n).radial s.domain

theorem NavierStokes.CorrectionStep.ParticularParameters.residual_gain_local {Q : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] (p : ParticularParameters Q) (s : WeightedClasses.StripData (Q × TorusInverse.Plane)) (c : CorrectionState.Context (Q × TorusInverse.Plane)) (u v : CorrectionState.State (Q × TorusInverse.Plane)) (hmean : v.mean = u.mean) (b : CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)) {W : ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} {M N : ℕ} (C : (j : ℤ) → j ∈ ParticularWaveAssembly.modes N → p.NativeControl s c u b G A j W α κ) (dyn : ∀ (j : ℤ) (hj : j ∈ ParticularWaveAssembly.modes N), NativeDynamics (C j hj)) (hα : 7 / 10 ≤ α) (hκ : κ ≤ 1 / 100000) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hR : ∀ x ∈ s.domain, 0 < c.operators.radius x) (hb : MeanIncrementBounds.BaseBounds s c.base) (hu : MeanIncrementBounds.CumulativeBounds s u.mean) (hW : ∀ (n : ℕ), ∀ x ∈ (nativeStrip s).domain, 0 ≤ W n x) (hWone : ∀ (n : ℕ), ∀ x ∈ s.domain, W n (ParticularWaveAssembly.angleShuffle (x, 0)) ≤ 1) (hm : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) (ParticularWaveBounds.reindexDirections ParticularWaveAssembly.angleShuffle p.directions) (ParticularWaveBounds.reindexCoefficients ParticularWaveAssembly.angleShuffle p.background)) (hold : CorrectionState.HarmonicBlock.WaveBounds s (fun (n : ℕ) (x : Q × TorusInverse.Plane) => W n (ParticularWaveAssembly.angleShuffle (x, 0))) (1 / 2) b) (hold0 : HarmonicWaveInteraction.ZeroMode b) (holdBand : b.BandLimited M) (hsourceBand : (HarmonicResidual.residualBlock c u b G A).BandLimited N) (hphase : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (b.phase n) s.domain) (hk : ∀ (n : ℕ), b.frequency n ≠ 0) (hkp : ∀ (n : ℕ), b.angularFrequency n ≠ 0) (hdiv : HarmonicWaveInteraction.ModeSolenoidal s c b) (hpress : ∀ (n : ℕ), HarmonicResidual.SmoothCoefficients s.domain (b.pressure n)) {patch : ℕ → Set (Q × TorusInverse.Plane)} (hNormal : ∀ (i : Fin 3), LocalizedWaveBounds.LocalUnweighted s (fun (n : ℕ) (x : Unit) => patch n) 0 fun (n : ℕ) (x : Unit) (x_1 : Q × TorusInverse.Plane) => (HarmonicMeanInteraction.slowNormal c ho hR b.phase n x_1).ofLp i) (hFreq : WeightedClasses.BandBound s (-(1 / 2)) b.frequency) (hAng : WeightedClasses.BandBound s (-(1 / 2)) fun (n : ℕ) => ↑(b.angularFrequency n)) (hz : ∀ (n : ℕ), ∀ x ∈ s.domain, x ∉ patch n → ∀ (i : Fin 3) (j : ℤ), j ≠ 0 → ((p.updateBlock s c u b G A N).velocity n i).coeff j =ᶠ[nhds x] fun (x : Q × TorusInverse.Plane) => 0) : CorrectionState.HarmonicBlock.WaveBounds s (fun (n : ℕ) (x : Q × TorusInverse.Plane) => W n (ParticularWaveAssembly.angleShuffle (x, 0))) (α + 1 / 10) (HarmonicResidual.residualBlock c v (HarmonicWaveInteraction.addBlock b (p.updateBlock s c u b G A N)) (G + (p.gaussianBlock c u b G A N).velocity) A)

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.NativeDynamics.residual_gain_local {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {I : Type} {p : PeriodizedSignedParameters D I} {s : WeightedClasses.StripData D} {P : ℕ → D → ℝ} {B κ : ℝ} {h : p.NativeControl s P κ} {request : ℕ → D × ℝ → SignedWaveUpdate.Vec2} (d : NativeDynamics h request) (i₀ : I) (hB : 7 / 10 ≤ B) (hκ : κ ≤ 1 / 100000) (hRquest : ∀ (j : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) (B - 1 / 2 - κ) fun (n : ℕ) (x : D × ℝ) => request n x j) (geom : ∀ (n : ℕ), CurlClassBounds.CylindricalGeometry (HarmonicWaveInteraction.productStrip s).domain (p.base.radius n) (p.directions.radialField n) (fun (x : D × ℝ) => p.directions.angular) (p.directions.axialField (HarmonicWaveInteraction.productStrip s) n)) (ht : ∀ (n : ℕ) (i : I), ∀ x ∈ (HarmonicWaveInteraction.productStrip s).domain, x ∈ h.phasePatch n i → inner ℝ (p.base.normal (HarmonicWaveInteraction.productStrip s) p.directions n x) (p.fundamental i n x) = 0) (hkp : ∀ (n : ℕ), p.base.frequency n * d.slope n = ↑(p.angularFrequency n)) (hkpne : ∀ (n : ℕ), p.angularFrequency n ≠ 0) (c : CorrectionState.Context D) (u v : CorrectionState.State D) (hmean : v.mean = u.mean) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hR : ∀ x ∈ s.domain, 0 < c.operators.radius x) (hbase : MeanIncrementBounds.BaseBounds s c.base) (hu : MeanIncrementBounds.CumulativeBounds s u.mean) (hm : WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) p.directions p.base) (a : CorrectionState.HarmonicBlock D) (hcarrier : SameCarrier a (p.exactBlock s request)) (ha : CorrectionState.HarmonicBlock.WaveBounds s P (1 / 2) a) (ha0 : HarmonicWaveInteraction.ZeroMode a) {M : ℕ} (hM : a.BandLimited M) (hphase : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (a.phase n) s.domain) (hk : ∀ (n : ℕ), a.frequency n ≠ 0) (hka : ∀ (n : ℕ), a.angularFrequency n ≠ 0) (hdiv : HarmonicWaveInteraction.ModeSolenoidal s c a) (hpress : ∀ (n : ℕ), HarmonicResidual.SmoothCoefficients s.domain (a.pressure n)) {patch : ℕ → Set D} (hNormal : ∀ (i : Fin 3), LocalizedWaveBounds.LocalUnweighted s (fun (n : ℕ) (x : Unit) => patch n) 0 fun (n : ℕ) (x : Unit) (x_1 : D) => (HarmonicMeanInteraction.slowNormal c ho hR a.phase n x_1).ofLp i) (hFreq : WeightedClasses.BandBound s (-(1 / 2)) a.frequency) (hAng : WeightedClasses.BandBound s (-(1 / 2)) fun (n : ℕ) => ↑(a.angularFrequency n)) (hz : ∀ (n : ℕ), ∀ x ∈ s.domain, x ∉ patch n → ∀ (i : Fin 3) (j : ℤ), j ≠ 0 → ((p.exactBlock s request).velocity n i).coeff j =ᶠ[nhds x] fun (x : D) => 0) (hP1 : ∀ (n : ℕ), ∀ x ∈ s.domain, P n x ≤ 1) (G A : HarmonicResidual.BlockCoefficients D) (hold : CorrectionState.HarmonicBlock.WaveBounds s P (B + 1 / 10) (HarmonicResidual.residualBlock c u a G A)) : CorrectionState.HarmonicBlock.WaveBounds s P (B + 1 / 10) (HarmonicResidual.residualBlock c v (HarmonicWaveInteraction.addBlock a (p.exactBlock s request)) (G + (p.gaussianBlock s request).velocity) A)

theorem NavierStokes.CorrectionStep.assembledCovarianceIncrement_mem {D ι : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {P : ι → ℕ → D → ℝ} {α β : ℝ} (hαβ : α ≤ β) {d h : ℝ} {vr vt : TorusInverse.Plane} {sys : PartitionedCovariance.SlotSystem d h vr vt} (labels : ℕ → Finset ι) (label : ℕ → ι → SlotColoring.Label) (hinj : ∀ (n : ℕ), Set.InjOn (label n) ↑(labels n)) (hlevel : ∀ (n : ℕ), ∀ l ∈ labels n, 1 ≤ (label n l).1) (χ : ℕ → D → LabelSumBounds.WindowPoint) (hχ : ∀ (n : ℕ), ContinuousOn (χ n) s.domain) (Y : ℕ → D → TorusInverse.Plane) (a b : ι → CorrectionState.HarmonicBlock D) (N : ℕ) (hNa : ∀ (l : ι), (a l).BandLimited N) (hNb : ∀ (l : ι), (b l).BandLimited N) (hcarrier : ∀ (l : ι), LabelSumBounds.SameCarrier (a l) (b l)) (ha : UniformHarmonicInteraction.UniformVelocity s P α a) (hb : UniformHarmonicInteraction.UniformVelocity s P β b) (ha0 : ∀ (l : ι), HarmonicWaveInteraction.ZeroMode (a l)) (hb0 : ∀ (l : ι), HarmonicWaveInteraction.ZeroMode (b l)) (hP0 : ∀ (l : ι) (n : ℕ), ∀ x ∈ s.domain, 0 ≤ P l n x) (hP1 : ∀ (l : ι) (n : ℕ), ∀ x ∈ s.domain, P l n x ≤ 1) (hkp : ∀ (l : ι) (n : ℕ), (a l).angularFrequency n ≠ 0) (hsu : LabelSumBounds.SupportedOscillations sys label χ Y s.domain fun (l : ι) => (a l).oscillation) (hsv : LabelSumBounds.SupportedOscillations sys label χ Y s.domain fun (l : ι) => (b l).oscillation) (u : CorrectionState.State D) (hrep : u.oscillation = LabelSumBounds.fieldSum labels fun (l : ι) => (a l).oscillation) : SignedMeanGain.TensorClass s (α + β) (SignedMeanGain.covarianceIncrement u.oscillation (LabelSumBounds.fieldSum labels fun (l : ι) => (b l).oscillation))

theorem NavierStokes.CorrectionStep.gaugeWaveStage_pressure_from_covariance {coord cL cR : ℝ} (U : LocalSignedRequest.SlowRegion coord) (g : VariableGaugeMean.GaugeData PressureStream.Plane) (ha : 0 < g.radial.inner) (hd : 0 < g.radial.exponent) (hcL : 0 < cL) (hcR : 0 < cR) (ε L : ℕ → ℝ) (hε : ∀ (n : ℕ), 0 < ε n) (hεone : ∀ (n : ℕ), ε n ≤ 1) (hL : ∀ (n : ℕ), 1 ≤ L n) (hell : ∀ (n : ℕ), g.length n = VariableGaugeMean.qLength coord) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) (w : CorrectionState.Oscillation LocalSignedRequest.Point) (q : CorrectionState.OscillatoryScalar LocalSignedRequest.Point) (gaussian : CorrectionState.Oscillation LocalSignedRequest.Point) (hop : LocalRankDefect.LocalOperators U.carrier c.operators) (hbase : MeanIncrementBounds.SmoothTriple (LocalRankDefect.positiveDomain U.carrier) c.base) (hm : GaugeDebtIncrement.RegularTriple U g.radial.inner g.radial.outer u.mean) (hW : ∀ (i j : Fin 3), GaugeDebtIncrement.Regular U g.radial.inner g.radial.outer (u.covariance i j)) (hX : ∀ (i j : Fin 3), GaugeDebtIncrement.Regular U g.radial.inner g.radial.outer (SignedMeanGain.covarianceIncrement u.oscillation w i j)) {κ α : ℝ} (ho : MeanIncrementBounds.OperatorBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) c.operators κ) (hcX : SignedMeanGain.TensorClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) α (SignedMeanGain.covarianceIncrement u.oscillation w)) (hfixed : (VariableGaugeMean.reconstructState g c u).pressure = u.pressure) : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (α - κ) (SignedMeanGain.pressureChange g c u w q gaussian)

theorem NavierStokes.CorrectionStep.gaugeWaveStage_mean_from_covariance {coord cL cR : ℝ} (U : LocalSignedRequest.SlowRegion coord) (g : VariableGaugeMean.GaugeData PressureStream.Plane) (ha : 0 < g.radial.inner) (hd : 0 < g.radial.exponent) (hcL : 0 < cL) (hcR : 0 < cR) (ε L : ℕ → ℝ) (hε : ∀ (n : ℕ), 0 < ε n) (hεone : ∀ (n : ℕ), ε n ≤ 1) (hL : ∀ (n : ℕ), 1 ≤ L n) (hell : ∀ (n : ℕ), g.length n = VariableGaugeMean.qLength coord) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) (w : CorrectionState.Oscillation LocalSignedRequest.Point) (q : CorrectionState.OscillatoryScalar LocalSignedRequest.Point) (gaussian : CorrectionState.Oscillation LocalSignedRequest.Point) (hop : LocalRankDefect.LocalOperators U.carrier c.operators) (hbase : MeanIncrementBounds.SmoothTriple (LocalRankDefect.positiveDomain U.carrier) c.base) (hm : GaugeDebtIncrement.RegularTriple U g.radial.inner g.radial.outer u.mean) (hW : ∀ (i j : Fin 3), GaugeDebtIncrement.Regular U g.radial.inner g.radial.outer (u.covariance i j)) (hX : ∀ (i j : Fin 3), GaugeDebtIncrement.Regular U g.radial.inner g.radial.outer (SignedMeanGain.covarianceIncrement u.oscillation w i j)) {κ α : ℝ} (ho : MeanIncrementBounds.OperatorBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) c.operators κ) (hcX : SignedMeanGain.TensorClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) α (SignedMeanGain.covarianceIncrement u.oscillation w)) (hfixed : (VariableGaugeMean.reconstructState g c u).pressure = u.pressure) (hb : MeanIncrementBounds.BaseBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) c.base) (hu : CorrectionState.CumulativeBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) u) (hα : 9 / 10 ≤ α - κ) {β : ℝ} (hβ : β ≤ α - κ) (hθ : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) β (u.thetaResidual c)) (hz : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) β (u.axialResidual c)) (hdebt : ∀ (i : Fin 3), WeightedClasses.UnweightedClass (PhysicalMeanDomain.localSlowStripData U.carrier ⋯ ε L hε hεone hL) β fun (n : ℕ) (x : LocalSignedRequest.Plane) => CorrectionState.debt c u n x i) : have v := SignedMeanGain.waveStage g c u w q gaussian; WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (α - κ) (SignedMeanGain.pressureChange g c u w q gaussian) ∧ CorrectionState.CumulativeBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) v ∧ WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) β (v.thetaResidual c) ∧ WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) β (v.axialResidual c) ∧ ∀ (i : Fin 3), WeightedClasses.UnweightedClass (PhysicalMeanDomain.localSlowStripData U.carrier ⋯ ε L hε hεone hL) β fun (n : ℕ) (x : LocalSignedRequest.Plane) => CorrectionState.debt c v n x i

noncomputable def NavierStokes.CorrectionStep.CycleParameters.beforeSignedBlock {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (l : ι) : CorrectionState.HarmonicBlock CyclePoint

Before signed block, given by addBlock (v.blocks l) (p.particularBlock v c u l).

Equations

• p.beforeSignedBlock v c u l = NavierStokes.CorrectionStep.addBlock (v.blocks l) (p.particularBlock v c u l)

noncomputable def NavierStokes.CorrectionStep.CycleParameters.signedTangent {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (l : ι) : CorrectionState.HarmonicBlock CyclePoint

Signed tangent, given by (p.signed l).tangentBlock p.strip (p.signedRequest v c u).

Equations

• p.signedTangent v c u l = (p.signed l).tangentBlock p.strip (p.signedRequest v c u)

noncomputable def NavierStokes.CorrectionStep.CycleParameters.signedCurl {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (l : ι) : CorrectionState.HarmonicBlock CyclePoint

Signed curl, given by (p.signed l).curlBlock p.strip (p.signedRequest v c u).

Equations

• p.signedCurl v c u l = (p.signed l).curlBlock p.strip (p.signedRequest v c u)

theorem NavierStokes.CorrectionStep.CycleParameters.beforeSignedBlock_represents {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) {axis : AxisymmetricAlias} (hrep : CycleRepresentation v u axis) : (p.afterParticular v c u).oscillation = LabelSumBounds.fieldSum v.labels fun (l : ι) => (p.beforeSignedBlock v c u l).oscillation

theorem NavierStokes.CorrectionStep.CycleParameters.signedVelocity_split {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : p.signedVelocity v c u = (LabelSumBounds.fieldSum v.labels fun (l : ι) => (p.signedTangent v c u l).oscillation) + LabelSumBounds.fieldSum v.labels fun (l : ι) => (p.signedCurl v c u l).oscillation

theorem NavierStokes.CorrectionStep.CycleParameters.block_band_mono {b : CorrectionState.HarmonicBlock CyclePoint} {N M : ℕ} (h : b.BandLimited N) (hle : N ≤ M) : b.BandLimited M

noncomputable def NavierStokes.CorrectionStep.CycleParameters.signedFamily {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (primary : ι → CorrectionState.HarmonicBlock CyclePoint) (P : ι → ℕ → CyclePoint → ℝ) {σ κ : ℝ} (hσ : 1 / 5 ≤ σ) (N : ℕ) (hprimary : ∀ (l : ι), (primary l).BandLimited N) (hband : CoefficientBands v) (hcp : ∀ (l : ι), SameCarrier (v.blocks l) (primary l)) (hcs : ∀ (l : ι), SameCarrier (v.blocks l) (p.signedBlock v c u l)) (hold : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 / 2) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((v.blocks l).velocity n i).coeff j x) (hdiff : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (17 / 25) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((v.blocks l).velocity n i).coeff j x - ((primary l).velocity n i).coeff j x) (hpart : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 / 2 + σ) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((p.particularBlock v c u l).velocity n i).coeff j x) (htangent : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 / 2 + σ - κ) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((p.signedTangent v c u l).velocity n i).coeff j x) (hcurl : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 + σ - 2 * κ) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((p.signedCurl v c u l).velocity n i).coeff j x) (hP0 : ∀ (l : ι) (n : ℕ), ∀ x ∈ p.strip.domain, 0 ≤ P l n x) (hP1 : ∀ (l : ι) (n : ℕ), ∀ x ∈ p.strip.domain, P l n x ≤ 1) (hkp : ∀ (l : ι) (n : ℕ), (v.blocks l).angularFrequency n ≠ 0) : LabelSumBounds.SignedFamily p.strip P (1 / 2) (17 / 25) (1 / 2 + σ - κ) (1 + σ - 2 * κ)

The family in the signed covariance identity is computed from the current cycle, including its actual particular increment and signed curl.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.nativeSignedStage_mean_debt (G : SignedMeanGain.Geometry) (B : SignedMeanGain.NativeData G) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) {P : SignedMeanGain.NativeIndex → ℕ → LocalSignedRequest.Point → ℝ} {σ κ : ℝ} (hσ : 1 / 5 ≤ σ) (hκ : 0 ≤ κ) (hκsmall : κ ≤ 1 / 100000) (f : LabelSumBounds.SignedFamily G.strip P (1 / 2) (17 / 25) (1 / 2 + σ - κ) (1 + σ - 2 * κ)) (a : SignedMeanGain.Assembly f) (hl : a.labels = B.labels) (hp : ∀ (l : SignedMeanGain.NativeIndex), (f.primary l).velocity = (B.primaryBlocks l).velocity) (hcp : ∀ (l : SignedMeanGain.NativeIndex), LabelSumBounds.SameCarrier (f.primary l) (B.primaryBlocks l)) (ht : ∀ (l : SignedMeanGain.NativeIndex), (f.tangent l).velocity = (B.signedBlocks c u l).velocity) (hct : ∀ (l : SignedMeanGain.NativeIndex), LabelSumBounds.SameCarrier (f.tangent l) (B.signedBlocks c u l)) (q : CorrectionState.OscillatoryScalar LocalSignedRequest.Point) (gaussian : CorrectionState.Oscillation LocalSignedRequest.Point) (hold : u.oscillation = SignedMeanGain.oldField f a) (H : SignedMeanGain.LocalData G c u (SignedMeanGain.tangentField f a + SignedMeanGain.curlField f a) q gaussian) (ho : MeanIncrementBounds.OperatorBounds G.strip G.operators κ) (hu : CorrectionState.CumulativeBounds G.strip u) (hbase : MeanIncrementBounds.SmoothTriple (LocalRankDefect.positiveDomain G.region.carrier) c.base) (hm : GaugeDebtIncrement.RegularTriple G.region G.patch.a G.patch.b u.mean) (hW : ∀ (i j : Fin 3), GaugeDebtIncrement.Regular G.region G.patch.a G.patch.b (u.covariance i j)) (hX : ∀ (i j : Fin 3), SignedMeanGain.MovingField G (SignedMeanGain.incrementTensor f a i j)) (hS : ∀ (i j : Fin 3), SignedMeanGain.MovingField G (SignedMeanGain.crossTensor f a i j)) (hθ : WeightedClasses.MeanClass G.strip (1 + σ - κ) (u.thetaResidual c)) (hz : WeightedClasses.MeanClass G.strip (1 + σ - κ) (u.axialResidual c)) (hd : CorrectionState.DefectBounds G.slowStrip (σ - κ) c u) : have v := SignedMeanGain.waveStage G.gauge c u (SignedMeanGain.tangentField f a + SignedMeanGain.curlField f a) q gaussian; WeightedClasses.MeanClass G.strip (1 + σ - 2 * κ) (v.pressure - u.pressure) ∧ CorrectionState.CumulativeBounds G.strip v ∧ WeightedClasses.MeanClass G.strip (1 + σ - 2 * κ) (v.thetaResidual c) ∧ WeightedClasses.MeanClass G.strip (1 + σ - 2 * κ) (v.axialResidual c) ∧ WeightedClasses.MeanClass G.strip (1 + σ + 17 / 100) (meanBar (v.thetaResidual c)) ∧ WeightedClasses.MeanClass G.strip (1 + σ + 17 / 100) (meanBar (v.axialResidual c)) ∧ CorrectionState.DefectBounds G.slowStrip (σ - 2 * κ) c v

The actual native signed update supplies its pressure, cumulative, mean-residual, and measured-debt bounds from the same covariance.

noncomputable def NavierStokes.CorrectionStep.jointRawBackground {D I ι : Type} (a : ι → PeriodizedWaveBounds.CopyData D I) : LocalizedWaveBounds.WaveFamily D (ι × I)

Joint raw background, given by LocalizedWaveBounds.WaveFamily.ofCoefficients (fun j => {(a j.1).background with amplitude := 0, pressure := 0}).

Equations

• One or more equations did not get rendered due to their size.

noncomputable def NavierStokes.CorrectionStep.jointRawCoefficients {D I ι : Type} (a : ι → PeriodizedWaveBounds.CopyData D I) : LocalizedWaveBounds.WaveFamily D (ι × I)

Joint raw coefficients, given by LocalizedWaveBounds.WaveFamily.ofCoefficients (fun j => (a j.1).raw j.2).

Equations

• NavierStokes.CorrectionStep.jointRawCoefficients a = NavierStokes.LocalizedWaveBounds.WaveFamily.ofCoefficients fun (j : ι × I) => (a j.1).raw j.2

theorem NavierStokes.CorrectionStep.uniform_localInput_of_coefficients {D I ι : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (a : ι → PeriodizedWaveBounds.CopyData D I) {s : WeightedClasses.StripData D} {C : ι → ℕ → I → Set D} {W : ι → ℕ → D → ℝ} {α κ : ℝ} {d : LinearWaveBounds.GraphDirections D} (h : LocalizedWaveBounds.InputBounds s (fun (n : ℕ) (j : ι × I) => C j.1 n j.2) (fun (n : ℕ) (j : ι × I) (x : D) => W j.1 n x) 0 κ d (jointRawBackground a)) (hW : ∀ (l : ι) (n : ℕ), ∀ x ∈ s.domain, 0 ≤ W l n x) (ha : PeriodizedWaveBounds.UniformLocalJets s (fun (l : ι) (n : ℕ) (x : D) => √(s.zeta x) * W l n x) α C fun (l : ι) => (a l).amplitude) (hp : PeriodizedWaveBounds.UniformLocalJets s (fun (l : ι) (n : ℕ) (x : D) => √(s.zeta x) * W l n x) (α + 1 / 2) C fun (l : ι) => (a l).pressure) : LocalizedWaveBounds.InputBounds s (fun (n : ℕ) (j : ι × I) => C j.1 n j.2) (fun (n : ℕ) (j : ι × I) (x : D) => W j.1 n x) α κ d (jointRawCoefficients a)

theorem NavierStokes.CorrectionStep.uniform_common_bounds_from_raw {D I ι : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (a : ι → PeriodizedWaveBounds.CopyData D I) (K : ι → PeriodizedWaveBounds.Cells D I) (hs : ∀ (l : ι) (n : ℕ) (i : I), Function.support ((a l).cutoff n i) ⊆ (K l).carrier n i) {s : WeightedClasses.StripData D} {C : ι → ℕ → I → Set D} {W : ι → ℕ → D → ℝ} {α κ : ℝ} {d : LinearWaveBounds.GraphDirections D} (hW : ∀ (l : ι) (n : ℕ), ∀ x ∈ s.domain, 0 ≤ W l n x) (h : LocalizedWaveBounds.InputBounds s (fun (n : ℕ) (j : ι × I) => C j.1 n j.2) (fun (n : ℕ) (j : ι × I) (x : D) => W j.1 n x) 0 κ d (jointRawBackground a)) (ha : PeriodizedWaveBounds.UniformLocalJets s (fun (l : ι) (n : ℕ) (x : D) => √(s.zeta x) * W l n x) α C fun (l : ι) => (a l).amplitude) (hp : PeriodizedWaveBounds.UniformLocalJets s (fun (l : ι) (n : ℕ) (x : D) => √(s.zeta x) * W l n x) (α + 1 / 2) C fun (l : ι) => (a l).pressure) (hcut : PeriodizedWaveBounds.UniformLocalJets s (fun (x : ι) (x_1 : ℕ) (x_2 : D) => 1) 0 C fun (l : ι) => (a l).cutoff) (hκ : κ ≤ 1 / 2) {lo hi : ℝ} (hlo : 0 < lo) (hLower : ∀ (l : ι) (n : ℕ) (i : I), ∀ x ∈ s.domain, x ∈ C l n i → lo ≤ ‖(a l).background.normal s d n x‖) (hUpper : ∀ (l : ι) (n : ℕ) (i : I), ∀ x ∈ s.domain, x ∈ C l n i → ‖(a l).background.normal s d n x‖ ≤ hi) (hfreq : LocalizedWaveBounds.LocalUnweighted s (fun (n : ℕ) (j : ι × I) => C j.1 n j.2) (1 / 2) fun (n : ℕ) (j : ι × I) (x : D) => 1 / (a j.1).background.frequency n) (hcover : ∀ (l : ι) (n : ℕ) (i : I), ∀ x ∈ s.domain, x ∈ (K l).carrier n i → x ∈ C l n i ∨ (((a l).localized i).amplitude n =ᶠ[nhds x] fun (x : D) => 0) ∧ ((a l).localized i).pressure n =ᶠ[nhds x] fun (x : D) => 0) : (LabelSumBounds.UniformWaveClass s W α fun (l : ι) => (a l).common.amplitude) ∧ (LabelSumBounds.UniformWaveClass s W α fun (l : ι) => ((a l).commonCorrected s d).amplitude) ∧ (LabelSumBounds.UniformWaveClass s W (α + 1 / 2) fun (l : ι) => (a l).common.pressure) ∧ (LabelSumBounds.UniformWaveClass s W (α + 1 / 2 - κ) fun (l : ι) => (a l).common.curlCorrection s d) ∧ LabelSumBounds.UniformWaveClass s W (α + 1 / 2 - 3 * κ) fun (l : ι) => (a l).globalGood s d

The native solver estimates enter before summation over copies or spatial labels. All bounds on the background remain local to C.

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.uniform_block_bounds {D I ι : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : ι → PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) {P : ι → ℕ → D → ℝ} {α κ : ℝ} (ha : LabelSumBounds.UniformWaveClass (HarmonicWaveInteraction.productStrip s) (fun (l : ι) (n : ℕ) (x : D × ℝ) => P l n x.1) α fun (l : ι) => ((p l).copyData s request).common.amplitude) (he : LabelSumBounds.UniformWaveClass (HarmonicWaveInteraction.productStrip s) (fun (l : ι) (n : ℕ) (x : D × ℝ) => P l n x.1) α fun (l : ι) => (((p l).copyData s request).commonCorrected (HarmonicWaveInteraction.productStrip s) (p l).directions).amplitude) (hp : LabelSumBounds.UniformWaveClass (HarmonicWaveInteraction.productStrip s) (fun (l : ι) (n : ℕ) (x : D × ℝ) => P l n x.1) (α + 1 / 2) fun (l : ι) => ((p l).copyData s request).common.pressure) (hc : LabelSumBounds.UniformWaveClass (HarmonicWaveInteraction.productStrip s) (fun (l : ι) (n : ℕ) (x : D × ℝ) => P l n x.1) (α + 1 / 2 - κ) fun (l : ι) => ((p l).copyData s request).common.curlCorrection (HarmonicWaveInteraction.productStrip s) (p l).directions) (hg : LabelSumBounds.UniformWaveClass (HarmonicWaveInteraction.productStrip s) (fun (l : ι) (n : ℕ) (x : D × ℝ) => P l n x.1) (α + 1 / 2 - 3 * κ) fun (l : ι) => ((p l).copyData s request).globalGood (HarmonicWaveInteraction.productStrip s) (p l).directions) : (∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass s P α fun (l : ι) (n : ℕ) (x : D) => (((p l).tangentBlock s request).velocity n i).coeff j x) ∧ (∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass s P α fun (l : ι) (n : ℕ) (x : D) => (((p l).exactBlock s request).velocity n i).coeff j x) ∧ (∀ (j : ℤ), LabelSumBounds.UniformWaveClass s P (α + 1 / 2) fun (l : ι) (n : ℕ) (x : D) => (((p l).exactBlock s request).pressure n).coeff j x) ∧ (∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass s P (α + 1 / 2 - κ) fun (l : ι) (n : ℕ) (x : D) => (((p l).curlBlock s request).velocity n i).coeff j x) ∧ ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass s P (α + 1 / 2 - 3 * κ) fun (l : ι) (n : ℕ) (x : D) => (((p l).goodBlock s request).velocity n i).coeff j x

Literal stored coefficients inherit the joint estimates of the actual common solves, including the exact-minus-tangent curl.

theorem NavierStokes.CorrectionStep.ParticularParameters.common_amplitude {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] (p : ParticularParameters P) (c : CorrectionState.Context (P × TorusInverse.Plane)) (u : CorrectionState.State (P × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (P × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (P × TorusInverse.Plane)) (j : ℤ) (n : ℕ) : (p.copyData c u b G A j).common.amplitude n = ParticularWaveAssembly.angleLift (ParticularWaveBounds.commonVelocity (p.tangent j n) (ParticularWaveAssembly.residualSource c u b G A j n) (p.geometry n) ⋯ (p.cutoff n))

theorem NavierStokes.CorrectionStep.ParticularParameters.common_pressure {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] (p : ParticularParameters P) (c : CorrectionState.Context (P × TorusInverse.Plane)) (u : CorrectionState.State (P × TorusInverse.Plane)) (b : CorrectionState.HarmonicBlock (P × TorusInverse.Plane)) (G A : HarmonicResidual.BlockCoefficients (P × TorusInverse.Plane)) (j : ℤ) (n : ℕ) (hk : ↑j * b.frequency n ≠ 0) : (p.copyData c u b G A j).common.pressure n = ParticularWaveAssembly.angleLift (ParticularWaveBounds.commonPressure (p.tangent j n) (ParticularWaveAssembly.residualSource c u b G A j n) (p.geometry n) ⋯ (p.cutoff n) (↑j * b.frequency n))

noncomputable def NavierStokes.CorrectionStep.ParticularParameters.fromReference (D : ParticularWaveAssembly.AssemblyData PhysicalParticularWave.Parameter) (h : ℝ) (gap : ℕ → ℕ) : ParticularParameters PhysicalParticularWave.Parameter

Every target band uses the same chosen reference tangent, geometry, clock interval and cutoff. Only the current HR source is supplied at solve time.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.ParticularParameters.fromReference_amplitude (D : ParticularWaveAssembly.AssemblyData PhysicalParticularWave.Parameter) (h : ℝ) (gap : ℕ → ℕ) (j : ℤ) (n : ℕ) : ((fromReference D h gap).copyData D.context D.state D.carrierBlock D.gaussianInput D.aliasInput j).common.amplitude n = ParticularWaveAssembly.angleLift (PhysicalParticularWave.residualBandAmplitude D h ⋯ ⋯ (gap n) (↑j * D.carrierBlock.frequency n) j n)

theorem NavierStokes.CorrectionStep.ParticularParameters.fromReference_pressure (D : ParticularWaveAssembly.AssemblyData PhysicalParticularWave.Parameter) (h : ℝ) (gap : ℕ → ℕ) (j : ℤ) (n : ℕ) (hk : ↑j * D.carrierBlock.frequency n ≠ 0) : ((fromReference D h gap).copyData D.context D.state D.carrierBlock D.gaussianInput D.aliasInput j).common.pressure n = ParticularWaveAssembly.angleLift (PhysicalParticularWave.residualBandPressure D h ⋯ ⋯ (gap n) (↑j * D.carrierBlock.frequency n) j n)

theorem NavierStokes.CorrectionStep.ParticularParameters.fromReference_coherent_amplitude (D : ParticularWaveAssembly.AssemblyData PhysicalParticularWave.Parameter) (h : ℝ) (gap : ℕ → ℕ) (j : ℤ) (n i : ℕ) (H : PhysicalResidualNaturality.BandCoherence D h ⋯ ⋯ i (gap n) n) (hn : PhysicalResidualNaturality.PositiveSupport D.carrierBlock D.gaussianInput D.aliasInput n) (hr : PhysicalResidualNaturality.PositiveSupport D.carrierBlock D.gaussianInput D.aliasInput D.reference.band) : ((fromReference D h gap).copyData D.context D.state D.carrierBlock D.gaussianInput D.aliasInput j).common.amplitude n = ParticularWaveAssembly.angleLift (PhysicalParticularWave.bandAmplitude D h ⋯ ⋯ (gap n) (↑j * D.carrierBlock.frequency n) j)

Full-lift current-state coherence identifies the actual solved amplitude with the one reference physical wave, before taking a graph restriction.

theorem NavierStokes.CorrectionStep.ParticularParameters.fromReference_coherent_pressure (D : ParticularWaveAssembly.AssemblyData PhysicalParticularWave.Parameter) (h : ℝ) (gap : ℕ → ℕ) (j : ℤ) (n i : ℕ) (H : PhysicalResidualNaturality.BandCoherence D h ⋯ ⋯ i (gap n) n) (hn : PhysicalResidualNaturality.PositiveSupport D.carrierBlock D.gaussianInput D.aliasInput n) (hr : PhysicalResidualNaturality.PositiveSupport D.carrierBlock D.gaussianInput D.aliasInput D.reference.band) (hk : ↑j * D.carrierBlock.frequency n ≠ 0) : ((fromReference D h gap).copyData D.context D.state D.carrierBlock D.gaussianInput D.aliasInput j).common.pressure n = ParticularWaveAssembly.angleLift (PhysicalParticularWave.bandPressure D h ⋯ ⋯ (gap n) (↑j * D.carrierBlock.frequency n) j)

theorem NavierStokes.CorrectionStep.meanStages_constructed (g : VariableGaugeMean.GaugeData PressureStream.Plane) (r : CorrectionState.RankData PressureStream.Plane) (h : ℝ) (index : ℕ → ℕ) (axial : PressureStream.Plane × PressureStream.Plane) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) {coord cL cR A B : ℝ} (U : LocalSignedRequest.SlowRegion coord) (ha : 0 < g.radial.inner) (hd : 0 < g.radial.exponent) (hcL : 0 < cL) (hcR : 0 < cR) (ε L : ℕ → ℝ) (hε : ∀ (n : ℕ), 0 < ε n) (hεone : ∀ (n : ℕ), ε n ≤ 1) (hL : ∀ (n : ℕ), 1 ≤ L n) (hell : ∀ (n : ℕ), g.length n = VariableGaugeMean.qLength coord) {σ κ : ℝ} (hfixed : (VariableGaugeMean.reconstructState g c u).pressure = u.pressure) (hσ : 1 / 5 ≤ σ) (hκsmall : κ ≤ 1 / 100000) (hh : 0 ≤ h) (hscale : ∀ (n : ℕ), ChartScales.S n ≤ L n) (gap : ℕ) (hgap : ∀ (n : ℕ), ChartScales.nativeIndex h n ≤ index n + gap) (hv : c.operators.vT = (0, 0, TorusInverse.vector TorusInverse.Direction.temporal)) (hfast : ∀ (n : ℕ), c.operators.fastCoefficient n = ChartScales.Tg ^ index n * ChartScales.Q n ^ (1 + h)) (ho : MeanIncrementBounds.OperatorBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) c.operators κ) (hb : MeanIncrementBounds.BaseBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) c.base) (hsigned : CorrectionState.CumulativeBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) u) (hop : LocalRankDefect.LocalOperators U.carrier c.operators) (hbase : MeanIncrementBounds.SmoothTriple (LocalRankDefect.positiveDomain U.carrier) c.base) (hV : LocalRankDefect.IsSlowOn U.carrier c.base.angular) (hG : LocalRankDefect.IsSlowOn U.carrier c.base.axial) (hm : MeanIncrementBounds.SmoothTriple (PhysicalMeanDomain.slowDomain U.carrier) u.mean) (hms : GaugeSupportedTriple g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier u.mean) (hW : ∀ (i j : Fin 3), MeanIncrementBounds.SmoothOn (PhysicalMeanDomain.slowDomain U.carrier) (u.covariance i j)) (hWs : ∀ (i j : Fin 3), GaugeSupported g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier (u.covariance i j)) (hθ : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.thetaResidual c n) (PhysicalMeanDomain.slowDomain U.carrier)) (hz : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (u.axialResidual c n) (PhysicalMeanDomain.slowDomain U.carrier)) (hpθ : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn U.carrier (u.thetaResidual c n)) (hpz : ∀ (n : ℕ), PhysicalMeanDomain.PeriodicOn U.carrier (u.axialResidual c n)) (hsθ : GaugeSupported g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier (u.thetaResidual c)) (hsz : GaugeSupported g.radial.inner g.radial.outer (VariableGaugeMean.qLength coord) U.carrier (u.axialResidual c)) (hcθ : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (1 + σ - 2 * κ) (u.thetaResidual c)) (hcz : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (1 + σ - 2 * κ) (u.axialResidual c)) (hbarθ : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (1 + σ + 17 / 100) (meanBar (u.thetaResidual c))) (hbarz : WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (1 + σ + 17 / 100) (meanBar (u.axialResidual c))) (hdebt : ∀ (i : Fin 3), WeightedClasses.UnweightedClass (PhysicalMeanDomain.localSlowStripData U.carrier ⋯ ε L hε hεone hL) (1 + σ - 2 * κ) fun (n : ℕ) (x : LocalSignedRequest.Plane) => CorrectionState.debt c u n x i) (hg : LocalRankDefect.RankGeometry g r U.carrier c (VariableGaugeMean.temporalStageState g h index axial c u)) (hparam : RankStateBounds.NormalizedParameters coord A B r U.carrier) (hB : B ≠ 0) (hleft : g.radial.inner < r.inner) (hright : r.outer < g.radial.outer) : MeanIncrementBounds.IncrementBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (1 + σ - 2 * κ) (VariableGaugeMean.temporalIncrementState g h index axial c u) ∧ MeanIncrementBounds.IncrementBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (1 + σ - 2 * κ) (VariableGaugeMean.rankIncrementState g r axial c (VariableGaugeMean.temporalStageState g h index axial c u)) ∧ WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (1 + σ - 2 * κ) ((VariableGaugeMean.rankStageState g r axial c (VariableGaugeMean.temporalStageState g h index axial c u)).pressure - u.pressure) ∧ CorrectionState.CumulativeBounds (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (VariableGaugeMean.rankStageState g r axial c (VariableGaugeMean.temporalStageState g h index axial c u)) ∧ CorrectionState.DefectBounds (PhysicalMeanDomain.localSlowStripData U.carrier ⋯ ε L hε hεone hL) (σ + 1 / 10) c (VariableGaugeMean.rankStageState g r axial c (VariableGaugeMean.temporalStageState g h index axial c u)) ∧ WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (1 + (σ + 1 / 10)) ((VariableGaugeMean.rankStageState g r axial c (VariableGaugeMean.temporalStageState g h index axial c u)).thetaResidual c) ∧ WeightedClasses.MeanClass (LocalSignedRequest.movingStripData U g.radial.inner g.radial.outer cL cR ha hcL hcR ε L hε hεone hL) (1 + (σ + 1 / 10)) ((VariableGaugeMean.rankStageState g r axial c (VariableGaugeMean.temporalStageState g h index axial c u)).axialResidual c - fun (n : ℕ) (x : PressureStream.Lift PressureStream.Plane) => VariableGaugeMean.temporalAliasState g h index c u n (x, 0) 2)

theorem NavierStokes.CorrectionStep.ParticularParameters.uniform_assembled_bounds {Q ι : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] (p : ι → ParticularParameters Q) (s : WeightedClasses.StripData (Q × TorusInverse.Plane)) (c : CorrectionState.Context (Q × TorusInverse.Plane)) (u : CorrectionState.State (Q × TorusInverse.Plane)) (b : ι → CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)) (G A : ι → HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)) (N : ℕ) {W : ι → ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} (hW : ∀ (l : ι) (n : ℕ), ∀ x ∈ (nativeStrip s).domain, 0 ≤ W l n x) (ha : ∀ j ∈ ParticularWaveAssembly.modes N, LabelSumBounds.UniformWaveClass (nativeStrip s) W α fun (l : ι) => ((p l).wave s c u (b l) (G l) (A l) j).amplitude) (hp : ∀ j ∈ ParticularWaveAssembly.modes N, LabelSumBounds.UniformWaveClass (nativeStrip s) W (α + 1 / 2) fun (l : ι) => ((p l).wave s c u (b l) (G l) (A l) j).pressure) (hg : ∀ j ∈ ParticularWaveAssembly.modes N, LabelSumBounds.UniformWaveClass (nativeStrip s) W (α + 1 / 2 - 3 * κ) fun (l : ι) => ((p l).copyData c u (b l) (G l) (A l) j).globalGood (nativeStrip s) (p l).directions) : (∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass s (fun (l : ι) (n : ℕ) (x : Q × TorusInverse.Plane) => W l n (ParticularWaveAssembly.angleShuffle (x, 0))) α fun (l : ι) (n : ℕ) (x : Q × TorusInverse.Plane) => (((p l).updateBlock s c u (b l) (G l) (A l) N).velocity n i).coeff j x) ∧ (∀ (j : ℤ), LabelSumBounds.UniformWaveClass s (fun (l : ι) (n : ℕ) (x : Q × TorusInverse.Plane) => W l n (ParticularWaveAssembly.angleShuffle (x, 0))) (α + 1 / 2) fun (l : ι) (n : ℕ) (x : Q × TorusInverse.Plane) => (((p l).updateBlock s c u (b l) (G l) (A l) N).pressure n).coeff j x) ∧ ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass s (fun (l : ι) (n : ℕ) (x : Q × TorusInverse.Plane) => W l n (ParticularWaveAssembly.angleShuffle (x, 0))) (α + 1 / 2 - 3 * κ) fun (l : ι) (n : ℕ) (x : Q × TorusInverse.Plane) => (((p l).goodBlock s c u (b l) (G l) (A l) N).velocity n i).coeff j x

theorem NavierStokes.CorrectionStep.ParticularParameters.uniform_linearGood_bounds {Q ι : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] (p : ι → ParticularParameters Q) (s : WeightedClasses.StripData (Q × TorusInverse.Plane)) (c : CorrectionState.Context (Q × TorusInverse.Plane)) (u : CorrectionState.State (Q × TorusInverse.Plane)) (b : ι → CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)) (G A : ι → HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)) (N : ℕ) {W : ι → ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} (C : (l : ι) → (j : ℤ) → j ∈ ParticularWaveAssembly.modes N → (p l).NativeControl s c u (b l) (G l) (A l) j (W l) α κ) (dyn : ∀ (l : ι) (j : ℤ) (hj : j ∈ ParticularWaveAssembly.modes N), NativeDynamics (C l j hj)) (hκ : κ ≤ 1 / 2) (hW : ∀ (l : ι) (n : ℕ), ∀ x ∈ (nativeStrip s).domain, 0 ≤ W l n x) (hg : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass s (fun (l : ι) (n : ℕ) (x : Q × TorusInverse.Plane) => W l n (ParticularWaveAssembly.angleShuffle (x, 0))) (α + 1 / 2 - 3 * κ) fun (l : ι) (n : ℕ) (x : Q × TorusInverse.Plane) => (((p l).goodBlock s c u (b l) (G l) (A l) N).velocity n i).coeff j x) (hN : ∀ (l : ι), (HarmonicResidual.residualBlock c u (b l) (G l) (A l)).BandLimited N) (hB : MeanIncrementBounds.SmoothTriple s.domain c.base) (hrad : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (HarmonicResidual.contextFrame c n).radial s.domain) (hm : ∀ (l : ι), WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) (ParticularWaveBounds.reindexDirections ParticularWaveAssembly.angleShuffle (p l).directions) (ParticularWaveBounds.reindexCoefficients ParticularWaveAssembly.angleShuffle (p l).background)) (hphase : ∀ (l : ι) (n : ℕ), ContDiffOn ℝ (↑⊤) ((b l).phase n) s.domain) (hkp : ∀ (l : ι) (n : ℕ), (b l).angularFrequency n ≠ 0) (i : Fin 3) (j : ℤ) : j ≠ 0 → LabelSumBounds.UniformWaveClass s (fun (l : ι) (n : ℕ) (x : Q × TorusInverse.Plane) => W l n (ParticularWaveAssembly.angleShuffle (x, 0))) (α + 1 / 2 - 3 * κ) fun (l : ι) (n : ℕ) (x : Q × TorusInverse.Plane) => ((HarmonicResidual.residualBlock c u (b l) (G l) (A l)).velocity n i).coeff j x + ((HarmonicWaveInteraction.linearGoodBlock c (b l) ((p l).updateBlock s c u (b l) (G l) (A l) N) ((p l).gaussianBlock c u (b l) (G l) (A l) N).velocity).velocity n i).coeff j x

theorem NavierStokes.CorrectionStep.ParticularParameters.uniform_residual_gain {Q ι : Type} [NormedAddCommGroup Q] [NormedSpace ℝ Q] (p : ι → ParticularParameters Q) (s : WeightedClasses.StripData (Q × TorusInverse.Plane)) (c : CorrectionState.Context (Q × TorusInverse.Plane)) (u : CorrectionState.State (Q × TorusInverse.Plane)) (b : ι → CorrectionState.HarmonicBlock (Q × TorusInverse.Plane)) (G A : ι → HarmonicResidual.BlockCoefficients (Q × TorusInverse.Plane)) (N : ℕ) {W : ι → ℕ → (Q × ℝ) × TorusInverse.Plane → ℝ} {α κ : ℝ} (C : (l : ι) → (j : ℤ) → j ∈ ParticularWaveAssembly.modes N → (p l).NativeControl s c u (b l) (G l) (A l) j (W l) α κ) (dyn : ∀ (l : ι) (j : ℤ) (hj : j ∈ ParticularWaveAssembly.modes N), NativeDynamics (C l j hj)) (hα : 7 / 10 ≤ α) (hκ : κ ≤ 1 / 100000) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hR : ∀ x ∈ s.domain, 0 < c.operators.radius x) (hb : MeanIncrementBounds.BaseBounds s c.base) (hu : MeanIncrementBounds.CumulativeBounds s u.mean) (v : CorrectionState.State (Q × TorusInverse.Plane)) (hmean : v.mean = u.mean) (hW : ∀ (l : ι) (n : ℕ), ∀ x ∈ (nativeStrip s).domain, 0 ≤ W l n x) (hWone : ∀ (l : ι) (n : ℕ), ∀ x ∈ s.domain, W l n (ParticularWaveAssembly.angleShuffle (x, 0)) ≤ 1) (hm : ∀ (l : ι), WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) (ParticularWaveBounds.reindexDirections ParticularWaveAssembly.angleShuffle (p l).directions) (ParticularWaveBounds.reindexCoefficients ParticularWaveAssembly.angleShuffle (p l).background)) (hcopy : ∀ j ∈ ParticularWaveAssembly.modes N, LabelSumBounds.UniformWaveClass (nativeStrip s) W α fun (l : ι) => ((p l).wave s c u (b l) (G l) (A l) j).amplitude) (hpressure : ∀ j ∈ ParticularWaveAssembly.modes N, LabelSumBounds.UniformWaveClass (nativeStrip s) W (α + 1 / 2) fun (l : ι) => ((p l).wave s c u (b l) (G l) (A l) j).pressure) (hgood : ∀ j ∈ ParticularWaveAssembly.modes N, LabelSumBounds.UniformWaveClass (nativeStrip s) W (α + 1 / 2 - 3 * κ) fun (l : ι) => ((p l).copyData c u (b l) (G l) (A l) j).globalGood (nativeStrip s) (p l).directions) (hold : UniformHarmonicInteraction.UniformVelocity s (fun (l : ι) (n : ℕ) (x : Q × TorusInverse.Plane) => W l n (ParticularWaveAssembly.angleShuffle (x, 0))) (1 / 2) b) (hzero : ∀ (l : ι), HarmonicWaveInteraction.ZeroMode (b l)) {M : ℕ} (hband : ∀ (l : ι), (b l).BandLimited M) (hsource : ∀ (l : ι), (HarmonicResidual.residualBlock c u (b l) (G l) (A l)).BandLimited N) (hphase : ∀ (l : ι) (n : ℕ), ContDiffOn ℝ (↑⊤) ((b l).phase n) s.domain) (hk : ∀ (l : ι) (n : ℕ), (b l).frequency n ≠ 0) (hkp : ∀ (l : ι) (n : ℕ), (b l).angularFrequency n ≠ 0) (hdiv : ∀ (l : ι), HarmonicWaveInteraction.ModeSolenoidal s c (b l)) (hpold : ∀ (l : ι) (n : ℕ), HarmonicResidual.SmoothCoefficients s.domain ((b l).pressure n)) {patch : ℕ → ι → Set (Q × TorusInverse.Plane)} (hNormal : ∀ (i : Fin 3), LocalizedWaveBounds.LocalUnweighted s patch 0 fun (n : ℕ) (l : ι) (x : Q × TorusInverse.Plane) => (HarmonicMeanInteraction.slowNormal c ho hR (b l).phase n x).ofLp i) (hFreq : LocalizedWaveBounds.LocalUnweighted s patch (-(1 / 2)) fun (n : ℕ) (l : ι) (x : Q × TorusInverse.Plane) => (b l).frequency n) (hAng : LocalizedWaveBounds.LocalUnweighted s patch (-(1 / 2)) fun (n : ℕ) (l : ι) (x : Q × TorusInverse.Plane) => ↑((b l).angularFrequency n)) (hz : ∀ (n : ℕ) (l : ι), ∀ x ∈ s.domain, x ∉ patch n l → ∀ (i : Fin 3) (j : ℤ), j ≠ 0 → (((p l).updateBlock s c u (b l) (G l) (A l) N).velocity n i).coeff j =ᶠ[nhds x] fun (x : Q × TorusInverse.Plane) => 0) : UniformHarmonicInteraction.UniformVelocity s (fun (l : ι) (n : ℕ) (x : Q × TorusInverse.Plane) => W l n (ParticularWaveAssembly.angleShuffle (x, 0))) (α + 1 / 10) fun (l : ι) => HarmonicResidual.residualBlock c v (HarmonicWaveInteraction.addBlock (b l) ((p l).updateBlock s c u (b l) (G l) (A l) N)) (G l + ((p l).gaussianBlock c u (b l) (G l) (A l) N).velocity) (A l)

theorem NavierStokes.CorrectionStep.bandNativeSignedStage_mean_debt {ι : Type} (G : SignedMeanGain.Geometry) (B : SignedMeanGain.NativeData G) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) {P : ι → ℕ → LocalSignedRequest.Point → ℝ} {σ κ : ℝ} (hσ : 1 / 5 ≤ σ) (hκ : 0 ≤ κ) (hκsmall : κ ≤ 1 / 100000) (f : LabelSumBounds.SignedFamily G.strip P (1 / 2) (17 / 25) (1 / 2 + σ - κ) (1 + σ - 2 * κ)) (a : SignedMeanGain.Assembly f) (e : ℕ → ι → SignedMeanGain.NativeIndex) (he : ∀ (n : ℕ), Set.InjOn (e n) ↑(a.labels n)) (hlabels : ∀ (n : ℕ), Finset.image (e n) (a.labels n) = B.labels n) (hp : ∀ (n : ℕ), ∀ l ∈ a.labels n, (f.primary l).velocity n = (B.primaryBlocks (e n l)).velocity n) (hcp : ∀ (n : ℕ), ∀ l ∈ a.labels n, BandReindexedSignedMeanGain.SameCarrierAt (f.primary l) (B.primaryBlocks (e n l)) n) (ht : ∀ (n : ℕ), ∀ l ∈ a.labels n, (f.tangent l).velocity n = (B.signedBlocks c u (e n l)).velocity n) (hct : ∀ (n : ℕ), ∀ l ∈ a.labels n, BandReindexedSignedMeanGain.SameCarrierAt (f.tangent l) (B.signedBlocks c u (e n l)) n) (q : CorrectionState.OscillatoryScalar LocalSignedRequest.Point) (gaussian : CorrectionState.Oscillation LocalSignedRequest.Point) (hold : u.oscillation = SignedMeanGain.oldField f a) (H : SignedMeanGain.LocalData G c u (SignedMeanGain.tangentField f a + SignedMeanGain.curlField f a) q gaussian) (ho : MeanIncrementBounds.OperatorBounds G.strip G.operators κ) (hu : CorrectionState.CumulativeBounds G.strip u) (hbase : MeanIncrementBounds.SmoothTriple (LocalRankDefect.positiveDomain G.region.carrier) c.base) (hm : GaugeDebtIncrement.RegularTriple G.region G.patch.a G.patch.b u.mean) (hW : ∀ (i j : Fin 3), GaugeDebtIncrement.Regular G.region G.patch.a G.patch.b (u.covariance i j)) (hX : ∀ (i j : Fin 3), SignedMeanGain.MovingField G (SignedMeanGain.incrementTensor f a i j)) (hS : ∀ (i j : Fin 3), SignedMeanGain.MovingField G (SignedMeanGain.crossTensor f a i j)) (hθ : WeightedClasses.MeanClass G.strip (1 + σ - κ) (u.thetaResidual c)) (hz : WeightedClasses.MeanClass G.strip (1 + σ - κ) (u.axialResidual c)) (hd : CorrectionState.DefectBounds G.slowStrip (σ - κ) c u) : have v := SignedMeanGain.waveStage G.gauge c u (SignedMeanGain.tangentField f a + SignedMeanGain.curlField f a) q gaussian; WeightedClasses.MeanClass G.strip (1 + σ - 2 * κ) (v.pressure - u.pressure) ∧ CorrectionState.CumulativeBounds G.strip v ∧ WeightedClasses.MeanClass G.strip (1 + σ - 2 * κ) (v.thetaResidual c) ∧ WeightedClasses.MeanClass G.strip (1 + σ - 2 * κ) (v.axialResidual c) ∧ WeightedClasses.MeanClass G.strip (1 + σ + 17 / 100) (meanBar (v.thetaResidual c)) ∧ WeightedClasses.MeanClass G.strip (1 + σ + 17 / 100) (meanBar (v.axialResidual c)) ∧ CorrectionState.DefectBounds G.slowStrip (σ - 2 * κ) c v

The actual native signed update supplies its pressure, cumulative, mean-residual, and measured-debt bounds from the same covariance.

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.uniform_linearGood_bounds {D I ι : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : ι → PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) {P : ι → ℕ → D → ℝ} {β κ : ℝ} (C : (l : ι) → (p l).NativeControl s (P l) κ) (dyn : (l : ι) → NativeDynamics (C l) request) (i₀ : I) (hκ : κ ≤ 1 / 2) (hR : ∀ (j : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) β fun (n : ℕ) (x : D × ℝ) => request n x j) (hkp : ∀ (l : ι) (n : ℕ), (p l).base.frequency n * (dyn l).slope n = ↑((p l).angularFrequency n)) (hkpne : ∀ (l : ι) (n : ℕ), (p l).angularFrequency n ≠ 0) (c : CorrectionState.Context D) (hB : MeanIncrementBounds.SmoothTriple s.domain c.base) (hrad : ∀ (n : ℕ), ContDiffOn ℝ (↑⊤) (HarmonicResidual.contextFrame c n).radial s.domain) (hm : ∀ (l : ι), WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) (p l).directions (p l).base) (a : ι → CorrectionState.HarmonicBlock D) (hc : ∀ (l : ι), SameCarrier (a l) ((p l).exactBlock s request)) (hg : UniformHarmonicInteraction.UniformVelocity s P (β + 1 - 3 * κ) fun (l : ι) => (p l).goodBlock s request) : UniformHarmonicInteraction.UniformVelocity s P (β + 1 - 3 * κ) fun (l : ι) => HarmonicWaveInteraction.linearGoodBlock c (a l) ((p l).exactBlock s request) ((p l).gaussianBlock s request).velocity

theorem NavierStokes.CorrectionStep.PeriodizedSignedParameters.uniform_residual_gain {D I ι : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] (p : ι → PeriodizedSignedParameters D I) (s : WeightedClasses.StripData D) (request : ℕ → D × ℝ → SignedWaveUpdate.Vec2) {P : ι → ℕ → D → ℝ} {κ : ℝ} (C : (l : ι) → (p l).NativeControl s (P l) κ) (dyn : (l : ι) → NativeDynamics (C l) request) (i₀ : I) {B : ℝ} (hB : 7 / 10 ≤ B) (hκ : κ ≤ 1 / 100000) (hRquest : ∀ (j : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip s) (B - 1 / 2 - κ) fun (n : ℕ) (x : D × ℝ) => request n x j) (geom : ∀ (l : ι) (n : ℕ), CurlClassBounds.CylindricalGeometry (HarmonicWaveInteraction.productStrip s).domain ((p l).base.radius n) ((p l).directions.radialField n) (fun (x : D × ℝ) => (p l).directions.angular) ((p l).directions.axialField (HarmonicWaveInteraction.productStrip s) n)) (ht : ∀ (l : ι) (n : ℕ) (i : I), ∀ x ∈ (HarmonicWaveInteraction.productStrip s).domain, x ∈ (C l).phasePatch n i → inner ℝ ((p l).base.normal (HarmonicWaveInteraction.productStrip s) (p l).directions n x) ((p l).fundamental i n x) = 0) (hkp : ∀ (l : ι) (n : ℕ), (p l).base.frequency n * (dyn l).slope n = ↑((p l).angularFrequency n)) (hkpne : ∀ (l : ι) (n : ℕ), (p l).angularFrequency n ≠ 0) (c : CorrectionState.Context D) (u v : CorrectionState.State D) (hmean : v.mean = u.mean) (ho : MeanIncrementBounds.OperatorBounds s c.operators κ) (hR : ∀ x ∈ s.domain, 0 < c.operators.radius x) (hbase : MeanIncrementBounds.BaseBounds s c.base) (hu : MeanIncrementBounds.CumulativeBounds s u.mean) (hm : ∀ (l : ι), WaveFrameMatch c (HarmonicWaveInteraction.productStrip s) (p l).directions (p l).base) (a : ι → CorrectionState.HarmonicBlock D) (hc : ∀ (l : ι), SameCarrier (a l) ((p l).exactBlock s request)) (ha : UniformHarmonicInteraction.UniformVelocity s P (1 / 2) a) (hnew : UniformHarmonicInteraction.UniformVelocity s P (B - κ) fun (l : ι) => (p l).exactBlock s request) (hgood : UniformHarmonicInteraction.UniformVelocity s P (B + 1 / 2 - 4 * κ) fun (l : ι) => (p l).goodBlock s request) (ha0 : ∀ (l : ι), HarmonicWaveInteraction.ZeroMode (a l)) {M : ℕ} (hM : ∀ (l : ι), (a l).BandLimited M) (hphase : ∀ (l : ι) (n : ℕ), ContDiffOn ℝ (↑⊤) ((a l).phase n) s.domain) (hk : ∀ (l : ι) (n : ℕ), (a l).frequency n ≠ 0) (hka : ∀ (l : ι) (n : ℕ), (a l).angularFrequency n ≠ 0) (hdiv : ∀ (l : ι), HarmonicWaveInteraction.ModeSolenoidal s c (a l)) (hpold : ∀ (l : ι) (n : ℕ), HarmonicResidual.SmoothCoefficients s.domain ((a l).pressure n)) {patch : ℕ → ι → Set D} (hNormal : ∀ (i : Fin 3), LocalizedWaveBounds.LocalUnweighted s patch 0 fun (n : ℕ) (l : ι) (x : D) => (HarmonicMeanInteraction.slowNormal c ho hR (a l).phase n x).ofLp i) (hFreq : LocalizedWaveBounds.LocalUnweighted s patch (-(1 / 2)) fun (n : ℕ) (l : ι) (x : D) => (a l).frequency n) (hAng : LocalizedWaveBounds.LocalUnweighted s patch (-(1 / 2)) fun (n : ℕ) (l : ι) (x : D) => ↑((a l).angularFrequency n)) (hz : ∀ (n : ℕ) (l : ι), ∀ x ∈ s.domain, x ∉ patch n l → ∀ (i : Fin 3) (j : ℤ), j ≠ 0 → (((p l).exactBlock s request).velocity n i).coeff j =ᶠ[nhds x] fun (x : D) => 0) (hP1 : ∀ (l : ι) (n : ℕ), ∀ x ∈ s.domain, P l n x ≤ 1) (G A : ι → HarmonicResidual.BlockCoefficients D) (hold : UniformHarmonicInteraction.UniformVelocity s P (B + 1 / 10) fun (l : ι) => HarmonicResidual.residualBlock c u (a l) (G l) (A l)) : UniformHarmonicInteraction.UniformVelocity s P (B + 1 / 10) fun (l : ι) => HarmonicResidual.residualBlock c v (HarmonicWaveInteraction.addBlock (a l) ((p l).exactBlock s request)) (G l + ((p l).gaussianBlock s request).velocity) (A l)

theorem NavierStokes.CorrectionStep.fourStage_mean_gain {ι : Type} (G : SignedMeanGain.Geometry) (B : SignedMeanGain.NativeData G) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) (w₁ : CorrectionState.Oscillation LocalSignedRequest.Point) (q₁ : CorrectionState.OscillatoryScalar LocalSignedRequest.Point) (e₁ : CorrectionState.Oscillation LocalSignedRequest.Point) {P : ι → ℕ → LocalSignedRequest.Point → ℝ} {σ κ : ℝ} (f : LabelSumBounds.SignedFamily G.strip P (1 / 2) (17 / 25) (1 / 2 + σ - κ) (1 + σ - 2 * κ)) (a : SignedMeanGain.Assembly f) (q₂ : CorrectionState.OscillatoryScalar LocalSignedRequest.Point) (e₂ : CorrectionState.Oscillation LocalSignedRequest.Point) (hσ : 1 / 5 ≤ σ) (hκ : 0 ≤ κ) (hκsmall : κ ≤ 1 / 100000) (H : MeanStateRegularity.PrimitiveData G.region G.patch.a G.patch.b c u) (hop : c.operators = G.operators) (ho : MeanIncrementBounds.OperatorBounds G.strip G.operators κ) (hb : MeanIncrementBounds.BaseBounds G.strip c.base) (hu : CorrectionState.CumulativeBounds G.strip u) (hfixed : (VariableGaugeMean.reconstructState G.gauge c u).pressure = u.pressure) (hmθ : ∀ (n : ℕ), ∀ z ∈ G.region.carrier, CorrectionState.radialMoment 2 u.mean.angular n z = 0) (hmz : ∀ (n : ℕ), ∀ z ∈ G.region.carrier, CorrectionState.radialMoment 1 u.mean.axial n z = 0) (hθ : WeightedClasses.MeanClass G.strip (1 + σ) (u.thetaResidual c)) (hz : WeightedClasses.MeanClass G.strip (1 + σ) (u.axialResidual c)) (hd : CorrectionState.DefectBounds G.slowStrip σ c u) (hX₁ : ∀ (i j : Fin 3), GaugeMomentBalances.MovingField G.region G.patch.a G.patch.b (SignedMeanGain.covarianceIncrement u.oscillation w₁ i j)) (hX₁class : SignedMeanGain.TensorClass G.strip (1 + σ) (SignedMeanGain.covarianceIncrement u.oscillation w₁)) (hX₂ : ∀ (i j : Fin 3), SignedMeanGain.MovingField G (SignedMeanGain.incrementTensor f a i j)) (hS : ∀ (i j : Fin 3), SignedMeanGain.MovingField G (SignedMeanGain.crossTensor f a i j)) (hold : (SignedMeanGain.waveStage G.gauge c u w₁ q₁ e₁).oscillation = SignedMeanGain.oldField f a) (e : ℕ → ι → SignedMeanGain.NativeIndex) (he : ∀ (n : ℕ), Set.InjOn (e n) ↑(a.labels n)) (hlabels : ∀ (n : ℕ), Finset.image (e n) (a.labels n) = B.labels n) (hp : ∀ (n : ℕ), ∀ l ∈ a.labels n, (f.primary l).velocity n = (B.primaryBlocks (e n l)).velocity n) (hcp : ∀ (n : ℕ), ∀ l ∈ a.labels n, BandReindexedSignedMeanGain.SameCarrierAt (f.primary l) (B.primaryBlocks (e n l)) n) (ht : ∀ (n : ℕ), ∀ l ∈ a.labels n, (f.tangent l).velocity n = (B.signedBlocks c (SignedMeanGain.waveStage G.gauge c u w₁ q₁ e₁) (e n l)).velocity n) (hct : ∀ (n : ℕ), ∀ l ∈ a.labels n, BandReindexedSignedMeanGain.SameCarrierAt (f.tangent l) (B.signedBlocks c (SignedMeanGain.waveStage G.gauge c u w₁ q₁ e₁) (e n l)) n) (r : CorrectionState.RankData PressureStream.Plane) (h : ℝ) (index : ℕ → ℕ) (axial : PressureStream.Plane × PressureStream.Plane) (hh : 0 ≤ h) (hscale : ∀ (n : ℕ), ChartScales.S n ≤ G.slow n) (gap : ℕ) (hgap : ∀ (n : ℕ), ChartScales.nativeIndex h n ≤ index n + gap) (hv : c.operators.vT = (0, 0, TorusInverse.vector TorusInverse.Direction.temporal)) (hfast : ∀ (n : ℕ), c.operators.fastCoefficient n = ChartScales.Tg ^ index n * ChartScales.Q n ^ (1 + h)) (hV : LocalRankDefect.IsSlowOn G.region.carrier c.base.angular) (hG : LocalRankDefect.IsSlowOn G.region.carrier c.base.axial) (hg : LocalRankDefect.RankGeometry G.gauge r G.region.carrier c (VariableGaugeMean.temporalStageState G.gauge h index axial c (SignedMeanGain.waveStage G.gauge c (SignedMeanGain.waveStage G.gauge c u w₁ q₁ e₁) (SignedMeanGain.tangentField f a + SignedMeanGain.curlField f a) q₂ e₂))) {A₀ B₀ : ℝ} (hparam : RankStateBounds.NormalizedParameters G.coord A₀ B₀ r G.region.carrier) (hB : B₀ ≠ 0) (hleft : G.patch.a < r.inner) (hright : r.outer < G.patch.b) : have t := VariableGaugeMean.temporalStageState G.gauge h index axial c (SignedMeanGain.waveStage G.gauge c (SignedMeanGain.waveStage G.gauge c u w₁ q₁ e₁) (SignedMeanGain.tangentField f a + SignedMeanGain.curlField f a) q₂ e₂); have v := VariableGaugeMean.rankStageState G.gauge r axial c t; MeanIncrementBounds.IncrementBounds G.strip (1 + σ - 2 * κ) (VariableGaugeMean.temporalIncrementState G.gauge h index axial c (SignedMeanGain.waveStage G.gauge c (SignedMeanGain.waveStage G.gauge c u w₁ q₁ e₁) (SignedMeanGain.tangentField f a + SignedMeanGain.curlField f a) q₂ e₂)) ∧ MeanIncrementBounds.IncrementBounds G.strip (1 + σ - 2 * κ) (VariableGaugeMean.rankIncrementState G.gauge r axial c t) ∧ WeightedClasses.MeanClass G.strip (1 + σ - 2 * κ) (v.pressure - u.pressure) ∧ CorrectionState.CumulativeBounds G.strip v ∧ CorrectionState.DefectBounds G.slowStrip (σ + 1 / 10) c v ∧ WeightedClasses.MeanClass G.strip (1 + (σ + 1 / 10)) (v.thetaResidual c) ∧ WeightedClasses.MeanClass G.strip (1 + (σ + 1 / 10)) (v.axialResidual c - fun (n : ℕ) (x : PressureStream.Lift SignedMeanGain.Plane) => VariableGaugeMean.temporalAliasState G.gauge h index c (SignedMeanGain.waveStage G.gauge c (SignedMeanGain.waveStage G.gauge c u w₁ q₁ e₁) (SignedMeanGain.tangentField f a + SignedMeanGain.curlField f a) q₂ e₂) n (x, 0) 2)

The two actual wave updates, temporal inverse, and rank solve form one mean/debt gain. All intermediate residual and flux regularity is derived from the original primitive fields and the actual covariance increments.

theorem NavierStokes.CorrectionStep.incrementBounds_updated {D : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] {s : WeightedClasses.StripData D} {H : ℝ} {a b : MeanIncrementBounds.Triple D} (ha : MeanIncrementBounds.IncrementBounds s H a) (hb : MeanIncrementBounds.IncrementBounds s H b) : MeanIncrementBounds.IncrementBounds s H (MeanIncrementBounds.updated a b)

theorem NavierStokes.CorrectionStep.updated_assoc {D : Type} (a b c : MeanIncrementBounds.Triple D) : MeanIncrementBounds.updated (MeanIncrementBounds.updated a b) c = MeanIncrementBounds.updated a (MeanIncrementBounds.updated b c)

theorem NavierStokes.CorrectionStep.CycleParameters.finalBlock_uniform_cumulative {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (primary : ι → CorrectionState.HarmonicBlock CyclePoint) {P : ι → ℕ → CyclePoint → ℝ} {σ κ : ℝ} (hσ : 1 / 5 ≤ σ) (hκsmall : κ ≤ 1 / 100000) (hold : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 / 2) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((v.blocks l).velocity n i).coeff j x) (hdiff : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (17 / 25) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((v.blocks l).velocity n i).coeff j x - ((primary l).velocity n i).coeff j x) (hpart : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 / 2 + σ) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((p.particularBlock v c u l).velocity n i).coeff j x) (hsigned : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 / 2 + σ - κ) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((p.signedBlock v c u l).velocity n i).coeff j x) : (∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 / 2) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((p.finalBlock v c u l).velocity n i).coeff j x) ∧ ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (17 / 25) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((p.finalBlock v c u l).velocity n i).coeff j x - ((primary l).velocity n i).coeff j x

The actual two wave increments retain the cumulative bound and the difference from the fixed primary family, with constants before labels.

theorem NavierStokes.CorrectionStep.CycleParameters.finalBlock_increment_bounds {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) {P : ι → ℕ → CyclePoint → ℝ} {σ κ : ℝ} (hκ : 0 ≤ κ) (hpart : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 / 2 + σ) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((p.particularBlock v c u l).velocity n i).coeff j x) (hsigned : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 / 2 + σ - κ) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((p.signedBlock v c u l).velocity n i).coeff j x) (hpp : ∀ (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 + σ) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((p.particularBlock v c u l).pressure n).coeff j x) (hsp : ∀ (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 + σ - κ) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((p.signedBlock v c u l).pressure n).coeff j x) : (∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 / 2 + σ - κ) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((p.finalBlock v c u l).velocity n i).coeff j x - ((v.blocks l).velocity n i).coeff j x) ∧ ∀ (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 + σ - κ) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((p.finalBlock v c u l).pressure n).coeff j x - ((v.blocks l).pressure n).coeff j x

theorem NavierStokes.CorrectionStep.CycleParameters.meanStages_residual_gain {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) {P : ι → ℕ → CyclePoint → ℝ} {σ κ : ℝ} (hκsmall : κ ≤ 1 / 100000) (ho : MeanIncrementBounds.OperatorBounds p.strip c.operators κ) (hR : ∀ x ∈ p.strip.domain, 0 < c.operators.radius x) (hb : MeanIncrementBounds.SmoothTriple p.strip.domain c.base) (hm : MeanIncrementBounds.SmoothTriple p.strip.domain u.mean) (hTemporal : MeanIncrementBounds.IncrementBounds p.strip (1 + σ - 2 * κ) (p.temporalIncrement v c u)) (hRank : MeanIncrementBounds.IncrementBounds p.strip (1 + σ - 2 * κ) (p.rankIncrement v c u)) (hvelocity : UniformHarmonicInteraction.UniformVelocity p.strip P (1 / 2) (p.finalBlock v c u)) {C : ℕ → ι → Set CyclePoint} (hNormal : ∀ (i : Fin 3), LocalizedWaveBounds.LocalUnweighted p.strip C 0 fun (n : ℕ) (l : ι) (x : CyclePoint) => (HarmonicMeanInteraction.slowNormal c ho hR (v.blocks l).phase n x).ofLp i) (hFreq : LocalizedWaveBounds.LocalUnweighted p.strip C (-(1 / 2)) fun (n : ℕ) (l : ι) (x : CyclePoint) => (v.blocks l).frequency n) (hAng : LocalizedWaveBounds.LocalUnweighted p.strip C (-(1 / 2)) fun (n : ℕ) (l : ι) (x : CyclePoint) => ↑((v.blocks l).angularFrequency n)) (hz : ∀ (n : ℕ) (l : ι), ∀ x ∈ p.strip.domain, x ∉ C n l → ∀ (i : Fin 3) (j : ℤ), j ≠ 0 → ((p.finalBlock v c u l).velocity n i).coeff j =ᶠ[nhds x] fun (x : CyclePoint) => 0) (hold : UniformHarmonicInteraction.UniformVelocity p.strip P (1 / 2 + σ + 1 / 10) fun (l : ι) => HarmonicResidual.residualBlock c (p.afterSigned v c u) (p.finalBlock v c u l) ((p.nextCoefficients v c u).gaussian l) (v.aliasCoefficients l)) : UniformHarmonicInteraction.UniformVelocity p.strip P (1 / 2 + (σ + 1 / 10)) fun (l : ι) => HarmonicResidual.residualBlock c (p.next v c u) ((p.nextCoefficients v c u).blocks l) ((p.nextCoefficients v c u).gaussian l) ((p.nextCoefficients v c u).aliasCoefficients l)

Apply the complete actual mean increment once to the stored harmonic residual. The pressure-alias refresh contributes only an angular zero mode.

def NavierStokes.CorrectionStep.OscillationPeriodic (U : Set PressureStream.Plane) (w : CorrectionState.Oscillation LocalSignedRequest.Point) : Prop

Whole-fiber periodicity of the actual real oscillation.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.OscillationPeriodic.add {U : Set PressureStream.Plane} {u w : CorrectionState.Oscillation LocalSignedRequest.Point} (hu : OscillationPeriodic U u) (hw : OscillationPeriodic U w) : OscillationPeriodic U (u + w)

theorem NavierStokes.CorrectionStep.OscillationPeriodic.bilinearCovariance {U : Set PressureStream.Plane} {u w : CorrectionState.Oscillation LocalSignedRequest.Point} (hu : OscillationPeriodic U u) (hw : OscillationPeriodic U w) (i j : Fin 3) : MeanStateRegularity.Periodic U (CorrectionState.bilinearCovariance u w i j)

theorem NavierStokes.CorrectionStep.OscillationPeriodic.covarianceIncrement {U : Set PressureStream.Plane} {u w : CorrectionState.Oscillation LocalSignedRequest.Point} (hu : OscillationPeriodic U u) (hw : OscillationPeriodic U w) (i j : Fin 3) : MeanStateRegularity.Periodic U (SignedMeanGain.covarianceIncrement u w i j)

theorem NavierStokes.CorrectionStep.covarianceIncrement_moving {coord a b : ℝ} (U : LocalSignedRequest.SlowRegion coord) {u w : CorrectionState.Oscillation LocalSignedRequest.Point} (hu : WaveStateRegularity.AngularSmooth (PhysicalMeanDomain.slowDomain U.carrier) u) (hw : WaveStateRegularity.AngularSmooth (PhysicalMeanDomain.slowDomain U.carrier) w) (hs : WaveStateRegularity.WaveSupport U a b w) (hup : OscillationPeriodic U.carrier u) (hwp : OscillationPeriodic U.carrier w) (i j : Fin 3) : GaugeMomentBalances.MovingField U a b (SignedMeanGain.covarianceIncrement u w i j)

theorem NavierStokes.CorrectionStep.symmetricCovariance_moving {coord a b : ℝ} (U : LocalSignedRequest.SlowRegion coord) {u w : CorrectionState.Oscillation LocalSignedRequest.Point} (hu : WaveStateRegularity.AngularSmooth (PhysicalMeanDomain.slowDomain U.carrier) u) (hw : WaveStateRegularity.AngularSmooth (PhysicalMeanDomain.slowDomain U.carrier) w) (hs : WaveStateRegularity.WaveSupport U a b w) (hup : OscillationPeriodic U.carrier u) (hwp : OscillationPeriodic U.carrier w) (i j : Fin 3) : GaugeMomentBalances.MovingField U a b (LabelSumBounds.symmetricCovariance u w i j)

theorem NavierStokes.CorrectionStep.block_zeroMode_pull {D E : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] [NormedAddCommGroup E] [NormedSpace ℝ E] (e : D ≃ₗᵢ[ℝ] E) (b : CorrectionState.HarmonicBlock E) (hb : HarmonicWaveInteraction.ZeroMode b) : HarmonicWaveInteraction.ZeroMode (StateReindex.block e b)

theorem NavierStokes.CorrectionStep.block_angularMean_zero {D : Type} (b : CorrectionState.HarmonicBlock D) (hb : HarmonicWaveInteraction.ZeroMode b) (hk : ∀ (n : ℕ), b.angularFrequency n ≠ 0) : angularMeanVector b.oscillation = 0

theorem NavierStokes.CorrectionStep.fieldSum_angularMean_zero {D ι : Type} (labels : ℕ → Finset ι) (b : ι → CorrectionState.HarmonicBlock D) (hb : ∀ (l : ι), HarmonicWaveInteraction.ZeroMode (b l)) (hk : ∀ (l : ι) (n : ℕ), (b l).angularFrequency n ≠ 0) : angularMeanVector (LabelSumBounds.fieldSum labels fun (l : ι) => (b l).oscillation) = 0

theorem NavierStokes.CorrectionStep.CycleParameters.particularBlock_zero {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (l : ι) : HarmonicWaveInteraction.ZeroMode (p.particularBlock v c u l)

theorem NavierStokes.CorrectionStep.CycleParameters.particularGaussianBlock_zero {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (l : ι) : HarmonicWaveInteraction.ZeroMode (p.particularGaussianBlock v c u l)

theorem NavierStokes.CorrectionStep.CycleParameters.signedGaussianBlock_zero {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (l : ι) : HarmonicWaveInteraction.ZeroMode (p.signedGaussianBlock v c u l)

theorem NavierStokes.CorrectionStep.CycleParameters.gaussianIncrement_angularMeans {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (hk : ∀ (l : ι) (n : ℕ), (v.blocks l).angularFrequency n ≠ 0) (hc : ∀ (l : ι), SameCarrier (v.blocks l) (p.signedBlock v c u l)) : angularMeanVector (p.particularGaussian v c u) = 0 ∧ angularMeanVector (p.signedGaussian v c u) = 0

theorem NavierStokes.CorrectionStep.CycleParameters.gaussianIncrement_angularContinuous {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : AngularContinuous (p.particularGaussian v c u) ∧ AngularContinuous (p.signedGaussian v c u)

theorem NavierStokes.CorrectionStep.CycleParameters.next_gaussian_angularMean {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (hk : ∀ (l : ι) (n : ℕ), (v.blocks l).angularFrequency n ≠ 0) (hc : ∀ (l : ι), SameCarrier (v.blocks l) (p.signedBlock v c u l)) (hu : AngularContinuous u.errors.gaussian) : angularMeanVector (p.next v c u).errors.gaussian = angularMeanVector u.errors.gaussian

theorem NavierStokes.CorrectionStep.CycleParameters.next_alias_lift {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : (p.next v c u).errors.aliasError = u.errors.aliasError + fun (n : ℕ) (x : CyclePoint × ℝ) => p.nextAxisymmetricAlias v c u 0 n x.1

theorem NavierStokes.CorrectionStep.CycleParameters.next_alias_angularContinuous {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (hu : AngularContinuous u.errors.aliasError) : AngularContinuous (p.next v c u).errors.aliasError

theorem NavierStokes.CorrectionStep.CycleParameters.next_alias_angularMean {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (hu : AngularContinuous u.errors.aliasError) : angularMeanVector (p.next v c u).errors.aliasError = angularMeanVector u.errors.aliasError + p.nextAxisymmetricAlias v c u 0

theorem NavierStokes.CorrectionStep.CycleParameters.nextAliasIncrement_angular {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (n : ℕ) (x : CyclePoint) : p.nextAxisymmetricAlias v c u 0 n x 1 = 0

theorem NavierStokes.CorrectionStep.CycleParameters.nextAliasIncrement_axial {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (n : ℕ) (x : CyclePoint) : p.nextAxisymmetricAlias v c u 0 n x 2 = VariableGaugeMean.temporalAliasState p.gauge p.timeExponent p.commonIndex c (p.afterSigned v c u) n (x, 0) 2

theorem NavierStokes.CorrectionStep.CycleParameters.next_meanResidualBounds {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) {σ : ℝ} (hk : ∀ (l : ι) (n : ℕ), (v.blocks l).angularFrequency n ≠ 0) (hc : ∀ (l : ι), SameCarrier (v.blocks l) (p.signedBlock v c u l)) (hb : ∀ (n : ℕ), ∀ x ∈ p.strip.domain, ∀ (i : Fin 3), Continuous fun (θ : ℝ) => u.errors.base n (x, θ) i) (hg : AngularContinuous u.errors.gaussian) (ha : AngularContinuous u.errors.aliasError) (hθ : WeightedClasses.MeanClass p.strip (1 + σ) ((p.next v c u).thetaResidual c)) (hz : WeightedClasses.MeanClass p.strip (1 + σ) ((p.next v c u).axialResidual c - fun (n : ℕ) (x : PressureStream.Lift PressureStream.Plane) => VariableGaugeMean.temporalAliasState p.gauge p.timeExponent p.commonIndex c (p.afterSigned v c u) n (x, 0) 2)) (hgθ : WeightedClasses.MeanClass p.strip (1 + σ) fun (n : ℕ) (x : CyclePoint) => angularMeanVector u.errors.gaussian n x 1) (hgz : WeightedClasses.MeanClass p.strip (1 + σ) fun (n : ℕ) (x : CyclePoint) => angularMeanVector u.errors.gaussian n x 2) (haθ : WeightedClasses.MeanClass p.strip (1 + σ) fun (n : ℕ) (x : CyclePoint) => angularMeanVector u.errors.aliasError n x 1) (haz : WeightedClasses.MeanClass p.strip (1 + σ) fun (n : ℕ) (x : CyclePoint) => angularMeanVector u.errors.aliasError n x 2) : CorrectionState.MeanResidualBounds p.strip σ c (p.next v c u)

The actual good mean residual gains the requested exponent. New Gaussian means vanish exactly, and the new temporal alias is the same one retained by the mean-stage calculation.

noncomputable def NavierStokes.CorrectionStep.CycleParameters.ofGeometry {ι : Type} (G : SignedMeanGain.Geometry) (h : ℝ) (index : ℕ → ℕ) (axial : PressureStream.Plane × PressureStream.Plane) (particular : ι → ParticularParameters CycleSlow) (signed : ι → PeriodizedSignedParameters CyclePoint TorusInverse.Frequency) (rank : CorrectionState.RankData PressureStream.Plane) : CycleParameters ι

One geometric choice is shared by all four literal stages.

Equations

• One or more equations did not get rendered due to their size.

theorem NavierStokes.CorrectionStep.CycleParameters.mean_gain_from_waves {ι : Type} (G : SignedMeanGain.Geometry) (B : SignedMeanGain.NativeData G) (h : ℝ) (index : ℕ → ℕ) (axial : PressureStream.Plane × PressureStream.Plane) (particular : ι → ParticularParameters CycleSlow) (signed : ι → PeriodizedSignedParameters CyclePoint TorusInverse.Frequency) (r : CorrectionState.RankData PressureStream.Plane) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (primary : ι → CorrectionState.HarmonicBlock CyclePoint) (P : ι → ℕ → CyclePoint → ℝ) {σ κ : ℝ} (hσ : 1 / 5 ≤ σ) (N : ℕ) (hprimary : ∀ (l : ι), (primary l).BandLimited N) (hband : CoefficientBands v) (hcp : ∀ (l : ι), SameCarrier (v.blocks l) (primary l)) (hcs : ∀ (l : ι), SameCarrier (v.blocks l) ((ofGeometry G h index axial particular signed r).signedBlock v c u l)) (hold : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass G.strip P (1 / 2) fun (l : ι) (n : ℕ) (x : SignedMeanGain.Point) => ((v.blocks l).velocity n i).coeff j x) (hdiff : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass G.strip P (17 / 25) fun (l : ι) (n : ℕ) (x : SignedMeanGain.Point) => ((v.blocks l).velocity n i).coeff j x - ((primary l).velocity n i).coeff j x) (hpart : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass G.strip P (1 / 2 + σ) fun (l : ι) (n : ℕ) (x : SignedMeanGain.Point) => (((ofGeometry G h index axial particular signed r).particularBlock v c u l).velocity n i).coeff j x) (htangent : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass G.strip P (1 / 2 + σ - κ) fun (l : ι) (n : ℕ) (x : SignedMeanGain.Point) => (((ofGeometry G h index axial particular signed r).signedTangent v c u l).velocity n i).coeff j x) (hcurl : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass G.strip P (1 + σ - 2 * κ) fun (l : ι) (n : ℕ) (x : SignedMeanGain.Point) => (((ofGeometry G h index axial particular signed r).signedCurl v c u l).velocity n i).coeff j x) (hP0 : ∀ (l : ι) (n : ℕ), ∀ x ∈ G.strip.domain, 0 ≤ P l n x) (hP1 : ∀ (l : ι) (n : ℕ), ∀ x ∈ G.strip.domain, P l n x ≤ 1) (hkp : ∀ (l : ι) (n : ℕ), (v.blocks l).angularFrequency n ≠ 0) (a : SignedMeanGain.Assembly ((ofGeometry G h index axial particular signed r).signedFamily v c u primary P hσ N hprimary hband hcp hcs hold hdiff hpart htangent hcurl hP0 hP1 hkp)) (halabels : a.labels = v.labels) {axis : AxisymmetricAlias} (hrep : CycleRepresentation v u axis) (hzero : ∀ (l : ι), HarmonicWaveInteraction.ZeroMode (v.blocks l)) (hpartzero : ∀ (l : ι), HarmonicWaveInteraction.ZeroMode ((ofGeometry G h index axial particular signed r).particularBlock v c u l)) (hsold : LabelSumBounds.SupportedOscillations a.slots a.label a.window a.auxiliary G.strip.domain fun (l : ι) => (v.blocks l).oscillation) (hspart : LabelSumBounds.SupportedOscillations a.slots a.label a.window a.auxiliary G.strip.domain fun (l : ι) => ((ofGeometry G h index axial particular signed r).particularBlock v c u l).oscillation) (hκ : 0 ≤ κ) (hκsmall : κ ≤ 1 / 100000) (H : MeanStateRegularity.PrimitiveData G.region G.patch.a G.patch.b c u) (hop : c.operators = G.operators) (ho : MeanIncrementBounds.OperatorBounds G.strip G.operators κ) (hb : MeanIncrementBounds.BaseBounds G.strip c.base) (hu : CorrectionState.CumulativeBounds G.strip u) (hfixed : (VariableGaugeMean.reconstructState G.gauge c u).pressure = u.pressure) (hmθ : ∀ (n : ℕ), ∀ z ∈ G.region.carrier, CorrectionState.radialMoment 2 u.mean.angular n z = 0) (hmz : ∀ (n : ℕ), ∀ z ∈ G.region.carrier, CorrectionState.radialMoment 1 u.mean.axial n z = 0) (hθ : WeightedClasses.MeanClass G.strip (1 + σ) (u.thetaResidual c)) (hz : WeightedClasses.MeanClass G.strip (1 + σ) (u.axialResidual c)) (hd : CorrectionState.DefectBounds G.slowStrip σ c u) (hX₁ : ∀ (i j : Fin 3), GaugeMomentBalances.MovingField G.region G.patch.a G.patch.b (SignedMeanGain.covarianceIncrement u.oscillation ((ofGeometry G h index axial particular signed r).particularVelocity v c u) i j)) (hX₂ : ∀ (i j : Fin 3), SignedMeanGain.MovingField G (SignedMeanGain.incrementTensor ((ofGeometry G h index axial particular signed r).signedFamily v c u primary P hσ N hprimary hband hcp hcs hold hdiff hpart htangent hcurl hP0 hP1 hkp) a i j)) (hS : ∀ (i j : Fin 3), SignedMeanGain.MovingField G (SignedMeanGain.crossTensor ((ofGeometry G h index axial particular signed r).signedFamily v c u primary P hσ N hprimary hband hcp hcs hold hdiff hpart htangent hcurl hP0 hP1 hkp) a i j)) (e : ℕ → ι → SignedMeanGain.NativeIndex) (he : ∀ (n : ℕ), Set.InjOn (e n) ↑(v.labels n)) (hlabels : ∀ (n : ℕ), Finset.image (e n) (v.labels n) = B.labels n) (hp : ∀ (n : ℕ), ∀ l ∈ v.labels n, (primary l).velocity n = (B.primaryBlocks (e n l)).velocity n) (hpc : ∀ (n : ℕ), ∀ l ∈ v.labels n, BandReindexedSignedMeanGain.SameCarrierAt (primary l) (B.primaryBlocks (e n l)) n) (ht : ∀ (n : ℕ), ∀ l ∈ v.labels n, ((ofGeometry G h index axial particular signed r).signedTangent v c u l).velocity n = (B.signedBlocks c ((ofGeometry G h index axial particular signed r).afterParticular v c u) (e n l)).velocity n) (htc : ∀ (n : ℕ), ∀ l ∈ v.labels n, BandReindexedSignedMeanGain.SameCarrierAt ((ofGeometry G h index axial particular signed r).signedTangent v c u l) (B.signedBlocks c ((ofGeometry G h index axial particular signed r).afterParticular v c u) (e n l)) n) (hh : 0 ≤ h) (hscale : ∀ (n : ℕ), ChartScales.S n ≤ G.slow n) (gap : ℕ) (hgap : ∀ (n : ℕ), ChartScales.nativeIndex h n ≤ index n + gap) (hv : c.operators.vT = (0, 0, TorusInverse.vector TorusInverse.Direction.temporal)) (hfast : ∀ (n : ℕ), c.operators.fastCoefficient n = ChartScales.Tg ^ index n * ChartScales.Q n ^ (1 + h)) (hV : LocalRankDefect.IsSlowOn G.region.carrier c.base.angular) (hG : LocalRankDefect.IsSlowOn G.region.carrier c.base.axial) (hg : LocalRankDefect.RankGeometry G.gauge r G.region.carrier c ((ofGeometry G h index axial particular signed r).afterTemporal v c u)) {A₀ B₀ : ℝ} (hparam : RankStateBounds.NormalizedParameters G.coord A₀ B₀ r G.region.carrier) (hB : B₀ ≠ 0) (hleft : G.patch.a < r.inner) (hright : r.outer < G.patch.b) : MeanIncrementBounds.IncrementBounds G.strip (1 + σ - 2 * κ) ((ofGeometry G h index axial particular signed r).temporalIncrement v c u) ∧ MeanIncrementBounds.IncrementBounds G.strip (1 + σ - 2 * κ) ((ofGeometry G h index axial particular signed r).rankIncrement v c u) ∧ WeightedClasses.MeanClass G.strip (1 + σ - 2 * κ) (((ofGeometry G h index axial particular signed r).next v c u).pressure - u.pressure) ∧ CorrectionState.CumulativeBounds G.strip ((ofGeometry G h index axial particular signed r).next v c u) ∧ CorrectionState.DefectBounds G.slowStrip (σ + 1 / 10) c ((ofGeometry G h index axial particular signed r).next v c u) ∧ WeightedClasses.MeanClass G.strip (1 + (σ + 1 / 10)) (((ofGeometry G h index axial particular signed r).next v c u).thetaResidual c) ∧ WeightedClasses.MeanClass G.strip (1 + (σ + 1 / 10)) (((ofGeometry G h index axial particular signed r).next v c u).axialResidual c - fun (n : ℕ) (x : PressureStream.Lift SignedMeanGain.Plane) => VariableGaugeMean.temporalAliasState G.gauge h index c ((ofGeometry G h index axial particular signed r).afterSigned v c u) n (x, 0) 2)

The complete measured-mean gain for next. The signed family is computed from this cycle's actual particular, tangent, and curl blocks; its first covariance estimate is derived from the same finite labels.

theorem NavierStokes.CorrectionStep.CycleParameters.next_primitive {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) {coord : ℝ} (U : LocalSignedRequest.SlowRegion coord) (ha : 0 < p.gauge.radial.inner) (hd : 0 < p.gauge.radial.exponent) (hell : ∀ (n : ℕ), p.gauge.length n = VariableGaugeMean.qLength coord) (H : MeanStateRegularity.PrimitiveData U p.gauge.radial.inner p.gauge.radial.outer c u) (hX₁ : ∀ (i j : Fin 3), GaugeMomentBalances.MovingField U p.gauge.radial.inner p.gauge.radial.outer (SignedMeanGain.covarianceIncrement u.oscillation (p.particularVelocity v c u) i j)) (hX₂ : ∀ (i j : Fin 3), GaugeMomentBalances.MovingField U p.gauge.radial.inner p.gauge.radial.outer (SignedMeanGain.covarianceIncrement (p.afterParticular v c u).oscillation (p.signedVelocity v c u) i j)) (hg : LocalRankDefect.RankGeometry p.gauge p.rank U.carrier c u) : MeanStateRegularity.PrimitiveData U p.gauge.radial.inner p.gauge.radial.outer c (p.next v c u) ∧ VariableGaugeMean.reconstructState p.gauge c (p.next v c u) = p.next v c u

Primitive regularity is propagated through the literal four-stage state. The rank geometry is reused from the incoming state; its new measured-debt smoothness is proved from the updated primitive fields.

theorem NavierStokes.CorrectionStep.CycleParameters.next_zeroMassesOn {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) {coord : ℝ} (U : LocalSignedRequest.SlowRegion coord) (ha : 0 < p.gauge.radial.inner) (hd : 0 < p.gauge.radial.exponent) (hell : ∀ (n : ℕ), p.gauge.length n = VariableGaugeMean.qLength coord) (H : MeanStateRegularity.PrimitiveData U p.gauge.radial.inner p.gauge.radial.outer c u) (hX₁ : ∀ (i j : Fin 3), GaugeMomentBalances.MovingField U p.gauge.radial.inner p.gauge.radial.outer (SignedMeanGain.covarianceIncrement u.oscillation (p.particularVelocity v c u) i j)) (hX₂ : ∀ (i j : Fin 3), GaugeMomentBalances.MovingField U p.gauge.radial.inner p.gauge.radial.outer (SignedMeanGain.covarianceIncrement (p.afterParticular v c u).oscillation (p.signedVelocity v c u) i j)) (hg : LocalRankDefect.RankGeometry p.gauge p.rank U.carrier c u) (hlength : ∀ (n : ℕ), ∀ x ∈ U.carrier, p.rank.length n x = VariableGaugeMean.qLength coord x) (hleft : p.gauge.radial.inner ≤ p.rank.inner) (hright : p.rank.outer ≤ p.gauge.radial.outer) (hm : GaugeMassPreservation.ZeroMassesOn U.carrier u) : GaugeMassPreservation.ZeroMassesOn U.carrier (p.next v c u)

theorem NavierStokes.CorrectionStep.reindex_addBlock {D E : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] [NormedAddCommGroup E] [NormedSpace ℝ E] (e : D ≃ₗᵢ[ℝ] E) (a b : CorrectionState.HarmonicBlock E) : StateReindex.block e (HarmonicWaveInteraction.addBlock a b) = HarmonicWaveInteraction.addBlock (StateReindex.block e a) (StateReindex.block e b)

theorem NavierStokes.CorrectionStep.reindex_coefficients_add {D E : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] [NormedAddCommGroup E] [NormedSpace ℝ E] (e : D ≃ₗᵢ[ℝ] E) (G A : HarmonicResidual.BlockCoefficients E) : StateReindex.blockCoefficients e (G + A) = StateReindex.blockCoefficients e G + StateReindex.blockCoefficients e A

theorem NavierStokes.CorrectionStep.reindex_coefficients_roundtrip {D E : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] [NormedAddCommGroup E] [NormedSpace ℝ E] (e : D ≃ₗᵢ[ℝ] E) (G : HarmonicResidual.BlockCoefficients D) : StateReindex.blockCoefficients e (StateReindex.blockCoefficients e.symm G) = G

theorem NavierStokes.CorrectionStep.residual_update_return {D E : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] [NormedAddCommGroup E] [NormedSpace ℝ E] (e : D ≃ₗᵢ[ℝ] E) (c : CorrectionState.Context D) (u : CorrectionState.State D) (a : CorrectionState.HarmonicBlock D) (b : CorrectionState.HarmonicBlock E) (G A : HarmonicResidual.BlockCoefficients D) (g : HarmonicResidual.BlockCoefficients E) : StateReindex.block e (HarmonicResidual.residualBlock (StateReindex.context e.symm c) (StateReindex.state e.symm u) (HarmonicWaveInteraction.addBlock (StateReindex.block e.symm a) b) (StateReindex.blockCoefficients e.symm G + g) (StateReindex.blockCoefficients e.symm A)) = HarmonicResidual.residualBlock c u (HarmonicWaveInteraction.addBlock a (StateReindex.block e b)) (G + StateReindex.blockCoefficients e g) A

Returning the actual mixed old/new block and its new Gaussian term commutes with the entire nonlinear residual, including all derivatives.

theorem NavierStokes.CorrectionStep.residual_update_uniform_return {D E : Type} [NormedAddCommGroup D] [NormedSpace ℝ D] [NormedAddCommGroup E] [NormedSpace ℝ E] {ι : Type} (e : D ≃ₗᵢ[ℝ] E) {s : WeightedClasses.StripData D} {P : ι → ℕ → D → ℝ} {α : ℝ} (c : CorrectionState.Context D) (u : CorrectionState.State D) (a : ι → CorrectionState.HarmonicBlock D) (b : ι → CorrectionState.HarmonicBlock E) (G A : ι → HarmonicResidual.BlockCoefficients D) (g : ι → HarmonicResidual.BlockCoefficients E) (hh : UniformHarmonicInteraction.UniformVelocity (ParticularWaveBounds.reindexStrip e.symm s) (fun (l : ι) (n : ℕ) (x : E) => P l n (e.symm x)) α fun (l : ι) => HarmonicResidual.residualBlock (StateReindex.context e.symm c) (StateReindex.state e.symm u) (HarmonicWaveInteraction.addBlock (StateReindex.block e.symm (a l)) (b l)) (StateReindex.blockCoefficients e.symm (G l) + g l) (StateReindex.blockCoefficients e.symm (A l))) : UniformHarmonicInteraction.UniformVelocity s P α fun (l : ι) => HarmonicResidual.residualBlock c u (HarmonicWaveInteraction.addBlock (a l) (StateReindex.block e (b l))) (G l + StateReindex.blockCoefficients e (g l)) (A l)

theorem NavierStokes.CorrectionStep.CycleRepresentation.withAxis {ι : Type} {v : CycleCoefficients ι} {u : CorrectionState.State CyclePoint} {axis : AxisymmetricAlias} (h : CycleRepresentation v u axis) : AxisymmetricResidualGrouping.Representation v.labels v.blocks v.gaussian v.aliasCoefficients u axis

theorem NavierStokes.CorrectionStep.CycleRepresentation.fullGoodWaveResidual_grouped {ι : Type} {v : CycleCoefficients ι} {u : CorrectionState.State CyclePoint} {axis : AxisymmetricAlias} (h : CycleRepresentation v u axis) {U : Set CyclePoint} (hU : IsOpen U) {c : CorrectionState.Context CyclePoint} {n : ℕ} (hr : HarmonicResidual.ExtractionRegular U c u v.labels v.blocks v.gaussian v.aliasCoefficients n) {x : CyclePoint × ℝ} (hx : x ∈ HarmonicResidual.liftDomain U) (i : Fin 3) : fullGoodWaveResidual c u n x i = ∑ l ∈ v.labels n, (HarmonicResidual.residualBlock c u (v.blocks l) (v.gaussian l) (v.aliasCoefficients l)).oscillation n x i

theorem NavierStokes.CorrectionStep.CycleRepresentation.fullResidual_reconstructed {ι : Type} {v : CycleCoefficients ι} {u : CorrectionState.State CyclePoint} {axis : AxisymmetricAlias} (h : CycleRepresentation v u axis) {U : Set CyclePoint} (hU : IsOpen U) {c : CorrectionState.Context CyclePoint} {n : ℕ} (hr : HarmonicResidual.ExtractionRegular U c u v.labels v.blocks v.gaussian v.aliasCoefficients n) {x : CyclePoint × ℝ} (hx : x ∈ HarmonicResidual.liftDomain U) (i : Fin 3) : fullResidual c u n x i = ∑ l ∈ v.labels n, (HarmonicResidual.residualBlock c u (v.blocks l) (v.gaussian l) (v.aliasCoefficients l)).oscillation n x i + (HarmonicResidual.stateMeanCoefficientValue v.labels v.blocks v.gaussian v.aliasCoefficients c u n x.1 i - axis n x.1 i) + u.errors.total n x i

theorem NavierStokes.CorrectionStep.CycleRepresentation.fullGoodWaveResidual_grouped_local {ι : Type} {v : CycleCoefficients ι} {u : CorrectionState.State CyclePoint} {axis : AxisymmetricAlias} (h : CycleRepresentation v u axis) {U : Set CyclePoint} (hU : IsOpen U) {c : CorrectionState.Context CyclePoint} {n : ℕ} (hr : LocalResidualGrouping.ExtractionRegular U c u v.labels v.blocks v.gaussian v.aliasCoefficients n) {x : CyclePoint × ℝ} (hx : x ∈ HarmonicResidual.liftDomain U) (i : Fin 3) : fullGoodWaveResidual c u n x i = ∑ l ∈ v.labels n, (HarmonicResidual.residualBlock c u (v.blocks l) (v.gaussian l) (v.aliasCoefficients l)).oscillation n x i

theorem NavierStokes.CorrectionStep.CycleRepresentation.fullResidual_reconstructed_local {ι : Type} {v : CycleCoefficients ι} {u : CorrectionState.State CyclePoint} {axis : AxisymmetricAlias} (h : CycleRepresentation v u axis) {U : Set CyclePoint} (hU : IsOpen U) {c : CorrectionState.Context CyclePoint} {n : ℕ} (hr : LocalResidualGrouping.ExtractionRegular U c u v.labels v.blocks v.gaussian v.aliasCoefficients n) {x : CyclePoint × ℝ} (hx : x ∈ HarmonicResidual.liftDomain U) (i : Fin 3) : fullResidual c u n x i = ∑ l ∈ v.labels n, (HarmonicResidual.residualBlock c u (v.blocks l) (v.gaussian l) (v.aliasCoefficients l)).oscillation n x i + (HarmonicResidual.stateMeanCoefficientValue v.labels v.blocks v.gaussian v.aliasCoefficients c u n x.1 i - axis n x.1 i) + u.errors.total n x i

structure NavierStokes.CorrectionStep.CycleRealCoefficients {ι : Type} (v : CycleCoefficients ι) : Prop

The stored coefficients themselves represent real fields. Retaining this algebraic invariant lets support of the real projection control the same coefficients used in the differentiated interaction estimates.

• velocity (l : ι) (n : ℕ) (i : Fin 3) : HarmonicFields.ConjugateSymmetric ((v.blocks l).velocity n i)
• pressure (l : ι) (n : ℕ) : HarmonicFields.ConjugateSymmetric ((v.blocks l).pressure n)
• gaussian (l : ι) (n : ℕ) (i : Fin 3) : HarmonicFields.ConjugateSymmetric (v.gaussian l n i)

theorem NavierStokes.CorrectionStep.CycleParameters.particularBlock_real {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (l : ι) : ErrorHarmonics.RealBlock (p.particularBlock v c u l)

theorem NavierStokes.CorrectionStep.CycleParameters.signedBlock_real {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (l : ι) : ErrorHarmonics.RealBlock (p.signedBlock v c u l)

theorem NavierStokes.CorrectionStep.CycleParameters.next_realCoefficients {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (h : CycleRealCoefficients v) : CycleRealCoefficients (p.nextCoefficients v c u)

theorem NavierStokes.CorrectionStep.block_velocity_zero_germ_of_inputSupport {U : Set CyclePoint} {S : ℕ → Set CyclePoint} (hU : IsOpen U) (hS : ∀ (n : ℕ), IsClosed (S n)) {b : CorrectionState.HarmonicBlock CyclePoint} {G A : HarmonicResidual.BlockCoefficients CyclePoint} (hs : HarmonicSourceSupport.InputSupportOn U S b G A) (hr : ∀ (n : ℕ) (i : Fin 3), HarmonicFields.ConjugateSymmetric (b.velocity n i)) (n : ℕ) {x : CyclePoint} (hx : x ∈ U) (hn : x ∉ S n) (i : Fin 3) (j : ℤ) (hj : j ≠ 0) : (b.velocity n i).coeff j =ᶠ[nhds x] fun (x : CyclePoint) => 0

theorem NavierStokes.CorrectionStep.velocity_zero_germ_of_inputSupport {ι : Type} {v : CycleCoefficients ι} {U : Set CyclePoint} {S : ι → ℕ → Set CyclePoint} (hU : IsOpen U) (hS : ∀ (l : ι) (n : ℕ), IsClosed (S l n)) (hs : ∀ (l : ι), HarmonicSourceSupport.InputSupportOn U (S l) (v.blocks l) (v.gaussian l) (v.aliasCoefficients l)) (hr : CycleRealCoefficients v) (l : ι) (n : ℕ) {x : CyclePoint} (hx : x ∈ U) (hn : x ∉ S l n) (i : Fin 3) (j : ℤ) (hj : j ≠ 0) : ((v.blocks l).velocity n i).coeff j =ᶠ[nhds x] fun (x : CyclePoint) => 0

The genuine input support controls raw nonzero coefficient germs because their real-projection identity is retained.

theorem NavierStokes.CorrectionStep.CycleRepresentation.alias_eq_lift {ι : Type} {v : CycleCoefficients ι} {u : CorrectionState.State CyclePoint} {axis : AxisymmetricAlias} (h : CycleRepresentation v u axis) (hz : ∀ (l : ι), v.aliasCoefficients l = 0) : u.errors.aliasError = fun (n : ℕ) (x : CyclePoint × ℝ) => axis n x.1

theorem NavierStokes.CorrectionStep.CycleRepresentation.gaussian_angularContinuous {ι : Type} {v : CycleCoefficients ι} {u : CorrectionState.State CyclePoint} {axis : AxisymmetricAlias} (h : CycleRepresentation v u axis) : AngularContinuous u.errors.gaussian

structure NavierStokes.CorrectionStep.CycleAnalyticInvariant {ι : Type} (G : SignedMeanGain.Geometry) (c : CorrectionState.Context CyclePoint) (primary : ι → CorrectionState.HarmonicBlock CyclePoint) (P : ι → ℕ → CyclePoint → ℝ) (labelCarrier : ι → ℕ → Set CyclePoint) (σ : ℝ) (x : CycleState ι) : Prop

The quantitative and local regularity invariant is stated on the actual stored fields of CycleState, including the independent alias. Its definition makes no assertion that an arbitrary step preserves it.

• representation : CycleRepresentation x.coefficients x.state x.axisymmetricAlias
• bands : CoefficientBands x.coefficients
• realCoefficients : CycleRealCoefficients x.coefficients
• inputSupport (l : ι) : HarmonicSourceSupport.InputSupportOn G.domain (labelCarrier l) (x.coefficients.blocks l) (x.coefficients.gaussian l) (x.coefficients.aliasCoefficients l)
• sourceBand (l : ι) : (HarmonicResidual.residualBlock c x.state (x.coefficients.blocks l) (x.coefficients.gaussian l) (x.coefficients.aliasCoefficients l)).BandLimited x.coefficients.residualBand
• zeroVelocity (l : ι) : HarmonicWaveInteraction.ZeroMode (x.coefficients.blocks l)
• zeroPressure (l : ι) (n : ℕ) : ((x.coefficients.blocks l).pressure n).coeff 0 = 0
• carrier (l : ι) : SameCarrier (x.coefficients.blocks l) (primary l)
• phase (l : ι) (n : ℕ) : ContDiffOn ℝ (↑⊤) ((x.coefficients.blocks l).phase n) G.strip.domain
• frequency (l : ι) (n : ℕ) : (x.coefficients.blocks l).frequency n ≠ 0
• angular (l : ι) (n : ℕ) : (x.coefficients.blocks l).angularFrequency n ≠ 0
• coefficientSmooth (l : ι) (n : ℕ) (i : Fin 3) : HarmonicResidual.SmoothCoefficients G.domain ((x.coefficients.blocks l).velocity n i)
• pressureCoefficientSmooth (l : ι) (n : ℕ) : HarmonicResidual.SmoothCoefficients G.domain ((x.coefficients.blocks l).pressure n)
• gaussianCoefficientSmooth (l : ι) (n : ℕ) (i : Fin 3) : HarmonicResidual.SmoothCoefficients G.domain (x.coefficients.gaussian l n i)
• solenoidal (l : ι) : HarmonicWaveInteraction.ModeSolenoidal G.strip c (x.coefficients.blocks l)
• wave (i : Fin 3) (j : ℤ) : LabelSumBounds.UniformWaveClass G.strip P (1 / 2) fun (l : ι) (n : ℕ) (z : SignedMeanGain.Point) => ((x.coefficients.blocks l).velocity n i).coeff j z
• pressure (j : ℤ) : LabelSumBounds.UniformWaveClass G.strip P 1 fun (l : ι) (n : ℕ) (z : SignedMeanGain.Point) => ((x.coefficients.blocks l).pressure n).coeff j z
• difference (i : Fin 3) (j : ℤ) : LabelSumBounds.UniformWaveClass G.strip P (17 / 25) fun (l : ι) (n : ℕ) (z : SignedMeanGain.Point) => ((x.coefficients.blocks l).velocity n i).coeff j z - ((primary l).velocity n i).coeff j z
• cumulative : CorrectionState.CumulativeBounds G.strip x.state
• covariance (i j : Fin 3) : WeightedClasses.MeanClass G.strip 1 (x.state.covariance i j)
• residual : UniformHarmonicInteraction.UniformVelocity G.strip P (1 / 2 + σ) fun (l : ι) => HarmonicResidual.residualBlock c x.state (x.coefficients.blocks l) (x.coefficients.gaussian l) (x.coefficients.aliasCoefficients l)
• mean : CorrectionState.MeanResidualBounds G.strip σ c x.state
• meanHypotheses : LiftedMeanResidual.MeanHypotheses G.strip.domain c x.state
• debt : CorrectionState.DefectBounds G.slowStrip σ c x.state
• primitives : MeanStateRegularity.PrimitiveData G.region G.patch.a G.patch.b c x.state
• reconstructed : VariableGaugeMean.reconstructState G.gauge c x.state = x.state
• masses : GaugeMassPreservation.ZeroMassesOn G.region.carrier x.state
• oscillationSmooth : WaveStateRegularity.AngularSmooth G.domain x.state.oscillation
• oscillatoryPressureSmooth (n : ℕ) : ContDiffOn ℝ (↑⊤) (x.state.oscillatoryPressure n) (G.domain ×ˢ Set.univ)
• oscillationPeriodic : OscillationPeriodic G.region.carrier x.state.oscillation
• oscillationSupport : WaveStateRegularity.WaveSupport G.region G.patch.a G.patch.b x.state.oscillation
• gaussianFlat (β : ℝ) (i : Fin 3) (j : ℤ) : LabelSumBounds.UniformClass G.strip (fun (x : ι) (x_1 : ℕ) (z : SignedMeanGain.Point) => √(G.strip.zeta z)) β fun (l : ι) (n : ℕ) (z : SignedMeanGain.Point) => (x.coefficients.gaussian l n i).coeff j z
• gaussianMean : angularMeanVector x.state.errors.gaussian = 0
• aliasCoefficients (l : ι) : x.coefficients.aliasCoefficients l = 0
• axisFlat (β : ℝ) : WeightedClasses.MeanClass G.strip β x.axisymmetricAlias
• baseAngular (n : ℕ) (z : SignedMeanGain.Point) : z ∈ G.domain → ∀ (i : Fin 3), Continuous fun (θ : ℝ) => x.state.errors.base n (z, θ) i

theorem NavierStokes.CorrectionStep.CycleAnalyticInvariant.raw_mean_bounds {ι : Type} {G : SignedMeanGain.Geometry} {c : CorrectionState.Context CyclePoint} {primary : ι → CorrectionState.HarmonicBlock CyclePoint} {P : ι → ℕ → CyclePoint → ℝ} {labelCarrier : ι → ℕ → Set CyclePoint} {σ : ℝ} {x : CycleState ι} (H : CycleAnalyticInvariant G c primary P labelCarrier σ x) : WeightedClasses.MeanClass G.strip (1 + σ) (x.state.thetaResidual c) ∧ WeightedClasses.MeanClass G.strip (1 + σ) (x.state.axialResidual c)

Raw residual classes required by the next signed request are derived from the good-mean invariant and the actual all-power axis alias.

theorem NavierStokes.CorrectionStep.CycleParameters.waveStages_residual_gain {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) {P : ι → ℕ → CyclePoint → ℝ} {σ κ : ℝ} (hσ : 1 / 5 ≤ σ) (hκsmall : κ ≤ 1 / 100000) (ho : MeanIncrementBounds.OperatorBounds p.strip c.operators κ) (hR : ∀ x ∈ p.strip.domain, 0 < c.operators.radius x) (hbase : MeanIncrementBounds.BaseBounds p.strip c.base) (hu : MeanIncrementBounds.CumulativeBounds p.strip u.mean) (hc : ∀ (l : ι), SameCarrier (v.blocks l) (p.signedBlock v c u l)) (hold : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 / 2) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((v.blocks l).velocity n i).coeff j x) (hpart : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 / 2 + σ) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((p.particularBlock v c u l).velocity n i).coeff j x) (hsigned : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 / 2 + σ - κ) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((p.signedBlock v c u l).velocity n i).coeff j x) (hpold : ∀ (l : ι) (n : ℕ), HarmonicResidual.SmoothCoefficients p.strip.domain ((v.blocks l).pressure n)) (hppart : ∀ (l : ι) (n : ℕ), HarmonicResidual.SmoothCoefficients p.strip.domain ((p.particularBlock v c u l).pressure n)) (hpsigned : ∀ (l : ι) (n : ℕ), HarmonicResidual.SmoothCoefficients p.strip.domain ((p.signedBlock v c u l).pressure n)) (hzero : ∀ (l : ι), HarmonicWaveInteraction.ZeroMode (v.blocks l)) (hband : ∀ (l : ι), (v.blocks l).BandLimited v.residualBand) (hphase : ∀ (l : ι) (n : ℕ), ContDiffOn ℝ (↑⊤) ((v.blocks l).phase n) p.strip.domain) (hk : ∀ (l : ι) (n : ℕ), (v.blocks l).frequency n ≠ 0) (hkp : ∀ (l : ι) (n : ℕ), (v.blocks l).angularFrequency n ≠ 0) (hdiv : ∀ (l : ι), HarmonicWaveInteraction.ModeSolenoidal p.strip c (v.blocks l)) (hdivpart : ∀ (l : ι), HarmonicWaveInteraction.ModeSolenoidal p.strip c (p.particularBlock v c u l)) (hdivsigned : ∀ (l : ι), HarmonicWaveInteraction.ModeSolenoidal p.strip c (p.signedBlock v c u l)) {C : ℕ → ι → Set CyclePoint} (hNormal : ∀ (i : Fin 3), LocalizedWaveBounds.LocalUnweighted p.strip C 0 fun (n : ℕ) (l : ι) (x : CyclePoint) => (HarmonicMeanInteraction.slowNormal c ho hR (v.blocks l).phase n x).ofLp i) (hFreq : LocalizedWaveBounds.LocalUnweighted p.strip C (-(1 / 2)) fun (n : ℕ) (l : ι) (x : CyclePoint) => (v.blocks l).frequency n) (hAng : LocalizedWaveBounds.LocalUnweighted p.strip C (-(1 / 2)) fun (n : ℕ) (l : ι) (x : CyclePoint) => ↑((v.blocks l).angularFrequency n)) (hzpart : ∀ (n : ℕ) (l : ι), ∀ x ∈ p.strip.domain, x ∉ C n l → ∀ (i : Fin 3) (j : ℤ), j ≠ 0 → ((p.particularBlock v c u l).velocity n i).coeff j =ᶠ[nhds x] fun (x : CyclePoint) => 0) (hzsigned : ∀ (n : ℕ) (l : ι), ∀ x ∈ p.strip.domain, x ∉ C n l → ∀ (i : Fin 3) (j : ℤ), j ≠ 0 → ((p.signedBlock v c u l).velocity n i).coeff j =ᶠ[nhds x] fun (x : CyclePoint) => 0) (hP0 : ∀ (l : ι) (n : ℕ), ∀ x ∈ p.strip.domain, 0 ≤ P l n x) (hP1 : ∀ (l : ι) (n : ℕ), ∀ x ∈ p.strip.domain, P l n x ≤ 1) (hlinearP : ∀ (i : Fin 3) (j : ℤ), j ≠ 0 → LabelSumBounds.UniformWaveClass p.strip P (1 + σ - 3 * κ) fun (l : ι) (n : ℕ) (x : CyclePoint) => ((HarmonicResidual.residualBlock c u (v.blocks l) (v.gaussian l) (v.aliasCoefficients l)).velocity n i).coeff j x + ((HarmonicWaveInteraction.linearGoodBlock c (v.blocks l) (p.particularBlock v c u l) (p.particularGaussianBlock v c u l).velocity).velocity n i).coeff j x) (hlinearS : UniformHarmonicInteraction.UniformVelocity p.strip P (1 + σ - 4 * κ) fun (l : ι) => HarmonicWaveInteraction.linearGoodBlock c (p.beforeSignedBlock v c u l) (p.signedBlock v c u l) (p.signedGaussianBlock v c u l).velocity) : (UniformHarmonicInteraction.UniformVelocity p.strip P (1 / 2 + σ + 1 / 10) fun (l : ι) => HarmonicResidual.residualBlock c (p.afterSigned v c u) (p.finalBlock v c u l) ((p.nextCoefficients v c u).gaussian l) (v.aliasCoefficients l)) ∧ ∀ (l : ι), HarmonicWaveInteraction.ModeSolenoidal p.strip c (p.finalBlock v c u l)

The two constructed linear cancellations give the improved residual of the literal post-signed state, including both nonlinear wave updates. The linear estimates are the native equation/jet outputs, not estimates on either complete updated residual.

theorem NavierStokes.CorrectionStep.fullRequest_bounds_of_primitive (G : SignedMeanGain.Geometry) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) (H : MeanStateRegularity.PrimitiveData G.region G.patch.a G.patch.b c u) (hfixed : (VariableGaugeMean.reconstructState G.gauge c u).pressure = u.pressure) {α : ℝ} (hθ : WeightedClasses.MeanClass G.strip α (u.thetaResidual c)) (hz : WeightedClasses.MeanClass G.strip α (u.axialResidual c)) (i : Fin 2) : WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip G.strip) (α - 1) fun (n : ℕ) (x : SignedMeanGain.Point × ℝ) => LocalSignedRequest.fullRequest G.strip G.patch G.coord c u n x i

The actual full signed request is controlled by the current raw residuals. Their smoothness and support are derived from primitive state regularity and the actual pressure reconstruction.

theorem NavierStokes.CorrectionStep.waveStage_mean_gain (G : SignedMeanGain.Geometry) (c : CorrectionState.Context LocalSignedRequest.Point) (u : CorrectionState.State LocalSignedRequest.Point) (w : CorrectionState.Oscillation LocalSignedRequest.Point) (q : CorrectionState.OscillatoryScalar LocalSignedRequest.Point) (gaussian : CorrectionState.Oscillation LocalSignedRequest.Point) {σ κ : ℝ} (hσ : 1 / 5 ≤ σ) (hκ : 0 ≤ κ) (hκsmall : κ ≤ 1 / 100000) (H : MeanStateRegularity.PrimitiveData G.region G.patch.a G.patch.b c u) (ho : MeanIncrementBounds.OperatorBounds G.strip c.operators κ) (hb : MeanIncrementBounds.BaseBounds G.strip c.base) (hu : CorrectionState.CumulativeBounds G.strip u) (hfixed : (VariableGaugeMean.reconstructState G.gauge c u).pressure = u.pressure) (hθ : WeightedClasses.MeanClass G.strip (1 + σ) (u.thetaResidual c)) (hz : WeightedClasses.MeanClass G.strip (1 + σ) (u.axialResidual c)) (hd : CorrectionState.DefectBounds G.slowStrip σ c u) (hX : ∀ (i j : Fin 3), GaugeMomentBalances.MovingField G.region G.patch.a G.patch.b (SignedMeanGain.covarianceIncrement u.oscillation w i j)) (hXC : SignedMeanGain.TensorClass G.strip (1 + σ) (SignedMeanGain.covarianceIncrement u.oscillation w)) : have next := SignedMeanGain.waveStage G.gauge c u w q gaussian; WeightedClasses.MeanClass G.strip (1 + σ - κ) (next.pressure - u.pressure) ∧ CorrectionState.CumulativeBounds G.strip next ∧ WeightedClasses.MeanClass G.strip (1 + σ - κ) (next.thetaResidual c) ∧ WeightedClasses.MeanClass G.strip (1 + σ - κ) (next.axialResidual c) ∧ CorrectionState.DefectBounds G.slowStrip (σ - κ) c next ∧ ∀ (i : Fin 2), WeightedClasses.MeanClass (HarmonicWaveInteraction.productStrip G.strip) (σ - κ) fun (n : ℕ) (x : SignedMeanGain.Point × ℝ) => LocalSignedRequest.fullRequest G.strip G.patch G.coord c next n x i

The first actual wave supplies the current raw residuals and debt used by the signed request. No post-wave residual estimate is assumed.

theorem NavierStokes.CorrectionStep.CycleParameters.next_covariance {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) : (p.next v c u).covariance = u.covariance + SignedMeanGain.covarianceIncrement u.oscillation (p.particularVelocity v c u) + SignedMeanGain.covarianceIncrement (p.afterParticular v c u).oscillation (p.signedVelocity v c u)

Mean stages and the alias refresh leave the actual wave covariance unchanged. Both finite wave increments are retained in this identity.

theorem NavierStokes.CorrectionStep.CycleParameters.next_covariance_mem {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) {α β γ : ℝ} (hα : γ ≤ α) (hβ : γ ≤ β) (hold : ∀ (i j : Fin 3), WeightedClasses.MeanClass p.strip γ (u.covariance i j)) (hp : SignedMeanGain.TensorClass p.strip α (SignedMeanGain.covarianceIncrement u.oscillation (p.particularVelocity v c u))) (hs : SignedMeanGain.TensorClass p.strip β (SignedMeanGain.covarianceIncrement (p.afterParticular v c u).oscillation (p.signedVelocity v c u))) (i j : Fin 3) : WeightedClasses.MeanClass p.strip γ ((p.next v c u).covariance i j)

theorem NavierStokes.CorrectionStep.CycleParameters.nextAxisymmetricAlias_mem {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (axis : AxisymmetricAlias) {β : ℝ} (hold : WeightedClasses.MeanClass p.strip β axis) (ht : WeightedClasses.MeanClass p.strip β fun (n : ℕ) (z : CyclePoint) => VariableGaugeMean.temporalAliasState p.gauge p.timeExponent p.commonIndex c (p.afterSigned v c u) n (z, 0)) (hpn : WeightedClasses.MeanClass p.strip β fun (n : ℕ) (z : CyclePoint) => VariableGaugeMean.pressureAliasState p.gauge c (p.afterRank v c u) n (z, 0)) (hpo : WeightedClasses.MeanClass p.strip β fun (n : ℕ) (z : CyclePoint) => VariableGaugeMean.pressureAliasState p.gauge c u n (z, 0)) : WeightedClasses.MeanClass p.strip β (p.nextAxisymmetricAlias v c u axis)

theorem NavierStokes.CorrectionStep.CycleParameters.next_gaussian_mem {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) {w : ι → ℕ → CyclePoint → ℝ} {β : ℝ} (hold : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformClass p.strip w β fun (l : ι) (n : ℕ) (z : CyclePoint) => (v.gaussian l n i).coeff j z) (hp : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformClass p.strip w β fun (l : ι) (n : ℕ) (z : CyclePoint) => ((p.particularGaussianBlock v c u l).velocity n i).coeff j z) (hs : ∀ (i : Fin 3) (j : ℤ), LabelSumBounds.UniformClass p.strip w β fun (l : ι) (n : ℕ) (z : CyclePoint) => ((p.signedGaussianBlock v c u l).velocity n i).coeff j z) (i : Fin 3) (j : ℤ) : LabelSumBounds.UniformClass p.strip w β fun (l : ι) (n : ℕ) (z : CyclePoint) => ((p.nextCoefficients v c u).gaussian l n i).coeff j z

The edge weight is retained in all new Gaussian coefficients.

theorem NavierStokes.CorrectionStep.CycleParameters.next_inputSupport {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) {U : Set CyclePoint} {S : ι → ℕ → Set CyclePoint} (hold : ∀ (l : ι), HarmonicSourceSupport.InputSupportOn U (S l) (v.blocks l) (v.gaussian l) (v.aliasCoefficients l)) (hp : ∀ (l : ι), HarmonicSourceSupport.InputSupportOn U (S l) (p.particularBlock v c u l) (p.particularGaussianBlock v c u l).velocity 0) (hs : ∀ (l : ι), HarmonicSourceSupport.InputSupportOn U (S l) (p.signedBlock v c u l) (p.signedGaussianBlock v c u l).velocity 0) (l : ι) : HarmonicSourceSupport.InputSupportOn U (S l) ((p.nextCoefficients v c u).blocks l) ((p.nextCoefficients v c u).gaussian l) ((p.nextCoefficients v c u).aliasCoefficients l)

theorem NavierStokes.CorrectionStep.CycleParameters.next_oscillation_smooth {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) {U : Set CyclePoint} (hold : WaveStateRegularity.AngularSmooth U u.oscillation) (hp : WaveStateRegularity.AngularSmooth U (p.particularVelocity v c u)) (hs : WaveStateRegularity.AngularSmooth U (p.signedVelocity v c u)) : WaveStateRegularity.AngularSmooth U (p.next v c u).oscillation

theorem NavierStokes.CorrectionStep.CycleParameters.next_oscillation_periodic {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) {U : Set PressureStream.Plane} (hold : OscillationPeriodic U u.oscillation) (hp : OscillationPeriodic U (p.particularVelocity v c u)) (hs : OscillationPeriodic U (p.signedVelocity v c u)) : OscillationPeriodic U (p.next v c u).oscillation

theorem NavierStokes.CorrectionStep.CycleParameters.next_oscillation_support {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) {coord a b : ℝ} {U : LocalSignedRequest.SlowRegion coord} (hold : WaveStateRegularity.WaveSupport U a b u.oscillation) (hp : WaveStateRegularity.WaveSupport U a b (p.particularVelocity v c u)) (hs : WaveStateRegularity.WaveSupport U a b (p.signedVelocity v c u)) : WaveStateRegularity.WaveSupport U a b (p.next v c u).oscillation

theorem NavierStokes.CorrectionStep.CycleParameters.finalBlock_zero {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (hold : ∀ (l : ι), HarmonicWaveInteraction.ZeroMode (v.blocks l)) (l : ι) : HarmonicWaveInteraction.ZeroMode (p.finalBlock v c u l)

theorem NavierStokes.CorrectionStep.CycleParameters.finalBlock_pressure_zero {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) (hold : ∀ (l : ι) (n : ℕ), ((v.blocks l).pressure n).coeff 0 = 0) (l : ι) (n : ℕ) : ((p.finalBlock v c u l).pressure n).coeff 0 = 0

theorem NavierStokes.CorrectionStep.CycleParameters.finalBlock_pressure_cumulative {ι : Type} (p : CycleParameters ι) (v : CycleCoefficients ι) (c : CorrectionState.Context CyclePoint) (u : CorrectionState.State CyclePoint) {P : ι → ℕ → CyclePoint → ℝ} {σ κ : ℝ} (hσ : 1 / 5 ≤ σ) (hκsmall : κ ≤ 1 / 100000) (hold : ∀ (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P 1 fun (l : ι) (n : ℕ) (z : CyclePoint) => ((v.blocks l).pressure n).coeff j z) (hp : ∀ (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 + σ) fun (l : ι) (n : ℕ) (z : CyclePoint) => ((p.particularBlock v c u l).pressure n).coeff j z) (hs : ∀ (j : ℤ), LabelSumBounds.UniformWaveClass p.strip P (1 + σ - κ) fun (l : ι) (n : ℕ) (z : CyclePoint) => ((p.signedBlock v c u l).pressure n).coeff j z) (j : ℤ) : LabelSumBounds.UniformWaveClass p.strip P 1 fun (l : ι) (n : ℕ) (z : CyclePoint) => ((p.finalBlock v c u l).pressure n).coeff j z