openAI-math-dataset / lean /OAI /MathematicalPhysics /NavierStokes /ForcedComputation /Programs /BalancedActivation.lean
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.BalancedBody | |
| namespace OAI | |
| /-! A computable time cutoff starts the machine-only periodic body. It changes | |
| only during the final empty part of the preceding period, so the body is | |
| exactly zero before one and exactly periodic from one onward. -/ | |
| noncomputable section | |
| namespace ForcedComputation.BalancedBody | |
| open ShearFlows Recorder.Planar PlanarHamiltonian Set | |
| open scoped ContDiff | |
| def activationStart (n : ℕ) : ℚ := 1 - 1 / (4 * ((n : ℚ) + 1)) | |
| def activationFinish (n : ℕ) : ℚ := 1 - 1 / (8 * ((n : ℚ) + 1)) | |
| theorem activation_intervals (n : ℕ) : | |
| 0 < activationStart n ∧ activationStart n < activationFinish n ∧ activationFinish n < 1 := by | |
| have hn : (0 : ℚ) < n + 1 := by positivity | |
| have h₄ : (0 : ℚ) < 4 * (n + 1) := by positivity | |
| have h₈ : (0 : ℚ) < 8 * (n + 1) := by positivity | |
| refine ⟨?_, ?_, ?_⟩ | |
| · unfold activationStart | |
| have h : 1 / (4 * ((n : ℚ) + 1)) < 1 := (div_lt_one h₄).mpr (by nlinarith [Nat.cast_nonneg (α := ℚ) n]) | |
| linarith | |
| · unfold activationStart activationFinish | |
| have h : 1 / (8 * ((n : ℚ) + 1)) < 1 / (4 * ((n : ℚ) + 1)) := | |
| one_div_lt_one_div_of_lt h₄ (by nlinarith) | |
| linarith | |
| · unfold activationFinish | |
| have h : (0 : ℚ) < 1 / (8 * (n + 1)) := by positivity | |
| linarith | |
| theorem finish_le_activationStart {n : ℕ} (i : Fin n) : | |
| PlanarTiming.finish i ≤ activationStart n := by | |
| have hn : (0 : ℚ) < (n : ℚ) + 1 := by positivity | |
| have hi : (i.val : ℚ) + 1 ≤ n := by exact_mod_cast i.isLt | |
| unfold PlanarTiming.finish activationStart | |
| apply (le_sub_iff_add_le).mpr | |
| apply (mul_le_mul_iff_left₀ (by positivity : (0 : ℚ) < 4 * (n + 1))).mp | |
| field_simp | |
| nlinarith | |
| def bodyLength (M : Alternating.Machine) (hM : M.WellFormed) : ℕ := | |
| (actions (freshMachine M) (freshInput_valid (BalancedPlanar.referenceValid hM)).1).length | |
| def activation (M : Alternating.Machine) (hM : M.WellFormed) : ℝ → ℝ := | |
| smoothRamp (activationStart (bodyLength M hM)) (activationFinish (bodyLength M hM)) | |
| def activated (M : Alternating.Machine) (hM : M.WellFormed) : Velocity := | |
| fun y => activation M hM y.1 • velocity M hM y | |
| theorem raw_late_zero (M : Alternating.Machine) (hM : M.WellFormed) {t : ℝ} | |
| (ht : t ∈ Icc (activationStart (bodyLength M hM) : ℝ) 1) (x : Space) : | |
| raw M hM (t, x) = 0 := by | |
| have hn := activation_intervals (bodyLength M hM) | |
| have ht0 : 0 ≤ t := (Rat.cast_nonneg.mpr hn.1.le).trans ht.1 | |
| have hp : BalancedPlanar.bodyVelocity M hM t (horizontal x) = 0 := by | |
| rw [show BalancedPlanar.bodyVelocity M hM = | |
| PlanarHamiltonian.periodicVelocity | |
| (normalizedPulse (BalancedPlanar.referenceInput M) (BalancedPlanar.referenceValid hM)) from rfl] | |
| rw [periodicVelocity_on_unit | |
| (normalizedPulse_valid (BalancedPlanar.referenceInput M) (BalancedPlanar.referenceValid hM)) | |
| (normalizedPulse_inUnit (BalancedPlanar.referenceInput M) (BalancedPlanar.referenceValid hM)) ⟨ht0, ht.2⟩, | |
| processorVelocity_eq_sum] | |
| apply Finset.sum_eq_zero | |
| intro i _ | |
| have hfi : ((normalizedPulse (BalancedPlanar.referenceInput M) | |
| (BalancedPlanar.referenceValid hM) i).finish : ℝ) ≤ t := by | |
| exact (Rat.cast_le.mpr (finish_le_activationStart i)).trans ht.1 | |
| have hab := (normalizedPulse_valid (BalancedPlanar.referenceInput M) | |
| (BalancedPlanar.referenceValid hM) i).2 | |
| rw [Pulse.velocity, smoothPulse_after (by exact_mod_cast hab) hfi, zero_smul] | |
| simp only [raw, CompactLift.velocity, CompactLift.spatial, VelocityDetector.triangularLift, | |
| VelocityDetector.horizontalLinear_eq, hp, map_zero, zero_smul, add_zero, smul_zero] | |
| theorem velocity_late_zero (M : Alternating.Machine) (hM : M.WellFormed) {t : ℝ} | |
| (ht : t ∈ Icc (activationStart (bodyLength M hM) : ℝ) 1) (x : Space) : | |
| velocity M hM (t, x) = 0 := by | |
| change BalancedStretch.stretch (raw M hM (t, BalancedStretch.stretch.symm x)) = 0 | |
| rw [raw_late_zero M hM ht, map_zero] | |
| theorem activated_before (M : Alternating.Machine) (hM : M.WellFormed) {t : ℝ} | |
| (ht : t ≤ 1) (x : Space) : activated M hM (t, x) = 0 := by | |
| by_cases ha : t ≤ (activationStart (bodyLength M hM) : ℝ) | |
| · rw [activated, activation, smoothRamp_before | |
| (by exact_mod_cast (activation_intervals (bodyLength M hM)).2.1) ha, zero_smul] | |
| · rw [activated, velocity_late_zero M hM ⟨(lt_of_not_ge ha).le, ht⟩, smul_zero] | |
| theorem activated_tail (M : Alternating.Machine) (hM : M.WellFormed) {t : ℝ} | |
| (ht : 1 ≤ t) (x : Space) : activated M hM (t, x) = velocity M hM (t, x) := by | |
| rw [activated, activation, smoothRamp_after | |
| (by exact_mod_cast (activation_intervals (bodyLength M hM)).2.1), one_smul] | |
| have hfinish : (activationFinish (bodyLength M hM) : ℝ) ≤ 1 := by | |
| exact_mod_cast (activation_intervals (bodyLength M hM)).2.2.le | |
| exact hfinish.trans ht | |
| theorem activated_smooth (M : Alternating.Machine) (hM : M.WellFormed) : | |
| ContDiff ℝ ∞ (activated M hM) := | |
| ((smoothRamp_smooth _ _).comp contDiff_fst).smul (velocity_smooth M hM) | |
| theorem activated_support (M : Alternating.Machine) (hM : M.WellFormed) (t : ℝ) : | |
| tsupport (fun x => activated M hM (t, x)) ⊆ support := | |
| (tsupport_smul_subset_right _ _).trans (velocity_support M hM t) | |
| theorem activated_bounded (M : Alternating.Machine) (hM : M.WellFormed) : | |
| BoundedMixedDerivatives (activated M hM) := | |
| boundedMixed_of_compact_tail (activated_smooth M hM) (velocity_smooth M hM) | |
| support_compact (activated_support M hM) (velocity_support M hM) (velocity_periodic M hM) | |
| (fun _ ht x => activated_before M hM (by linarith) x) | |
| (fun _ ht x => activated_tail M hM ht.le x) | |
| end ForcedComputation.BalancedBody | |
| end | |
| end OAI | |