openAI-math-dataset / lean /OAI /MathematicalPhysics /NavierStokes /ForcedComputation /Programs /CompactRapidEmbedding.lean
| import OAI.MathematicalPhysics.RapidForcing.Support | |
| namespace OAI | |
| /-! An explicit reflected similarity places the compact rapid-forcing | |
| construction in a single unit chart. The first-coordinate observation is | |
| preserved, and material trajectories are conjugated by the same map. -/ | |
| noncomputable section | |
| open Set | |
| open scoped ContDiff | |
| namespace RapidForcing.CompactEmbedding | |
| def reflection : Space ≃ₗᵢ[ℝ] Space := | |
| LinearIsometryEquiv.piLpCongrRight 2 (fun i : Fin 3 => | |
| if i = 0 then LinearIsometryEquiv.neg ℝ else LinearIsometryEquiv.refl ℝ ℝ) | |
| @[simp] theorem reflection_apply (x : Space) (i : Fin 3) : | |
| reflection x i = if i = 0 then -x i else x i := by | |
| by_cases hi : i = 0 <;> simp [reflection, LinearIsometryEquiv.piLpCongrRight_apply, hi] | |
| @[simp] theorem reflection_reflection (x : Space) : reflection (reflection x) = x := by | |
| ext i | |
| by_cases hi : i = 0 <;> simp [hi] | |
| def linear : Space →L[ℝ] Space := | |
| (1 / 8 : ℝ) • reflection.toContinuousLinearMap | |
| def inverseLinear : Space →L[ℝ] Space := | |
| (8 : ℝ) • reflection.toContinuousLinearMap | |
| def coordinateSign (i : Fin 3) : ℝ := if i = 0 then -1 else 1 | |
| theorem linear_apply (x : Space) (i : Fin 3) : | |
| linear x i = (coordinateSign i / 8) * x i := by | |
| by_cases hi : i = 0 <;> simp [linear, coordinateSign, hi, div_eq_mul_inv] | |
| theorem inverseLinear_basis (i : Fin 3) : | |
| inverseLinear (basis i) = (8 * coordinateSign i) • basis i := by | |
| ext j | |
| by_cases hji : j = i | |
| · subst j | |
| by_cases hi : i = 0 <;> simp [inverseLinear, coordinateSign, basis, hi] | |
| · have hj0 : i = 0 → j ≠ 0 := by intro hi; simpa [hi] using hji | |
| by_cases hi : i = 0 <;> simp [inverseLinear, coordinateSign, basis, hji, hi, hj0] | |
| @[simp] theorem inverseLinear_linear (x : Space) : inverseLinear (linear x) = x := by | |
| simp [inverseLinear, linear, map_smul, smul_smul] | |
| @[simp] theorem linear_inverseLinear (x : Space) : linear (inverseLinear x) = x := by | |
| simp [inverseLinear, linear, map_smul, smul_smul] | |
| theorem norm_linear (x : Space) : ‖linear x‖ = (1 / 8 : ℝ) * ‖x‖ := by | |
| simp [linear, norm_smul] | |
| theorem norm_inverseLinear (x : Space) : ‖inverseLinear x‖ = 8 * ‖x‖ := by | |
| simp [inverseLinear, norm_smul] | |
| def center : Space := vec (3 / 8) (1 / 2) (1 / 2) | |
| def embed (x : Space) : Space := center + linear x | |
| def unembed (x : Space) : Space := inverseLinear (x - center) | |
| @[simp] theorem unembed_embed (x : Space) : unembed (embed x) = x := by | |
| simp [unembed, embed] | |
| @[simp] theorem embed_unembed (x : Space) : embed (unembed x) = x := by | |
| simp [unembed, embed] | |
| @[simp] theorem embed_zero : embed 0 = center := by simp [embed] | |
| @[simp] theorem unembed_center : unembed center = 0 := by simp [unembed] | |
| theorem embed_injective : Function.Injective embed := | |
| Function.LeftInverse.injective unembed_embed | |
| theorem unembed_injective : Function.Injective unembed := | |
| Function.LeftInverse.injective embed_unembed | |
| @[simp] theorem embed_first (x : Space) : embed x 0 = 3 / 8 - x 0 / 8 := by | |
| simp [embed, center, vec, linear, sub_eq_add_neg, div_eq_mul_inv, mul_comm] | |
| @[simp] theorem embed_second (x : Space) : embed x 1 = 1 / 2 + x 1 / 8 := by | |
| simp [embed, center, vec, linear, div_eq_mul_inv, mul_comm] | |
| @[simp] theorem embed_third (x : Space) : embed x 2 = 1 / 2 + x 2 / 8 := by | |
| simp [embed, center, vec, linear, div_eq_mul_inv, mul_comm] | |
| theorem embed_observation (x : Space) : 1 / 2 < embed x 0 ↔ x 0 < -1 := by | |
| rw [embed_first] | |
| constructor <;> intro h <;> linarith | |
| def chart : Set Space := {x | (∀ i, 1 / 4 ≤ x i) ∧ ∀ i, x i ≤ 3 / 4} | |
| theorem embed_mem_chart {x : Space} (hx : x ∈ K) : embed x ∈ chart := by | |
| obtain ⟨hx0, hx0', hx1, hx1', hx2, hx2'⟩ := hx | |
| have h0 := embed_first x | |
| have h1 := embed_second x | |
| have h2 := embed_third x | |
| constructor <;> intro i <;> fin_cases i <;> dsimp <;> linarith | |
| theorem chart_inside_unit {x : Space} (hx : x ∈ chart) : | |
| ∀ i, 0 < x i ∧ x i < 1 := by | |
| intro i | |
| have h0 := hx.1 i | |
| have h1 := hx.2 i | |
| constructor <;> linarith | |
| def compactChart : Set Space := embed '' K | |
| theorem compactChart_compact : IsCompact compactChart := | |
| K_compact.image (continuous_const.add linear.continuous) | |
| theorem compactChart_subset_chart : compactChart ⊆ chart := by | |
| rintro _ ⟨x, hx, rfl⟩ | |
| exact embed_mem_chart hx | |
| theorem embed_hasFDerivAt (x : Space) : HasFDerivAt embed linear x := by | |
| exact linear.hasFDerivAt.const_add center | |
| theorem unembed_hasFDerivAt (x : Space) : HasFDerivAt unembed inverseLinear x := by | |
| have he : unembed = fun y => inverseLinear y - inverseLinear center := by | |
| funext y | |
| exact map_sub inverseLinear y center | |
| rw [he] | |
| exact inverseLinear.hasFDerivAt.sub_const _ | |
| theorem embed_contDiff : ContDiff ℝ ∞ embed := | |
| contDiff_const.add linear.contDiff | |
| theorem unembed_contDiff : ContDiff ℝ ∞ unembed := | |
| inverseLinear.contDiff.comp (contDiff_id.sub contDiff_const) | |
| def field (u : Field Space) : Field Space := | |
| fun t x => linear (u t (unembed x)) | |
| @[simp] theorem field_embed (u : Field Space) (t : ℝ) (x : Space) : | |
| field u t (embed x) = linear (u t x) := by simp [field] | |
| theorem field_zero (u : Field Space) {t : ℝ} (hu : ∀ x, u t x = 0) : | |
| ∀ x, field u t x = 0 := by intro x; simp [field, hu] | |
| theorem field_supported {u : Field Space} (hu : Supported u) {t : ℝ} (ht : 0 ≤ t) : | |
| tsupport (field u t) ⊆ compactChart := by | |
| apply closure_minimal _ compactChart_compact.isClosed | |
| intro x hx | |
| have hmem : unembed x ∈ K := by | |
| by_contra h | |
| exact hx (by simp [field, hu.zero_off ht h]) | |
| exact ⟨unembed x, hmem, embed_unembed x⟩ | |
| theorem field_smooth {u : Field Space} (hu : Smooth u) : Smooth (field u) := by | |
| exact linear.contDiff.comp_contDiffOn | |
| (hu.comp (contDiff_fst.prodMk (unembed_contDiff.comp contDiff_snd)).contDiffOn | |
| (fun y hy => ⟨hy.1, mem_univ _⟩)) | |
| theorem embed_curve_hasDerivWithinAt {γ : ℝ → Space} {v : Space} | |
| {s : Set ℝ} {t : ℝ} (hγ : HasDerivWithinAt γ v s t) : | |
| HasDerivWithinAt (fun r => embed (γ r)) (linear v) s t := by | |
| simpa only [Function.comp_def] using (embed_hasFDerivAt (γ t)).comp_hasDerivWithinAt t hγ | |
| theorem unembed_curve_hasDerivWithinAt {γ : ℝ → Space} {v : Space} | |
| {s : Set ℝ} {t : ℝ} (hγ : HasDerivWithinAt γ v s t) : | |
| HasDerivWithinAt (fun r => unembed (γ r)) (inverseLinear v) s t := by | |
| simpa only [Function.comp_def] using | |
| (unembed_hasFDerivAt (γ t)).comp_hasDerivWithinAt t hγ | |
| def flow (X : ℝ → Space → Space) : ℝ → Space → Space := | |
| fun t x => embed (X t (unembed x)) | |
| @[simp] theorem flow_embed (X : ℝ → Space → Space) (t : ℝ) (x : Space) : | |
| flow X t (embed x) = embed (X t x) := by simp [flow] | |
| theorem trajectory_unembed {u : Field Space} {a : Space} {T : ℝ} {γ : ℝ → Space} | |
| (hγ : TrajectoryOn (field u) a T γ) : | |
| TrajectoryOn u (unembed a) T (fun t => unembed (γ t)) := by | |
| refine ⟨by change unembed (γ 0) = unembed a; rw [hγ.1], ?_⟩ | |
| intro t ht | |
| simpa only [field, inverseLinear_linear] using | |
| unembed_curve_hasDerivWithinAt (hγ.2 t ht) | |
| theorem materialFlow {u : Field Space} {X : ℝ → Space → Space} | |
| (hX : MaterialFlow u X) : MaterialFlow (field u) (flow X) := by | |
| refine ⟨?_, ?_, ?_⟩ | |
| · intro a | |
| simp [flow, hX.1] | |
| · intro a t ht | |
| simpa only [flow, field, unembed_embed] using | |
| embed_curve_hasDerivWithinAt (hX.2.1 (unembed a) t ht) | |
| · intro T hT a γ hγ t ht | |
| have he := hX.2.2 T hT (unembed a) (fun r => unembed (γ r)) | |
| (trajectory_unembed hγ) t ht | |
| have he' := congrArg embed he | |
| simpa only [embed_unembed, flow] using he' | |
| theorem flow_observation (X : ℝ → Space → Space) (t : ℝ) : | |
| 1 / 2 < flow X t center 0 ↔ X t 0 0 < -1 := by | |
| simpa only [flow, unembed_center] using embed_observation (X t 0) | |
| theorem reaches_iff (X : ℝ → Space → Space) : | |
| (∃ t : ℝ, 0 ≤ t ∧ 1 / 2 < flow X t center 0) ↔ | |
| ∃ t : ℝ, 0 ≤ t ∧ X t 0 0 < -1 := by | |
| simp only [flow_observation] | |
| end RapidForcing.CompactEmbedding | |
| end | |
| end OAI | |