openAI-math-dataset / lean /OAI /MathematicalPhysics /NavierStokes /VelocityDetection /ChartRouting.lean
| import OAI.MathematicalPhysics.NavierStokes.VelocityDetection.HistoryRouting | |
| import OAI.MathematicalPhysics.NavierStokes.VelocityDetection.Periodization | |
| namespace OAI | |
| noncomputable section | |
| namespace VelocityDetection.ChartRouting | |
| open Set Function Filter MeasureTheory | |
| open scoped Topology ContDiff BigOperators | |
| open Expanding CenterPaths SpatialCalculus | |
| variable (A : RoutingData) | |
| def scale (N : ℕ) : ℝ := (1024 * (count A.K A.D (N+1) + 4))⁻¹ | |
| theorem scale_pos (N : ℕ) : 0 < scale A N := by | |
| have hd : 0 ≤ count A.K A.D (N+1) := by | |
| unfold count | |
| exact mul_nonneg A.K_nonneg (pow_nonneg (by linarith [A.D_ge_one]) _) | |
| unfold scale | |
| positivity | |
| theorem scale_small (N : ℕ) : scale A N ≤ (1/4096 : ℝ) := by | |
| have hd : 0 ≤ count A.K A.D (N+1) := by | |
| unfold count | |
| exact mul_nonneg A.K_nonneg (pow_nonneg (by linarith [A.D_ge_one]) _) | |
| change (1024 * (count A.K A.D (N+1) + 4))⁻¹ ≤ _ | |
| have hp : 0 < 1024 * (count A.K A.D (N+1) + 4) := by positivity | |
| rw [inv_eq_one_div] | |
| apply (div_le_iff₀ hp).mpr | |
| nlinarith | |
| theorem scaled_address (N k : ℕ) (hk : (k:ℝ) ≤ count A.K A.D (N+1)) : | |
| scale A N * ((k:ℝ)+2) ≤ (1/1024 : ℝ) := by | |
| have hh : scale A N * (count A.K A.D (N+1)+4) = (1/1024:ℝ) := by | |
| unfold scale | |
| have hp : 0 < count A.K A.D (N+1)+4 := by | |
| have hd : 0 ≤ count A.K A.D (N+1) := by | |
| unfold count | |
| exact mul_nonneg A.K_nonneg (pow_nonneg (by linarith [A.D_ge_one]) _) | |
| linarith | |
| field_simp | |
| rw [← hh] | |
| exact mul_le_mul_of_nonneg_left (by linarith) (scale_pos A N).le | |
| def origin : Coord 2 := ![1/4,1/2] | |
| def targetHeight (N n : ℕ) (c : A.Instruction n) : ℝ := | |
| if A.sign n c = 1 then -(7/16:ℝ) else -scale A N | |
| def path (N n : ℕ) (c : A.Instruction n) (s : ℝ) : Coord 2 := | |
| origin + center (n:ℝ) 1 (scale A N) (scale A N) | |
| (targetHeight A N n c / scale A N) (A.source n c) (A.target n c) s | |
| @[fun_prop] theorem contDiff_path (N n : ℕ) (c : A.Instruction n) : | |
| ContDiff ℝ ∞ (path A N n c) := by unfold path; fun_prop | |
| theorem path_source (N n : ℕ) (c : A.Instruction n) {s : ℝ} (hs : s ≤ n) : | |
| path A N n c s = origin + ![scale A N * A.source n c,-scale A N] := by | |
| unfold path | |
| rw [center_source_collar] | |
| norm_num only [div_one] | |
| linarith | |
| theorem path_target (N n : ℕ) (c : A.Instruction n) {s : ℝ} (hs : n+1 ≤ s) : | |
| path A N n c s = origin + ![scale A N * A.target n c,targetHeight A N n c] := by | |
| unfold path | |
| rw [center_target_collar] | |
| · rw [div_mul_cancel₀ _ (ne_of_gt (scale_pos A N))] | |
| · norm_num only [div_one] | |
| linarith | |
| theorem velocity_source (N n : ℕ) (c : A.Instruction n) {s : ℝ} (hs : s ≤ n) : | |
| deriv (path A N n c) s = 0 := by | |
| unfold path | |
| rw [deriv_const_add] | |
| · exact velocity_source_collar _ _ (by norm_num only [div_one]; linarith) | |
| theorem velocity_target (N n : ℕ) (c : A.Instruction n) {s : ℝ} (hs : n+1 ≤ s) : | |
| deriv (path A N n c) s = 0 := by | |
| unfold path | |
| rw [deriv_const_add] | |
| · exact velocity_target_collar _ _ (by norm_num only [div_one]; linarith) | |
| theorem theta_order (a T s : ℝ) : theta a T 2 s ≤ theta a T 0 s := by | |
| unfold theta ramp | |
| exact Real.smoothTransition.monotone (by norm_num only [Nat.cast_ofNat, Nat.cast_zero]; linarith) | |
| theorem center_in_rectangle {S σ lo hi xmax : ℝ} {k l : ℕ} | |
| (hS0 : 0 ≤ S) (hk : S * k ≤ xmax) (hl : S * l ≤ xmax) | |
| (hrow : privateRow S k ∈ Icc lo hi) (hsource : -S ∈ Icc lo hi) | |
| (htarget : σ*S ∈ Icc lo hi) (a T s : ℝ) : | |
| (center a T S S σ k l s 0 ∈ Icc (0:ℝ) xmax) ∧ | |
| (center a T S S σ k l s 1 ∈ Icc lo hi) := by | |
| have ht (j : ℕ) : theta a T j s ∈ Icc (0:ℝ) 1 := | |
| ⟨ramp_nonneg _, ramp_le_one _⟩ | |
| have hm := theta_order a T s | |
| constructor | |
| · change 0 ≤ (1-theta a T 1 s)*S*k+theta a T 1 s*S*l ∧ | |
| (1-theta a T 1 s)*S*k+theta a T 1 s*S*l ≤ xmax | |
| have hp : 0 ≤ 1 - theta a T 1 s := by linarith [(ht 1).2] | |
| constructor | |
| · exact add_nonneg (mul_nonneg (mul_nonneg hp hS0) (Nat.cast_nonneg _)) | |
| (mul_nonneg (mul_nonneg (ht 1).1 hS0) (Nat.cast_nonneg _)) | |
| · have h₁ := mul_le_mul_of_nonneg_left hk hp | |
| have h₂ := mul_le_mul_of_nonneg_left hl (ht 1).1 | |
| nlinarith | |
| · change lo ≤ -(1-theta a T 0 s)*S+ | |
| (theta a T 0 s-theta a T 2 s)*privateRow S k+theta a T 2 s*σ*S ∧ | |
| -(1-theta a T 0 s)*S+ | |
| (theta a T 0 s-theta a T 2 s)*privateRow S k+theta a T 2 s*σ*S ≤ hi | |
| have hp : 0 ≤ 1-theta a T 0 s := by linarith [(ht 0).2] | |
| have hq : 0 ≤ theta a T 0 s-theta a T 2 s := sub_nonneg.mpr hm | |
| have h₁ := mul_le_mul_of_nonneg_left hsource.1 hp | |
| have h₂ := mul_le_mul_of_nonneg_left hrow.1 hq | |
| have h₃ := mul_le_mul_of_nonneg_left htarget.1 (ht 2).1 | |
| have h₄ := mul_le_mul_of_nonneg_left hsource.2 hp | |
| have h₅ := mul_le_mul_of_nonneg_left hrow.2 hq | |
| have h₆ := mul_le_mul_of_nonneg_left htarget.2 (ht 2).1 | |
| constructor <;> nlinarith | |
| theorem path_bounds (N n : ℕ) (c : A.Instruction n) (hn : n < N) (s : ℝ) : | |
| path A N n c s 0 ∈ Icc (1/4:ℝ) (1/4+1/1024) ∧ | |
| path A N n c s 1 ∈ Icc (1/16:ℝ) (1/2) := by | |
| have hk := scaled_address A N (A.source n c) | |
| ((A.source_count n c).trans (count_mono A.K_nonneg A.D_ge_one (by omega))) | |
| have hl := scaled_address A N (A.target n c) | |
| ((A.target_count n c).trans (count_mono A.K_nonneg A.D_ge_one (by omega))) | |
| have hS := scale_pos A N | |
| have hsmall := scale_small A N | |
| have hheight : targetHeight A N n c ∈ Icc (-(7/16):ℝ) 0 := by | |
| unfold targetHeight | |
| split_ifs <;> constructor <;> linarith | |
| have hh := center_in_rectangle hS.le | |
| (show scale A N * (A.source n c:ℝ) ≤ (1/1024:ℝ) by nlinarith) | |
| (show scale A N * (A.target n c:ℝ) ≤ (1/1024:ℝ) by nlinarith) | |
| (show privateRow (scale A N) (A.source n c) ∈ Icc (-(7/16):ℝ) 0 by | |
| dsimp [privateRow]; constructor <;> nlinarith [Nat.cast_nonneg (α := ℝ) (A.source n c)]) | |
| (show -scale A N ∈ Icc (-(7/16):ℝ) 0 by constructor <;> linarith) | |
| (show targetHeight A N n c / scale A N * scale A N ∈ Icc (-(7/16):ℝ) 0 by | |
| rwa [div_mul_cancel₀ _ (ne_of_gt hS)]) (n:ℝ) 1 s | |
| change 1/4+center _ _ _ _ _ _ _ s 0 ∈ Icc _ _ ∧ | |
| 1/2+center _ _ _ _ _ _ _ s 1 ∈ Icc _ _ | |
| exact ⟨⟨by linarith [hh.1.1],by linarith [hh.1.2]⟩, | |
| ⟨by linarith [hh.2.1],by linarith [hh.2.2]⟩⟩ | |
| theorem nonterminal_bounds (N n : ℕ) (c : A.Instruction n) (hn : n < N) | |
| (hc : A.sign n c = -1) (s : ℝ) : | |
| (1/2-1/1024:ℝ) ≤ path A N n c s 1 := by | |
| have hk := scaled_address A N (A.source n c) | |
| ((A.source_count n c).trans (count_mono A.K_nonneg A.D_ge_one (by omega))) | |
| have hl := scaled_address A N (A.target n c) | |
| ((A.target_count n c).trans (count_mono A.K_nonneg A.D_ge_one (by omega))) | |
| have hS := scale_pos A N | |
| have hsmall := scale_small A N | |
| have he : targetHeight A N n c = -scale A N := by norm_num [targetHeight,hc] | |
| have hh := center_in_rectangle hS.le | |
| (show scale A N * (A.source n c:ℝ) ≤ (1/1024:ℝ) by nlinarith) | |
| (show scale A N * (A.target n c:ℝ) ≤ (1/1024:ℝ) by nlinarith) | |
| (show privateRow (scale A N) (A.source n c) ∈ Icc (-(1/1024):ℝ) 0 by | |
| dsimp [privateRow]; constructor <;> nlinarith [Nat.cast_nonneg (α := ℝ) (A.source n c)]) | |
| (show -scale A N ∈ Icc (-(1/1024):ℝ) 0 by constructor <;> linarith) | |
| (show targetHeight A N n c / scale A N * scale A N ∈ Icc (-(1/1024):ℝ) 0 by | |
| rw [div_mul_cancel₀ _ (ne_of_gt hS),he]; constructor <;> linarith) (n:ℝ) 1 s | |
| change _ ≤ 1/2+center _ _ _ _ _ _ _ s 1 | |
| linarith [hh.2.1] | |
| def radius (N : ℕ) : ℝ := scale A N / 16 | |
| theorem radius_pos (N : ℕ) : 0 < radius A N := div_pos (scale_pos A N) (by norm_num) | |
| def stage (N n : ℕ) : VectorField 2 := fun s X => | |
| ∑ c : A.Instruction n, TranslationGates.field (radius A N) | |
| (path A N n c s) (deriv (path A N n c) s) X | |
| @[fun_prop] theorem contDiff_stage (N n : ℕ) : ContDiff ℝ ∞ (uncurry (stage A N n)) := by | |
| unfold stage | |
| apply ContDiff.sum | |
| intro c _ | |
| exact TranslationGates.contDiff_movingField _ (contDiff_path A N n c) | |
| ((contDiff_infty_iff_deriv.mp (contDiff_path A N n c)).2) | |
| theorem stage_zero_before (N n : ℕ) {s : ℝ} (hs : s ≤ n) (X : Coord 2) : | |
| stage A N n s X = 0 := by | |
| unfold stage | |
| apply Finset.sum_eq_zero | |
| intro c _ | |
| rw [velocity_source A N n c hs,TranslationGates.field_zero_velocity] | |
| theorem stage_zero_after (N n : ℕ) {s : ℝ} (hs : n+1 ≤ s) (X : Coord 2) : | |
| stage A N n s X = 0 := by | |
| unfold stage | |
| apply Finset.sum_eq_zero | |
| intro c _ | |
| rw [velocity_target A N n c hs,TranslationGates.field_zero_velocity] | |
| theorem stage_divergence (N n : ℕ) (s : ℝ) (X : Coord 2) : | |
| divergence (stage A N n) s X = 0 := by | |
| unfold stage | |
| rw [divergence_sum] | |
| · apply Finset.sum_eq_zero | |
| intro c _ | |
| exact TranslationGates.divergence_field (radius A N) (path A N n c s) | |
| (deriv (path A N n c) s) X | |
| · intro c _ s | |
| exact TranslationGates.contDiff_field (radius A N) (path A N n c s) | |
| (deriv (path A N n c) s) | |
| theorem paths_separated (N n : ℕ) (c d : A.Instruction n) (hcd : c ≠ d) (s : ℝ) : | |
| ∃ i : Fin 2, 16*radius A N ≤ |path A N n c s i - path A N n d s i| := by | |
| obtain ⟨i,hi⟩ := CenterPaths.separated (scale_pos A N).le le_rfl (n:ℝ) 1 | |
| (targetHeight A N n c / scale A N) (targetHeight A N n d / scale A N) s | |
| ((A.source_injective n).ne hcd) ((A.target_injective n).ne hcd) | |
| refine ⟨i,?_⟩ | |
| simpa only [path,Pi.add_apply,add_sub_add_left_eq_sub,radius,mul_div_cancel₀ _ (by norm_num : (16:ℝ) ≠ 0)] using hi | |
| theorem stage_plateau (N n : ℕ) (c : A.Instruction n) (s : ℝ) (X : Coord 2) | |
| (hX : ∀ i, |X i - path A N n c s i| ≤ radius A N) : | |
| stage A N n s X = deriv (path A N n c) s := by | |
| exact TranslationGates.array_plateau (radius_pos A N) | |
| (fun c => path A N n c s) (fun c => deriv (path A N n c) s) | |
| (fun c _ d _ h => paths_separated A N n c d h s) (Finset.mem_univ c) X hX | |
| end VelocityDetection.ChartRouting | |
| end | |
| noncomputable section | |
| namespace VelocityDetection.ChartRouting | |
| open Set Function Filter MeasureTheory | |
| open scoped Topology ContDiff BigOperators | |
| open Expanding CenterPaths SpatialCalculus Periodization | |
| variable (A : RoutingData) | |
| def chartSet : Set (Coord 2) := Icc ![1/8,1/32] ![3/8,3/4] | |
| theorem compact_chartSet : IsCompact chartSet := isCompact_Icc | |
| theorem chartSet_interior {X : Coord 2} (hX : X ∈ chartSet) : | |
| ∀ i, X i ∈ Ioo (0:ℝ) 1 := by | |
| intro i | |
| fin_cases i | |
| · have h₁ := hX.1 (0 : Fin 2) | |
| have h₂ := hX.2 (0 : Fin 2) | |
| norm_num only [Matrix.cons_val_zero] at h₁ h₂ | |
| change 0 < X 0 ∧ X 0 < 1 | |
| constructor <;> linarith | |
| · have h₁ := hX.1 (1 : Fin 2) | |
| have h₂ := hX.2 (1 : Fin 2) | |
| norm_num only [Matrix.cons_val_one, Matrix.cons_val_zero] at h₁ h₂ | |
| change 0 < X 1 ∧ X 1 < 1 | |
| constructor <;> linarith | |
| theorem path_neighborhood (N n : ℕ) (c : A.Instruction n) (hn : n < N) | |
| (s : ℝ) (X : Coord 2) (hX : ∀ i, |X i-path A N n c s i| ≤ 3*radius A N) : | |
| X ∈ chartSet := by | |
| have hb := path_bounds A N n c hn s | |
| have hR : 3*radius A N ≤ (3/65536:ℝ) := by | |
| unfold radius | |
| linarith [scale_small A N] | |
| have hx := abs_le.mp (hX 0) | |
| have hy := abs_le.mp (hX 1) | |
| constructor <;> intro i <;> fin_cases i | |
| · change (1/8:ℝ) ≤ X 0 | |
| linarith [hb.1.1] | |
| · change (1/32:ℝ) ≤ X 1 | |
| linarith [hb.2.1] | |
| · change X 0 ≤ (3/8:ℝ) | |
| linarith [hb.1.2] | |
| · change X 1 ≤ (3/4:ℝ) | |
| linarith [hb.2.2] | |
| theorem stage_support (N n : ℕ) (hn : n < N) (s : ℝ) (X : Coord 2) | |
| (hX : stage A N n s X ≠ 0) : X ∈ chartSet := by | |
| unfold stage at hX | |
| obtain ⟨c,_,hc⟩ := Finset.exists_ne_zero_of_sum_ne_zero hX | |
| apply path_neighborhood A N n c hn s X | |
| intro i | |
| apply le_of_lt | |
| by_contra hi | |
| exact hc (TranslationGates.field_zero_outside (radius_pos A N) _ _ _ ⟨i,not_lt.mp hi⟩) | |
| def finiteField (N : ℕ) : VectorField 2 := fun s X => ∑ n ∈ Finset.range N, stage A N n s X | |
| @[fun_prop] theorem contDiff_prefix (N : ℕ) : ContDiff ℝ ∞ (uncurry (finiteField A N)) := by | |
| unfold finiteField | |
| exact ContDiff.sum (fun n _ => contDiff_stage A N n) | |
| theorem prefix_divergence (N : ℕ) (s : ℝ) (X : Coord 2) : | |
| divergence (finiteField A N) s X = 0 := by | |
| unfold finiteField | |
| rw [divergence_sum] | |
| · apply Finset.sum_eq_zero | |
| intro n _ | |
| exact stage_divergence A N n s X | |
| · intro n _ t | |
| exact contDiff_slice (contDiff_stage A N n) t | |
| theorem prefix_support (N : ℕ) (s : ℝ) (X : Coord 2) (hX : finiteField A N s X ≠ 0) : | |
| X ∈ chartSet := by | |
| unfold finiteField at hX | |
| obtain ⟨n,hn,h⟩ := Finset.exists_ne_zero_of_sum_ne_zero hX | |
| exact stage_support A N n (Finset.mem_range.mp hn) s X h | |
| theorem prefix_zero_before (N : ℕ) {s : ℝ} (hs : s ≤ 0) (X : Coord 2) : | |
| finiteField A N s X = 0 := by | |
| unfold finiteField | |
| apply Finset.sum_eq_zero | |
| intro n _ | |
| exact stage_zero_before A N n (hs.trans (Nat.cast_nonneg _)) X | |
| theorem prefix_zero_after (N : ℕ) {s : ℝ} (hs : N ≤ s) (X : Coord 2) : | |
| finiteField A N s X = 0 := by | |
| unfold finiteField | |
| apply Finset.sum_eq_zero | |
| intro n hn | |
| apply stage_zero_after A N n _ X | |
| have h : (n:ℝ)+1 ≤ N := by exact_mod_cast Finset.mem_range.mp hn | |
| exact h.trans hs | |
| theorem prefix_eq_stage (N n : ℕ) (hn : n < N) {s : ℝ} (hs : s ∈ Icc (n:ℝ) (n+1)) | |
| (X : Coord 2) : finiteField A N s X = stage A N n s X := by | |
| unfold finiteField | |
| apply Finset.sum_eq_single n | |
| · intro k _ hkn | |
| rcases lt_or_gt_of_ne hkn with h | h | |
| · apply stage_zero_after A N k _ X | |
| have hh : (k:ℝ)+1 ≤ n := by exact_mod_cast h | |
| exact hh.trans hs.1 | |
| · apply stage_zero_before A N k _ X | |
| have hh : (n:ℝ)+1 ≤ k := by exact_mod_cast h | |
| exact hs.2.trans hh | |
| · exact fun h => (h (Finset.mem_range.mpr hn)).elim | |
| theorem compactSupport_prefix (N : ℕ) : HasCompactSupport (uncurry (finiteField A N)) := by | |
| apply HasCompactSupport.of_support_subset_isCompact (isCompact_Icc.prod compact_chartSet) | |
| intro q hq | |
| refine ⟨⟨?_,?_⟩,prefix_support A N q.1 q.2 hq⟩ | |
| · exact (lt_of_not_ge (fun h => hq (prefix_zero_before A N h q.2))).le | |
| · exact (lt_of_not_ge (fun h => hq (prefix_zero_after A N h q.2))).le | |
| def periodicPrefix (N : ℕ) : VectorField 2 := Periodization.extend (finiteField A N) | |
| @[fun_prop] theorem contDiff_periodicPrefix (N : ℕ) : | |
| ContDiff ℝ ∞ (uncurry (periodicPrefix A N)) := by | |
| apply contDiff_extend (C := 1) (contDiff_prefix A N) | |
| intro s X hX i | |
| have hi := chartSet_interior (prefix_support A N s X hX) i | |
| rw [abs_of_pos hi.1] | |
| exact hi.2.le | |
| theorem periodic_periodicPrefix (N : ℕ) (s : ℝ) : | |
| FactorsThrough (periodicPrefix A N s) PeriodicSpace.cover := periodic_extend _ _ | |
| theorem periodicPrefix_chart (N : ℕ) (s : ℝ) {X : Coord 2} | |
| (hX : ∀ i, X i ∈ Icc (0:ℝ) 1) : periodicPrefix A N s X = finiteField A N s X := by | |
| apply extend_eq_chart _ s hX | |
| intro t Y hY | |
| exact chartSet_interior (prefix_support A N t Y hY) | |
| theorem periodicPrefix_plateau (N n : ℕ) (c : A.Instruction n) (hn : n < N) | |
| {s : ℝ} (hs : s ∈ Icc (n:ℝ) (n+1)) (X : Coord 2) | |
| (hX : ∀ i, |X i - path A N n c s i| ≤ radius A N) : | |
| periodicPrefix A N s X = deriv (path A N n c) s := by | |
| have hK := path_neighborhood A N n c hn s X | |
| (fun i => (hX i).trans (by linarith [radius_pos A N])) | |
| rw [periodicPrefix_chart A N s (fun i => ⟨(chartSet_interior hK i).1.le, | |
| (chartSet_interior hK i).2.le⟩),prefix_eq_stage A N n hn hs X] | |
| exact stage_plateau A N n c s X hX | |
| end VelocityDetection.ChartRouting | |
| end | |
| end OAI | |