| import Mathlib |
| import OAI.MathematicalPhysics.SheetFlows.Pulses |
|
|
| namespace OAI |
|
|
| /-! SheetFlows localization. -/ |
|
|
| section |
| noncomputable section |
| open Set MeasureTheory |
| open scoped BigOperators |
| namespace Solenoidal |
|
|
| def Rectangle.CollarSeparated {N : ℕ} (R : Fin N → Rectangle) (d : ℝ) : Prop := |
| ∀ i j, i ≠ j → ∀ y ∈ (R j).carrier, |
| ∃ k, (R i).halfWidth k + d ≤ |y k - (R i).center k| |
|
|
| theorem Rectangle.disjoint_of_separated {N : ℕ} {R : Fin N → Rectangle} |
| (h : SeparatelySeparated R) {i j : Fin N} (hij : i ≠ j) : |
| Disjoint (R i).carrier (R j).carrier := by |
| obtain ⟨δ,hδ,hh⟩ := h i j hij |
| rw [Set.disjoint_left] |
| intro y hi hj |
| have hn := hh y hi y hj |
| simp only [sub_self, norm_zero] at hn |
| exact (not_le_of_gt hδ) hn |
|
|
| theorem Rectangle.exists_coordinate_gap {P Q : Rectangle} (h : Disjoint P.carrier Q.carrier) : |
| ∃ k, P.upper k < Q.lower k ∨ Q.upper k < P.lower k := by |
| by_contra hn |
| push Not at hn |
| have hmin (k : Fin 2) : max (P.lower k) (Q.lower k) ≤ min (P.upper k) (Q.upper k) := by |
| rcases hn k with ⟨h₁,h₂⟩ |
| exact max_le (le_min (P.positive k).le h₂) (le_min h₁ (Q.positive k).le) |
| have hy : (fun k => ((max (P.lower k) (Q.lower k) : ℚ) : ℝ)) ∈ P.carrier ∩ Q.carrier := by |
| constructor |
| · intro k |
| dsimp only |
| constructor |
| · exact_mod_cast le_max_left (P.lower k) (Q.lower k) |
| · exact_mod_cast (hmin k).trans (min_le_left _ _) |
| · intro k |
| dsimp only |
| constructor |
| · exact_mod_cast le_max_right (P.lower k) (Q.lower k) |
| · exact_mod_cast (hmin k).trans (min_le_right _ _) |
| exact Set.disjoint_left.mp h hy.1 hy.2 |
|
|
| theorem Rectangle.collar_of_coordinate_gap {P Q : Rectangle} {d : ℝ} {k : Fin 2} |
| (h : (P.upper k : ℝ) + d ≤ Q.lower k ∨ (Q.upper k : ℝ) + d ≤ P.lower k) |
| {y : Plane} (hy : y ∈ Q.carrier) : P.halfWidth k + d ≤ |y k - P.center k| := by |
| rcases h with h | h |
| · apply le_abs.mpr |
| left |
| have hyk := (hy k).1 |
| dsimp [Rectangle.halfWidth, Rectangle.center] |
| linarith |
| · apply le_abs.mpr |
| right |
| have hyk := (hy k).2 |
| dsimp [Rectangle.halfWidth, Rectangle.center] |
| linarith |
|
|
| theorem Rectangle.exists_rational_collar {N : ℕ} {R : Fin N → Rectangle} |
| (h : SeparatelySeparated R) : |
| ∃ d : ℚ, 0 < d ∧ d ≤ 1/10 ∧ Rectangle.CollarSeparated R (d : ℝ) := by |
| classical |
| have hpair (i j : Fin N) : ∃ d : ℚ, 0 < d ∧ |
| (i ≠ j → ∀ y ∈ (R j).carrier, |
| ∃ k, (R i).halfWidth k + (d : ℝ) ≤ |y k - (R i).center k|) := by |
| by_cases hij : i = j |
| · exact ⟨1, by norm_num, fun hc => (hc hij).elim⟩ |
| obtain ⟨k,hk⟩ := Rectangle.exists_coordinate_gap (Rectangle.disjoint_of_separated h hij) |
| rcases hk with hk | hk |
| · refine ⟨(R j).lower k - (R i).upper k, sub_pos.mpr hk, fun _ y hy => ⟨k, ?_⟩⟩ |
| apply Rectangle.collar_of_coordinate_gap (Or.inl ?_) hy |
| push_cast |
| ring_nf |
| exact le_refl _ |
| · refine ⟨(R i).lower k - (R j).upper k, sub_pos.mpr hk, fun _ y hy => ⟨k, ?_⟩⟩ |
| apply Rectangle.collar_of_coordinate_gap (Or.inr ?_) hy |
| push_cast |
| ring_nf |
| exact le_refl _ |
| choose ds hpos hg using hpair |
| let S : Finset ℚ := insert (1/10) (Finset.univ.image (fun ij : Fin N × Fin N => ds ij.1 ij.2)) |
| have hS : S.Nonempty := ⟨1/10, Finset.mem_insert_self _ _⟩ |
| refine ⟨S.min' hS, ?_, S.min'_le _ (Finset.mem_insert_self _ _), ?_⟩ |
| · rw [Finset.lt_min'_iff] |
| intro q hq |
| rcases Finset.mem_insert.mp hq with rfl | hq |
| · norm_num |
| obtain ⟨⟨i,j⟩,_,rfl⟩ := Finset.mem_image.mp hq |
| exact hpos i j |
| · intro i j hij y hy |
| obtain ⟨k,hk⟩ := hg i j hij y hy |
| refine ⟨k, le_trans ?_ hk⟩ |
| apply add_le_add (le_refl _) |
| exact_mod_cast S.min'_le _ (Finset.mem_insert_of_mem (Finset.mem_image_of_mem _ (Finset.mem_univ (i,j)))) |
|
|
| theorem Rectangle.CollarSeparated.mono {N : ℕ} {R : Fin N → Rectangle} {d e : ℝ} |
| (h : Rectangle.CollarSeparated R d) (he : e ≤ d) : Rectangle.CollarSeparated R e := by |
| intro i j hij y hy |
| obtain ⟨k,hk⟩ := h i j hij y hy |
| exact ⟨k, (add_le_add (le_refl _) he).trans hk⟩ |
|
|
| theorem SheetData.exists_rational_collar {N : ℕ} (D : SheetData N) : |
| ∃ d : ℚ, 0 < d ∧ d ≤ 1/10 ∧ Rectangle.CollarSeparated D.source (d : ℝ) ∧ |
| Rectangle.CollarSeparated D.target (d : ℝ) := by |
| obtain ⟨a,ha,ha',hs⟩ := Rectangle.exists_rational_collar D.source_separated |
| obtain ⟨b,hb,_,ht⟩ := Rectangle.exists_rational_collar D.target_separated |
| refine ⟨min a b, lt_min ha hb, (min_le_left _ _).trans ha', hs.mono ?_, ht.mono ?_⟩ |
| · exact_mod_cast min_le_left a b |
| · exact_mod_cast min_le_right a b |
|
|
| theorem Rectangle.center_bounds (R : Rectangle) (hR : R.inCodingSquare) (j : Fin 2) : |
| 2 ≤ R.center j ∧ R.center j ≤ 3 := by |
| have hl : (2:ℝ) ≤ R.lower j := by exact_mod_cast (hR j).1 |
| have hu : (R.upper j:ℝ) ≤ 3 := by exact_mod_cast (hR j).2 |
| have hw : (R.lower j:ℝ) ≤ R.upper j := by exact_mod_cast (R.positive j).le |
| dsimp [Rectangle.center] |
| constructor <;> linarith |
| |
| theorem Rectangle.point_bounds (R : Rectangle) (hR : R.inCodingSquare) |
| {y : Plane} (hy : y ∈ R.carrier) (j : Fin 2) : 2 ≤ y j ∧ y j ≤ 3 := by |
| have hl : (2:ℝ) ≤ R.lower j := by exact_mod_cast (hR j).1 |
| have hu : (R.upper j:ℝ) ≤ 3 := by exact_mod_cast (hR j).2 |
| exact ⟨hl.trans (hy j).1, (hy j).2.trans hu⟩ |
|
|
| structure Collar where |
| size : ℝ |
| positive : 0 < size |
| small : size ≤ 1/10 |
|
|
| variable (d : Collar) |
|
|
| def lifted (s z : ℝ) (y : Plane) : Space := ![y 0 + s, y 1, z] |
|
|
| def verticalPulse (R : Rectangle) (hR : R.inCodingSquare) (s : ℝ) : StationaryPulse := |
| StationaryPulse.tensor 2 |
| ![Cprofile (R.halfWidth 0) d.size (R.center 0+s), |
| fun x => Cprofile (R.halfWidth 1) d.size (R.center 1) x - |
| Cprofile (R.halfWidth 1) d.size (R.center 1+4) x, fun _ => 1] |
| (by intro j; fin_cases j |
| · exact Cprofile_contDiff _ _ d.positive |
| · exact (Cprofile_contDiff _ _ d.positive).sub (Cprofile_contDiff _ _ d.positive) |
| · exact contDiff_const) |
| (by intro j; fin_cases j |
| · exact Cprofile_periodic _ _ _ |
| · exact (Cprofile_periodic _ _ _).sub (Cprofile_periodic _ _ _) |
| · exact fun _ => rfl) |
| (fun _ => rfl) 1 |
| (by |
| apply Cprofile_corrected_integral_zero d.positive <;> |
| have hw := R.halfWidth_le_half hR 1 <;> |
| have hc := R.center_bounds hR 1 <;> |
| linarith [d.small]) |
| |
| theorem verticalPulse_field (R : Rectangle) (hR : R.inCodingSquare) (s : ℝ) (x : Space) : |
| (verticalPulse d R hR s).field x = |
| (Cprofile (R.halfWidth 0) d.size (R.center 0+s) (x 0) * |
| (Cprofile (R.halfWidth 1) d.size (R.center 1) (x 1) - |
| Cprofile (R.halfWidth 1) d.size (R.center 1+4) (x 1))) • basis 2 := by |
| simp [verticalPulse, StationaryPulse.tensor, tensorVelocity, tensorScalar, Fin.prod_univ_succ] |
|
|
| theorem rect_support_chart (R : Rectangle) (hR : R.inCodingSquare) (j : Fin 2) |
| {s : ℝ} (hs : s ∈ Set.Icc 0 4) : |
| R.halfWidth j + d.size ≤ R.center j + s ∧ |
| R.center j + s + (R.halfWidth j + d.size) ≤ 10 := by |
| have hw := R.halfWidth_le_half hR j |
| have hc := R.center_bounds hR j |
| constructor <;> linarith [d.small, hs.1, hs.2] |
| |
| theorem correction_off (R : Rectangle) (hR : R.inCodingSquare) |
| {y : ℝ} (hy : y ∈ Set.Icc 2 3) : |
| Cprofile (R.halfWidth 1) d.size (R.center 1+4) y = 0 := by |
| have hc := rect_support_chart d R hR 1 (s := 4) (by norm_num) |
| apply Cprofile_zero_on_chart d.positive hc.1 hc.2 ⟨by linarith [hy.1], by linarith [hy.2]⟩ |
| apply le_abs.mpr |
| right |
| linarith [R.halfWidth_le_half hR 1, (R.center_bounds hR 1).1, d.small, hy.2] |
|
|
| theorem rect_profile_one (R : Rectangle) (hR : R.inCodingSquare) (j : Fin 2) |
| {s : ℝ} (hs : s ∈ Set.Icc 0 4) {y : Plane} (hy : y ∈ R.carrier) : |
| Cprofile (R.halfWidth j) d.size (R.center j+s) (y j+s) = 1 := by |
| have hc := rect_support_chart d R hR j hs |
| apply Cprofile_one d.positive hc.1 hc.2 |
| · have hb := R.point_bounds hR hy j |
| constructor <;> linarith [hs.1, hs.2, hb.1, hb.2] |
| · have hb := (R.mem_iff_abs y).mp hy j |
| have he : y j + s - (R.center j+s) = y j - R.center j := by ring |
| rw [he] |
| linarith [d.positive] |
|
|
| theorem verticalPulse_own (R : Rectangle) (hR : R.inCodingSquare) |
| {s : ℝ} (hs : s ∈ Set.Icc 0 4) {y : Plane} (hy : y ∈ R.carrier) (z : ℝ) : |
| (verticalPulse d R hR s).field (lifted s z y) = basis 2 := by |
| rw [verticalPulse_field] |
| have h₀ := rect_profile_one d R hR 0 hs hy |
| have h₁ := rect_profile_one d R hR 1 (s := 0) (by norm_num) hy |
| simp only [add_zero] at h₁ |
| simp only [lifted, Matrix.cons_val_zero, Matrix.cons_val_one, h₀, h₁, |
| correction_off d R hR (R.point_bounds hR hy 1), sub_zero, mul_one, one_smul] |
|
|
| theorem rect_profile_gap_zero (P Q : Rectangle) (hP : P.inCodingSquare) |
| (hQ : Q.inCodingSquare) (k : Fin 2) {s : ℝ} (hs : s ∈ Set.Icc 0 4) |
| {y : Plane} (hy : y ∈ Q.carrier) |
| (hgap : P.halfWidth k + d.size ≤ |y k-P.center k|) : |
| Cprofile (P.halfWidth k) d.size (P.center k+s) (y k+s) = 0 := by |
| have hc := rect_support_chart d P hP k hs |
| apply Cprofile_zero_on_chart d.positive hc.1 hc.2 |
| · have hb := Q.point_bounds hQ hy k |
| constructor <;> linarith [hs.1, hs.2, hb.1, hb.2] |
| · have he : y k+s-(P.center k+s) = y k-P.center k := by ring |
| rw [he] |
| exact hgap |
|
|
| theorem verticalPulse_off_same {N : ℕ} (R : Fin N → Rectangle) |
| (hR : ∀ i, (R i).inCodingSquare) (hsep : Rectangle.CollarSeparated R d.size) |
| {i j : Fin N} (hij : i ≠ j) {s : ℝ} (hs : s ∈ Set.Icc 0 4) |
| {y : Plane} (hy : y ∈ (R j).carrier) (z : ℝ) : |
| (verticalPulse d (R i) (hR i) s).field (lifted s z y) = 0 := by |
| obtain ⟨k,hk⟩ := hsep i j hij y hy |
| have hc := correction_off d (R i) (hR i) ((R j).point_bounds (hR j) hy 1) |
| rw [verticalPulse_field] |
| fin_cases k |
| · have hz := rect_profile_gap_zero d (R i) (R j) (hR i) (hR j) 0 hs hy hk |
| simp [lifted, hz] |
| · have hz := rect_profile_gap_zero d (R i) (R j) (hR i) (hR j) 1 (s := 0) (by norm_num) hy hk |
| simp only [add_zero] at hz |
| simp [lifted, hc, hz] |
|
|
| theorem verticalPulse_off_far (P Q : Rectangle) (hP : P.inCodingSquare) |
| (hQ : Q.inCodingSquare) {s t : ℝ} (hs : s ∈ Set.Icc 0 4) |
| (ht : t ∈ Set.Icc 0 4) (hst : 4 ≤ |t-s|) {y : Plane} (hy : y ∈ Q.carrier) (z : ℝ) : |
| (verticalPulse d P hP s).field (lifted t z y) = 0 := by |
| have hc := rect_support_chart d P hP 0 hs |
| have hz : Cprofile (P.halfWidth 0) d.size (P.center 0+s) (y 0+t) = 0 := by |
| apply Cprofile_zero_on_chart d.positive hc.1 hc.2 |
| · have hb := Q.point_bounds hQ hy 0 |
| constructor <;> linarith [ht.1, ht.2, hb.1, hb.2] |
| · rcases le_abs.mp hst with hf | hf |
| · apply le_abs.mpr (Or.inl ?_) |
| linarith [(Q.point_bounds hQ hy 0).1, (P.center_bounds hP 0).2, |
| P.halfWidth_le_half hP 0, d.small] |
| · apply le_abs.mpr (Or.inr ?_) |
| linarith [(Q.point_bounds hQ hy 0).2, (P.center_bounds hP 0).1, |
| P.halfWidth_le_half hP 0, d.small] |
| simp [verticalPulse_field, lifted, hz] |
| |
| def horizontalPulse (j : Fin 2) : StationaryPulse := |
| StationaryPulse.tensor j.castSucc |
| ![fun _ => 1, fun _ => 1, fun z => Cprofile 0 d.size 5 z - Cprofile 0 d.size 8 z] |
| (by intro k; fin_cases k |
| · exact contDiff_const |
| · exact contDiff_const |
| · exact (Cprofile_contDiff _ _ d.positive).sub (Cprofile_contDiff _ _ d.positive)) |
| (by intro k; fin_cases k |
| · exact fun _ => rfl |
| · exact fun _ => rfl |
| · exact (Cprofile_periodic _ _ _).sub (Cprofile_periodic _ _ _)) |
| (by intro s; fin_cases j <;> rfl) 2 |
| (by apply Cprofile_corrected_integral_zero d.positive <;> linarith [d.small]) |
| |
| theorem horizontalPulse_field (j : Fin 2) (x : Space) : |
| (horizontalPulse d j).field x = |
| (Cprofile 0 d.size 5 (x 2) - Cprofile 0 d.size 8 (x 2)) • basis j.castSucc := by |
| simp [horizontalPulse, StationaryPulse.tensor, tensorVelocity, tensorScalar, Fin.prod_univ_succ] |
|
|
| theorem horizontalPulse_on (j : Fin 2) {x : Space} (hx : x 2 = 5) : |
| (horizontalPulse d j).field x = basis j.castSucc := by |
| have h₅ : Cprofile 0 d.size 5 5 = 1 := by |
| apply Cprofile_one d.positive <;> norm_num <;> linarith [d.small, d.positive] |
| have h₈ : Cprofile 0 d.size 8 5 = 0 := by |
| apply Cprofile_zero_on_chart d.positive <;> norm_num <;> linarith [d.small, d.positive] |
| simp only [horizontalPulse_field, hx, h₅, h₈, sub_zero, one_smul] |
| |
| theorem horizontalPulse_off (j : Fin 2) {x : Space} (hx : x 2 = 2) : |
| (horizontalPulse d j).field x = 0 := by |
| have h₅ : Cprofile 0 d.size 5 2 = 0 := by |
| apply Cprofile_zero_on_chart d.positive <;> norm_num <;> linarith [d.small, d.positive] |
| have h₈ : Cprofile 0 d.size 8 2 = 0 := by |
| apply Cprofile_zero_on_chart d.positive <;> norm_num <;> linarith [d.small, d.positive] |
| simp only [horizontalPulse_field, hx, h₅, h₈, sub_self, zero_smul] |
| |
| @[simp] theorem StationaryPulse.scale_field (c : ℝ) (p : StationaryPulse) (x : Space) : |
| (p.scale c).field x = c • p.field x := rfl |
|
|
| def travelProgram (δ : Plane) : List StationaryPulse := |
| [(horizontalPulse d 0).scale (δ 0), (horizontalPulse d 1).scale (δ 1)] |
|
|
| theorem travelProgram_on (δ : Plane) (x y : ℝ) : |
| runProgram (travelProgram d δ) ![x,y,5] = ![x+δ 0,y+δ 1,5] := by |
| have h₀ : ((horizontalPulse d 0).scale (δ 0)).apply ![x,y,5] = ![x+δ 0,y,5] := by |
| simp only [StationaryPulse.apply, StationaryPulse.scale_field, |
| horizontalPulse_on d 0 (by rfl : (![x,y,5] : Space) 2 = 5)] |
| ext i; fin_cases i <;> simp [basis] |
| have h₁ : ((horizontalPulse d 1).scale (δ 1)).apply ![x+δ 0,y,5] = ![x+δ 0,y+δ 1,5] := by |
| simp only [StationaryPulse.apply, StationaryPulse.scale_field, |
| horizontalPulse_on d 1 (by rfl : (![x+δ 0,y,5] : Space) 2 = 5)] |
| ext i; fin_cases i <;> simp [basis] |
| change ((horizontalPulse d 1).scale (δ 1)).apply |
| (((horizontalPulse d 0).scale (δ 0)).apply ![x,y,5]) = _ |
| rw [h₀, h₁] |
| |
| theorem travelProgram_off (δ : Plane) (x : Space) (hx : x 2 = 2) : |
| runProgram (travelProgram d δ) x = x := by |
| apply runProgram_fixed |
| intro p hp |
| simp only [travelProgram, List.mem_cons, List.not_mem_nil, or_false] at hp |
| rcases hp with rfl | rfl <;> simp [horizontalPulse_off d _ hx] |
| |
| end Solenoidal |
| end |
| end |
| |
| |
| end OAI |
| |
