| import Mathlib |
| import OAI.MathematicalPhysics.SheetFlows.ShearCore |
|
|
| namespace OAI |
|
|
| /-! SheetFlows routing. -/ |
|
|
| noncomputable section |
| open Set MeasureTheory |
| open scoped BigOperators |
| namespace Solenoidal |
|
|
| @[simp] theorem StationaryPulse.apply_of_field_zero (p : StationaryPulse) {x : Space} |
| (h : p.field x = 0) : p.apply x = x := by |
| rw [StationaryPulse.apply, h, add_zero] |
|
|
| @[simp] theorem StationaryPulse.scale_apply_of_field_zero (p : StationaryPulse) (c : ℝ) |
| {x : Space} (h : p.field x = 0) : (p.scale c).apply x = x := by |
| apply StationaryPulse.apply_of_field_zero |
| rw [StationaryPulse.scale_field, h, smul_zero] |
|
|
| theorem verticalPulse_apply (d : Collar) (R : Rectangle) (hR : R.inCodingSquare) |
| {s : ℝ} (hs : s ∈ Set.Icc 0 4) {y : Plane} (hy : y ∈ R.carrier) (z c : ℝ) : |
| ((verticalPulse d R hR s).scale c).apply (lifted s z y) = lifted s (z+c) y := by |
| rw [StationaryPulse.apply, StationaryPulse.scale_field, verticalPulse_own d R hR hs hy] |
| ext i; fin_cases i <;> simp [lifted, basis] |
|
|
| def evacuateProgram (d : Collar) (R : Rectangle) (hR : R.inCodingSquare) : |
| List StationaryPulse := |
| [(verticalPulse d R hR 0).scale 3] ++ travelProgram d ![4,0] ++ |
| [(verticalPulse d R hR 4).scale (-3)] |
|
|
| theorem evacuateProgram_on (d : Collar) (R : Rectangle) (hR : R.inCodingSquare) |
| {y : Plane} (hy : y ∈ R.carrier) : |
| runProgram (evacuateProgram d R hR) (lifted 0 2 y) = lifted 4 2 y := by |
| have h₁ := verticalPulse_apply d R hR (s := 0) (by norm_num) hy 2 3 |
| have h₂ := verticalPulse_apply d R hR (s := 4) (by norm_num) hy 5 (-3) |
| norm_num only at h₁ h₂ |
| simp only [evacuateProgram, runProgram_append, runProgram_cons, runProgram_nil, h₁] |
| rw [show runProgram (travelProgram d ![4,0]) (lifted 0 5 y) = lifted 4 5 y by |
| simp only [lifted, travelProgram_on, Matrix.cons_val_zero, Matrix.cons_val_one, add_zero]] |
| exact h₂ |
|
|
| theorem evacuateProgram_off_input {N : ℕ} (d : Collar) (R : Fin N → Rectangle) |
| (hR : ∀ i, (R i).inCodingSquare) (hs : Rectangle.CollarSeparated R d.size) |
| {i j : Fin N} (hij : i ≠ j) {y : Plane} (hy : y ∈ (R j).carrier) : |
| runProgram (evacuateProgram d (R i) (hR i)) (lifted 0 2 y) = lifted 0 2 y := by |
| have h₀ := verticalPulse_off_same d R hR hs hij (s := 0) (by norm_num) hy 2 |
| have h₄ := verticalPulse_off_far d (R i) (R j) (hR i) (hR j) |
| (s := 4) (t := 0) (by norm_num) (by norm_num) (by norm_num) hy 2 |
| simp only [evacuateProgram, runProgram_append, runProgram_cons, runProgram_nil, |
| StationaryPulse.scale_apply_of_field_zero _ _ h₀, |
| travelProgram_off d _ _ (by rfl : (lifted 0 2 y) 2 = 2), |
| StationaryPulse.scale_apply_of_field_zero _ _ h₄] |
|
|
| theorem evacuateProgram_off_output {N : ℕ} (d : Collar) (R : Fin N → Rectangle) |
| (hR : ∀ i, (R i).inCodingSquare) (hs : Rectangle.CollarSeparated R d.size) |
| {i j : Fin N} (hij : i ≠ j) {y : Plane} (hy : y ∈ (R j).carrier) : |
| runProgram (evacuateProgram d (R i) (hR i)) (lifted 4 2 y) = lifted 4 2 y := by |
| have h₀ := verticalPulse_off_far d (R i) (R j) (hR i) (hR j) |
| (s := 0) (t := 4) (by norm_num) (by norm_num) (by norm_num) hy 2 |
| have h₄ := verticalPulse_off_same d R hR hs hij (s := 4) (by norm_num) hy 2 |
| simp only [evacuateProgram, runProgram_append, runProgram_cons, runProgram_nil, |
| StationaryPulse.scale_apply_of_field_zero _ _ h₀, |
| travelProgram_off d _ _ (by rfl : (lifted 4 2 y) 2 = 2), |
| StationaryPulse.scale_apply_of_field_zero _ _ h₄] |
|
|
| def instructionProgram {N : ℕ} (d : Collar) (D : SheetData N) (i : Fin N) : |
| List StationaryPulse := |
| [(verticalPulse d (D.source i) (D.source_inside i) 4).scale 3] ++ |
| travelProgram d ![1-(D.source i).center 0,6-(D.source i).center 1] ++ |
| processingProgram d (D.ratio i 0) (D.ratio i 1) ++ |
| travelProgram d ![(D.target i).center 0-5,(D.target i).center 1-6] ++ |
| [(verticalPulse d (D.target i) (D.target_inside i) 0).scale (-3)] |
|
|
| theorem SheetData.image_mem {N : ℕ} (D : SheetData N) (i : Fin N) |
| {y : Plane} (hy : y ∈ (D.source i).carrier) : |
| diagonalMap (D.source i) (D.target i) (D.ratio i) y ∈ (D.target i).carrier := by |
| rw [← D.image_eq i] |
| exact Set.mem_image_of_mem _ hy |
|
|
| theorem instructionProgram_on {N : ℕ} (d : Collar) (D : SheetData N) (i : Fin N) |
| {y : Plane} (hy : y ∈ (D.source i).carrier) : |
| runProgram (instructionProgram d D i) (lifted 4 2 y) = |
| lifted 0 2 (diagonalMap (D.source i) (D.target i) (D.ratio i) y) := by |
| let r := y 0 - (D.source i).center 0 |
| let s := y 1 - (D.source i).center 1 |
| have hr : |r| ≤ 1/2 := (D.source i).offset_bound (D.source_inside i) hy 0 |
| have hs : |s| ≤ 1/2 := (D.source i).offset_bound (D.source_inside i) hy 1 |
| have hlr : |(D.ratio i 0:ℝ)*r| ≤ 1/2 := D.scaled_offset_bound i hy 0 |
| have hms : |(D.ratio i 1:ℝ)*s| ≤ 1/2 := D.scaled_offset_bound i hy 1 |
| have hl : (D.ratio i 0:ℝ) ≠ 0 := ne_of_gt (by exact_mod_cast D.ratio_positive i 0) |
| have hm : (D.ratio i 1:ℝ) ≠ 0 := ne_of_gt (by exact_mod_cast D.ratio_positive i 1) |
| have hlift := verticalPulse_apply d (D.source i) (D.source_inside i) (s := 4) |
| (by norm_num) hy 2 3 |
| norm_num only at hlift |
| have hgo : runProgram (travelProgram d ![1-(D.source i).center 0,6-(D.source i).center 1]) |
| (lifted 4 5 y) = ![5+r,6+s,5] := by |
| rw [lifted, travelProgram_on] |
| ext j; fin_cases j <;> simp [r,s] <;> ring |
| have hback : runProgram (travelProgram d ![(D.target i).center 0-5,(D.target i).center 1-6]) |
| ![5+(D.ratio i 0:ℝ)*r,6+(D.ratio i 1:ℝ)*s,5] = |
| lifted 0 5 (diagonalMap (D.source i) (D.target i) (D.ratio i) y) := by |
| rw [travelProgram_on] |
| ext j; fin_cases j <;> simp [r,s,lifted,diagonalMap] <;> ring |
| have hdrop := verticalPulse_apply d (D.target i) (D.target_inside i) (s := 0) |
| (by norm_num) (D.image_mem i hy) 5 (-3) |
| norm_num only at hdrop |
| simp only [instructionProgram, runProgram_append, runProgram_cons, runProgram_nil, |
| hlift, hgo, processingProgram_on d hl hm hr hs hlr hms, hback, hdrop] |
|
|
| theorem instructionProgram_off_input {N : ℕ} (d : Collar) (D : SheetData N) |
| (hsource : Rectangle.CollarSeparated D.source d.size) |
| {i j : Fin N} (hij : i ≠ j) {y : Plane} (hy : y ∈ (D.source j).carrier) : |
| runProgram (instructionProgram d D i) (lifted 4 2 y) = lifted 4 2 y := by |
| have h₁ := verticalPulse_off_same d D.source D.source_inside hsource hij |
| (s := 4) (by norm_num) hy 2 |
| have h₂ := verticalPulse_off_far d (D.target i) (D.source j) |
| (D.target_inside i) (D.source_inside j) (s := 0) (t := 4) |
| (by norm_num) (by norm_num) (by norm_num) hy 2 |
| have hx : (lifted 4 2 y) 1 ∈ Set.Icc 2 3 := |
| (D.source j).point_bounds (D.source_inside j) hy 1 |
| have hz : (lifted 4 2 y) 2 = 2 := rfl |
| simp only [instructionProgram, runProgram_append, runProgram_cons, runProgram_nil, |
| StationaryPulse.scale_apply_of_field_zero _ _ h₁, travelProgram_off d _ _ hz, |
| processingProgram_off d _ _ _ hx hz, StationaryPulse.scale_apply_of_field_zero _ _ h₂] |
|
|
| theorem instructionProgram_off_output {N : ℕ} (d : Collar) (D : SheetData N) |
| (htarget : Rectangle.CollarSeparated D.target d.size) |
| {i j : Fin N} (hij : i ≠ j) {y : Plane} (hy : y ∈ (D.target j).carrier) : |
| runProgram (instructionProgram d D i) (lifted 0 2 y) = lifted 0 2 y := by |
| have h₁ := verticalPulse_off_far d (D.source i) (D.target j) |
| (D.source_inside i) (D.target_inside j) (s := 4) (t := 0) |
| (by norm_num) (by norm_num) (by norm_num) hy 2 |
| have h₂ := verticalPulse_off_same d D.target D.target_inside htarget hij |
| (s := 0) (by norm_num) hy 2 |
| have hx : (lifted 0 2 y) 1 ∈ Set.Icc 2 3 := |
| (D.target j).point_bounds (D.target_inside j) hy 1 |
| have hz : (lifted 0 2 y) 2 = 2 := rfl |
| simp only [instructionProgram, runProgram_append, runProgram_cons, runProgram_nil, |
| StationaryPulse.scale_apply_of_field_zero _ _ h₁, travelProgram_off d _ _ hz, |
| processingProgram_off d _ _ _ hx hz, StationaryPulse.scale_apply_of_field_zero _ _ h₂] |
|
|
| theorem runProgram_flatMap_fixed {ι : Type*} (l : List ι) |
| (P : ι → List StationaryPulse) (a : Space) |
| (h : ∀ i ∈ l, runProgram (P i) a = a) : |
| runProgram (l.flatMap P) a = a := by |
| induction l with |
| | nil => rfl |
| | cons i l ih => |
| rw [List.flatMap_cons, runProgram_append, h i (by simp)] |
| exact ih (fun j hj => h j (by simp [hj])) |
|
|
| theorem runProgram_separate_branches {ι A : Type*} (l : List ι) (hl : l.Nodup) |
| (P : ι → List StationaryPulse) (domain : ι → Set A) |
| (input output : ι → A → Space) |
| (hown : ∀ i a, a ∈ domain i → runProgram (P i) (input i a) = output i a) |
| (hin : ∀ i j, i ≠ j → ∀ a ∈ domain j, |
| runProgram (P i) (input j a) = input j a) |
| (hout : ∀ i j, i ≠ j → ∀ a ∈ domain j, |
| runProgram (P i) (output j a) = output j a) : |
| ∀ i ∈ l, ∀ a ∈ domain i, runProgram (l.flatMap P) (input i a) = output i a := by |
| classical |
| induction l with |
| | nil => simp |
| | cons j l ih => |
| rcases List.nodup_cons.mp hl with ⟨hjl,hl⟩ |
| intro i hi a ha |
| rw [List.flatMap_cons, runProgram_append] |
| rcases List.mem_cons.mp hi with rfl | hi |
| · rw [hown i a ha] |
| exact runProgram_flatMap_fixed l P (output i a) (fun k hk => |
| hout k i (fun h => hjl (h ▸ hk)) a ha) |
| · have hji : j ≠ i := fun h => hjl (h ▸ hi) |
| rw [hin j i hji a ha] |
| exact ih hl i hi a ha |
|
|
| def sheetProgram {N : ℕ} (d : Collar) (D : SheetData N) : List StationaryPulse := |
| (List.finRange N).flatMap (fun i => evacuateProgram d (D.source i) (D.source_inside i)) ++ |
| (List.finRange N).flatMap (instructionProgram d D) |
|
|
| theorem sheetProgram_on {N : ℕ} (d : Collar) (D : SheetData N) |
| (hsource : Rectangle.CollarSeparated D.source d.size) |
| (htarget : Rectangle.CollarSeparated D.target d.size) |
| (i : Fin N) {y : Plane} (hy : y ∈ (D.source i).carrier) : |
| runProgram (sheetProgram d D) (sheet y) = |
| sheet (diagonalMap (D.source i) (D.target i) (D.ratio i) y) := by |
| have hev := runProgram_separate_branches (List.finRange N) (List.nodup_finRange N) |
| (fun i => evacuateProgram d (D.source i) (D.source_inside i)) |
| (fun i => (D.source i).carrier) (fun _ => lifted 0 2) (fun _ => lifted 4 2) |
| (fun i _ hy => evacuateProgram_on d (D.source i) (D.source_inside i) hy) |
| (fun _ _ hij _ hj => evacuateProgram_off_input d D.source D.source_inside hsource hij hj) |
| (fun _ _ hij _ hj => evacuateProgram_off_output d D.source D.source_inside hsource hij hj) |
| i (List.mem_finRange i) y hy |
| have hop := runProgram_separate_branches (List.finRange N) (List.nodup_finRange N) |
| (instructionProgram d D) (fun i => (D.source i).carrier) (fun _ => lifted 4 2) |
| (fun i y => lifted 0 2 (diagonalMap (D.source i) (D.target i) (D.ratio i) y)) |
| (fun i _ hy => instructionProgram_on d D i hy) |
| (fun _ _ hij _ hj => instructionProgram_off_input d D hsource hij hj) |
| (fun _ j hij _ hj => instructionProgram_off_output d D htarget hij (D.image_mem j hj)) |
| i (List.mem_finRange i) y hy |
| have hs (y : Plane) : sheet y = lifted 0 2 y := by simp [sheet,lifted] |
| rw [sheetProgram, runProgram_append, hs, hev, hop, hs] |
|
|
| end Solenoidal |
| end |
|
|
| noncomputable section |
| open Set MeasureTheory |
| open scoped BigOperators |
| namespace Solenoidal |
|
|
| theorem sheet_theorem_analytic {N : ℕ} (D : SheetData N) (ν : ℝ) (hν : 0 < ν) : |
| ∃ f u : Field, ∃ X : ℝ → Space → Space, |
| SpatiallyPeriodic f ∧ SpatiallyPeriodic u ∧ Smooth f ∧ Smooth u ∧ |
| MeanZero f ∧ DivergenceFree f ∧ OnePeriodic f ∧ |
| ClassicalSolution ν f u (0 : Pressure) ∧ |
| (∀ v : Field, ∀ p : Pressure, ClassicalSolution ν f v p → |
| ∀ t, 0 ≤ t → ∀ x, v t x = u t x ∧ p t x = 0) ∧ |
| MaterialFlow u X ∧ |
| (∀ i : Fin N, ∀ y ∈ (D.source i).carrier, |
| toTorus (X 1 (sheet y)) = |
| toTorus (sheet (diagonalMap (D.source i) (D.target i) (D.ratio i) y))) ∧ |
| IntegerCollars u ∧ (∀ t x, advection u t x = 0) ∧ |
| (∀ α, ∃ B : ℝ, 0 ≤ B ∧ ∀ z, ‖mixedDerivative f α z‖ ≤ B) ∧ |
| (∀ α, ∃ B : ℝ, 0 ≤ B ∧ ∀ z, ‖mixedDerivative u α z‖ ≤ B) ∧ |
| (N = 0 → f = 0 ∧ u = 0) := by |
| cases N with |
| | zero => |
| refine ⟨0,0,fun _ a => a, zero_spatially_periodic, zero_spatially_periodic, |
| zero_smooth, zero_smooth, zero_mean_zero, zero_divergence_free, |
| zero_one_periodic, zero_classical_solution ν, ?_, zero_material_flow, |
| ?_, zero_integer_collars, ?_, ?_, ?_, by simp⟩ |
| · intro v p hv t ht x |
| exact (zero_classical_solution ν).unique hv hν.le ht x |
| · intro i |
| exact Fin.elim0 i |
| · intro t x |
| simp |
| · exact zero_effective_bounds.bounded |
| · exact zero_effective_bounds.bounded |
| | succ N => |
| obtain ⟨δ,hδ,hδsmall,hs,ht⟩ := D.exists_rational_collar |
| have hδsmall' : (δ:ℝ) ≤ 1/10 := by |
| have hc : δ*10 ≤ 1 := (le_div_iff₀ (by norm_num)).mp hδsmall |
| have hc' : (δ:ℝ)*10 ≤ 1 := by exact_mod_cast hc |
| linarith |
| let d : Collar := ⟨(δ:ℝ), by exact_mod_cast hδ, hδsmall'⟩ |
| obtain ⟨f,u,X,hfsp,husp,hfs,hus,hmean,hdiv,hper,hsol,huniq,hflow,hend,hcol,hadv,hfb,hub⟩ := |
| program_realization (sheetProgram d D) ν hν.le |
| refine ⟨f,u,X,hfsp,husp,hfs,hus,hmean,hdiv,hper,hsol,huniq,hflow,?_,hcol,hadv,hfb,hub,?_⟩ |
| · intro i y hy |
| rw [hend, sheetProgram_on d D hs ht i hy] |
| · simp |
|
|
| end Solenoidal |
| end |
|
|
| end OAI |
|
|
