openAI-math-dataset / lean /OAI /MathematicalPhysics /NavierStokes /ForcedComputation /Flow /CompactEuclideanEnergy.lean
| import OAI.MathematicalPhysics.AlternatingFlow.EnergyUniqueness | |
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.CompactRapidCoordinates | |
| namespace OAI | |
| /-! Energy regularity of compact smooth fields, transferred to the Euclidean | |
| coordinate convention. Pressure uniqueness is stated modulo time-dependent | |
| spatial constants, as in the balanced-box application. -/ | |
| noncomputable section | |
| namespace ForcedComputation.CompactEuclidean | |
| open Set | |
| open RapidForcing.CompactEmbedding | |
| open scoped ContDiff | |
| def velocity (V : ShearFlows.Velocity) : AlternatingNS.Velocity := | |
| fun t x => piCoordinates.symm (V (t, piCoordinates x)) | |
| theorem velocity_smooth {V : ShearFlows.Velocity} (hV : ContDiff ℝ ∞ V) : | |
| ContDiff ℝ ∞ (Function.uncurry (velocity V)) := | |
| piCoordinates.symm.contDiff.comp | |
| (hV.comp (contDiff_fst.prodMk (piCoordinates.contDiff.comp contDiff_snd))) | |
| theorem piField_velocity (V : ShearFlows.Velocity) : | |
| piField (velocity V) = V := by | |
| funext y | |
| simp only [piField, velocity, ContinuousLinearEquiv.apply_symm_apply] | |
| theorem velocity_divergence (V : ShearFlows.Velocity) (t : ℝ) (x : AlternatingNS.Space) : | |
| AlternatingNS.div (velocity V) t x = | |
| ShearFlows.divergence (fun y => V (t,y)) (piCoordinates x) := by | |
| have h := piField_divergence (velocity V) t (piCoordinates x) | |
| rw [piField_velocity] at h | |
| simpa only [ContinuousLinearEquiv.symm_apply_apply, AlternatingNS.div, | |
| AlternatingNS.dx, AlternatingNS.e, RapidForcing.divergence, | |
| RapidForcing.spatialD, RapidForcing.basis] using h.symm | |
| theorem velocity_support {V : ShearFlows.Velocity} {K : Set ShearFlows.Space} | |
| (hs : ∀ t, Function.support (fun x => V (t,x)) ⊆ K) (t : ℝ) : | |
| Function.support (velocity V t) ⊆ piCoordinates.symm '' K := by | |
| intro x hx | |
| have hv : V (t, piCoordinates x) ≠ 0 := by | |
| intro hz | |
| exact hx (by simp only [velocity, hz, map_zero]) | |
| exact ⟨piCoordinates x, hs t hv, piCoordinates.symm_apply_apply x⟩ | |
| theorem velocity_energyClass {V : ShearFlows.Velocity} (hV : ContDiff ℝ ∞ V) | |
| {K : Set ShearFlows.Space} (hK : IsCompact K) | |
| (hs : ∀ t, Function.support (fun x => V (t,x)) ⊆ K) : | |
| AlternatingNS.EnergyClass (velocity V) (fun _ _ => 0) := | |
| AlternatingNS.Analytic.smooth_energyClass (velocity V) (velocity_smooth hV) | |
| (piCoordinates.symm '' K) (hK.image piCoordinates.symm.continuous) (velocity_support hs) | |
| theorem velocity_global_material_flow {V : ShearFlows.Velocity} (hV : ContDiff ℝ ∞ V) | |
| {K : Set ShearFlows.Space} (hK : IsCompact K) | |
| (hs : ∀ t, Function.support (fun x => V (t,x)) ⊆ K) : | |
| ∃ X : AlternatingNS.Space → ℝ → AlternatingNS.Space, | |
| (∀ a, AlternatingNS.IsTrajectory (velocity V) a (X a)) ∧ | |
| (∀ a γ, AlternatingNS.IsTrajectory (velocity V) a γ → | |
| ∀ t, 0 ≤ t → γ t = X a t) := | |
| AlternatingNS.Analytic.global_material_flow (velocity V) (velocity_smooth hV) | |
| (piCoordinates.symm '' K) (hK.image piCoordinates.symm.continuous) (velocity_support hs) | |
| /-- A pressure class has an energy-regular representative satisfying the | |
| equations. Its spatially constant gauge may depend on time. -/ | |
| def IsEnergySolutionModuloConstants (ν : ℝ) (f u : AlternatingNS.Velocity) | |
| (p : AlternatingNS.Pressure) : Prop := | |
| ∃ c : ℝ → ℝ, | |
| AlternatingNS.NavierStokes ν f u (fun t x => p t x - c t) ∧ | |
| AlternatingNS.CompetitorEnergyClass u (fun t x => p t x - c t) | |
| theorem energy_unique_modulo_constants {ν : ℝ} (hν : 0 ≤ ν) | |
| {f U v : AlternatingNS.Velocity} {p : AlternatingNS.Pressure} | |
| (hU : AlternatingNS.NavierStokes ν f U (fun _ _ => 0)) | |
| (hUE : AlternatingNS.EnergyClass U (fun _ _ => 0)) | |
| (hv : IsEnergySolutionModuloConstants ν f v p) : | |
| ∃ c : ℝ → ℝ, ∀ t, 0 ≤ t → ∀ x, v t x = U t x ∧ p t x = c t := by | |
| obtain ⟨c, hvc, hvE⟩ := hv | |
| have he := AlternatingNS.Analytic.energy_unique ν hν f U v (fun t x => p t x - c t) | |
| hU hvc hUE hvE | |
| exact ⟨c, fun t ht x => ⟨(he t ht x).1, sub_eq_zero.mp (he t ht x).2⟩⟩ | |
| theorem compact_velocity_solution {ν : ℝ} (hν : 0 < ν) | |
| {V : ShearFlows.Velocity} (hV : ContDiff ℝ ∞ V) | |
| {K : Set ShearFlows.Space} (hK : IsCompact K) | |
| (hs : ∀ t, Function.support (fun x => V (t,x)) ⊆ K) | |
| (h0 : ∀ x, V (0,x) = 0) (hd : ShearFlows.Solenoidal V) : | |
| let U := velocity V | |
| AlternatingNS.NavierStokes ν (AlternatingNS.residual ν U) U (fun _ _ => 0) ∧ | |
| AlternatingNS.EnergyClass U (fun _ _ => 0) ∧ | |
| ∀ v p, IsEnergySolutionModuloConstants ν (AlternatingNS.residual ν U) v p → | |
| ∃ c : ℝ → ℝ, ∀ t, 0 ≤ t → ∀ x, v t x = U t x ∧ p t x = c t := by | |
| dsimp only | |
| have hsol := AlternatingNS.Analytic.residual_navierStokes ν (velocity V) (velocity_smooth hV) | |
| (fun x => by simp only [velocity, h0, map_zero]) | |
| (fun t _ x => by rw [velocity_divergence]; exact hd t (piCoordinates x)) | |
| have hE := velocity_energyClass hV hK hs | |
| exact ⟨hsol, hE, fun v p hv => energy_unique_modulo_constants hν.le hsol hE hv⟩ | |
| end ForcedComputation.CompactEuclidean | |
| end | |
| end OAI | |