| import OAI.Dynamics.TriangleBilliards.SpatialSmoothing |
|
|
| namespace OAI |
|
|
| open MeasureTheory Set |
| open scoped ENNReal symmDiff |
| noncomputable section |
| open MeasureTheory Set Filter Function Metric |
| open scoped Topology Convolution ContDiff |
| noncomputable section |
|
|
| namespace TriangularBilliards |
| open SpatialSmoothing |
|
|
| abbrev SmoothPhase := Phase × ZMod 2 |
|
|
| / |
| def directS (Q : Triangle) (ε : ℝ) (f : SmoothPhase → ℂ) |
| (b : ZMod 2) (v : Circle) (x : ℂ) : ℂ := |
| ∫ y in Q.table, kernel ε (x - y) • f ((y, v), b) |
|
|
| / |
| def reflectedS (Q : Triangle) (i : Fin 3) (ε : ℝ) (f : SmoothPhase → ℂ) |
| (b : ZMod 2) (v : Circle) (x : ℂ) : ℂ := |
| ∫ y in Q.table, kernel ε (x - wallReflection Q i y) • |
| f ((y, reflectedDirection Q i v), b + 1) |
|
|
| / |
| vertices, at most one reflected term can contribute. This fact is proved |
| geometrically instead of assuming a chart or an injectivity-radius bound. -/ |
| def reflectedSmoothing (Q : Triangle) (ε : ℝ) (f : SmoothPhase → ℂ) : SmoothPhase → ℂ := |
| fun z => directS Q ε f z.2 z.1.2 z.1.1 + |
| ∑ i : Fin 3, reflectedS Q i ε f z.2 z.1.2 z.1.1 |
|
|
| lemma reflectedDirection_involutive (Q : Triangle) (i : Fin 3) (v : Circle) : |
| reflectedDirection Q i (reflectedDirection Q i v) = v := by |
| apply Subtype.ext |
| exact reflect_involutive (Q.tangent_ne_zero i) v |
|
|
| lemma wallReflection_isometry (Q : Triangle) (i : Fin 3) : Isometry (wallReflection Q i) := by |
| apply isometry_iff_dist_eq.mpr |
| intro x y |
| rw [dist_eq_norm, wallReflection_sub, reflect_norm (Q.tangent_ne_zero i), dist_eq_norm] |
|
|
| lemma kernel_wall_pair (Q : Triangle) (i : Fin 3) (ε : ℝ) (x y : ℂ) : |
| kernel ε (wallReflection Q i x - wallReflection Q i y) = kernel ε (x - y) := by |
| rw [wallReflection_sub] |
| exact kernel_radial ε (reflect_norm (Q.tangent_ne_zero i) _) |
|
|
| lemma kernel_wall_transfer (Q : Triangle) (i : Fin 3) (ε : ℝ) (x y : ℂ) : |
| kernel ε (wallReflection Q i x - y) = kernel ε (x - wallReflection Q i y) := by |
| have h := kernel_wall_pair Q i ε x (wallReflection Q i y) |
| rwa [wallReflection_involutive] at h |
|
|
| lemma seamS_equivariant (Q : Triangle) (i : Fin 3) (ε : ℝ) (f : SmoothPhase → ℂ) |
| (b : ZMod 2) (v : Circle) (x : ℂ) : |
| directS Q ε f (b + 1) (reflectedDirection Q i v) (wallReflection Q i x) + |
| reflectedS Q i ε f (b + 1) (reflectedDirection Q i v) (wallReflection Q i x) = |
| directS Q ε f b v x + reflectedS Q i ε f b v x := by |
| simp only [directS, reflectedS, kernel_wall_transfer, wallReflection_involutive, |
| reflectedDirection_involutive] |
| have hb : (b + 1) + 1 = b := by |
| rw [add_assoc, show (1 : ZMod 2) + 1 = 0 by decide, add_zero] |
| rw [hb, add_comm] |
|
|
| namespace Triangle |
|
|
| def coordCLM (Q : Triangle) (i : Fin 3) : ℂ →L[ℝ] ℝ := |
| (Q.basis.coord i).linear.toContinuousLinearMap |
|
|
| lemma coord_sub (Q : Triangle) (i : Fin 3) (x y : ℂ) : |
| Q.basis.coord i x - Q.basis.coord i y = Q.coordCLM i (x - y) := by |
| exact ((Q.basis.coord i).linearMap_vsub x y).symm |
|
|
| def coordinateBound (Q : Triangle) : ℝ := ∑ i, ‖Q.coordCLM i‖ |
|
|
| lemma coordinateBound_nonneg (Q : Triangle) : 0 ≤ Q.coordinateBound := |
| Finset.sum_nonneg (fun _ _ => norm_nonneg _) |
|
|
| lemma coord_norm_le (Q : Triangle) (i : Fin 3) (x y : ℂ) : |
| |Q.basis.coord i x - Q.basis.coord i y| ≤ Q.coordinateBound * ‖x - y‖ := by |
| rw [Q.coord_sub, ← Real.norm_eq_abs] |
| apply (Q.coordCLM i).le_opNorm _ |>.trans |
| gcongr |
| exact Finset.single_le_sum (fun j _ => norm_nonneg (Q.coordCLM j)) (Finset.mem_univ i) |
|
|
| lemma coord_wallReflection (Q : Triangle) (i : Fin 3) (x : ℂ) : |
| Q.basis.coord (i + 2) (wallReflection Q i x) = -Q.basis.coord (i + 2) x := by |
| have hv : Q.basis.coord (i + 2) (Q.vertex i) = 0 := by |
| exact Q.basis.coord_apply (i + 2) i |>.trans (ite_eq_right (by decide +revert)) |
| have h₁ := Q.coord_shift (i + 2) (Q.vertex i) (reflect (Q.tangent i) (x - Q.vertex i)) 1 |
| have h₂ := Q.coord_shift (i + 2) (Q.vertex i) (x - Q.vertex i) 1 |
| rw [one_smul, hv, one_mul, Q.slope_reflect] at h₁ |
| rw [one_smul, add_sub_cancel, hv, one_mul, zero_add] at h₂ |
| change Q.basis.coord (i + 2) (Q.vertex i + reflect (Q.tangent i) (x - Q.vertex i)) = _ |
| linarith |
|
|
| lemma coord_small_of_reflected_near (Q : Triangle) (i : Fin 3) {x y : ℂ} {ε : ℝ} |
| (hy : y ∈ Q.table) (hxy : ‖x - wallReflection Q i y‖ ≤ ε) : |
| Q.basis.coord (i + 2) x ≤ Q.coordinateBound * ε := by |
| have h := Q.coord_norm_le (i + 2) x (wallReflection Q i y) |
| rw [Q.coord_wallReflection] at h |
| have hp := ((Q.table_iff_coords y).mp hy (i + 2)).le |
| have ha := le_abs_self (Q.basis.coord (i + 2) x - -Q.basis.coord (i + 2) y) |
| have hm := mul_le_mul_of_nonneg_left hxy Q.coordinateBound_nonneg |
| linarith |
|
|
| end Triangle |
|
|
| lemma norm_decompose_sq (e : ℂ) (a b : ℝ) : |
| ‖a • e + b • (Complex.I * e)‖ ^ 2 = (a ^ 2 + b ^ 2) * ‖e‖ ^ 2 := by |
| simp only [Complex.sq_norm, Complex.normSq_apply, Complex.add_re, Complex.add_im, |
| Complex.real_smul, Complex.mul_re, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, |
| Complex.I_re, Complex.I_im] |
| ring |
|
|
| lemma reflect_distance_le {e : ℂ} (he : e ≠ 0) (l : ℂ →ₗ[ℝ] ℝ) |
| (hl : l e = 0) (hlI : l (Complex.I * e) ≠ 0) {x y : ℂ} |
| (hxy : 0 ≤ l x * l y) : ‖x - y‖ ≤ ‖x - reflect e y‖ := by |
| obtain ⟨a, b, rfl⟩ := complex_decompose_tangent he x |
| obtain ⟨c, d, rfl⟩ := complex_decompose_tangent he y |
| simp only [map_add, map_smul, smul_eq_mul, hl, mul_zero, zero_add] at hxy |
| have hbd : 0 ≤ b * d := by |
| nlinarith [sq_pos_of_ne_zero hlI] |
| rw [reflect_add, reflect_real_smul, reflect_real_smul, reflect_tangent he, reflect_normal he] |
| have hsub : a • e + b • (Complex.I * e) - (c • e + d • (Complex.I * e)) = |
| (a - c) • e + (b - d) • (Complex.I * e) := by module |
| have href : a • e + b • (Complex.I * e) - (c • e + d • -(Complex.I * e)) = |
| (a - c) • e + (b + d) • (Complex.I * e) := by module |
| rw [hsub, href] |
| have hpos : 0 ≤ ‖e‖ ^ 2 := sq_nonneg ‖e‖ |
| have hn₁ := norm_decompose_sq e (a - c) (b - d) |
| have hn₂ := norm_decompose_sq e (a - c) (b + d) |
| nlinarith [norm_nonneg ((a - c) • e + (b - d) • (Complex.I * e)), |
| norm_nonneg ((a - c) • e + (b + d) • (Complex.I * e)), mul_nonneg hbd hpos] |
|
|
| namespace Triangle |
|
|
| lemma slope_normal_ne_zero (Q : Triangle) (i : Fin 3) : |
| Q.slope (i + 2) (Complex.I * Q.tangent i) ≠ 0 := by |
| intro hz |
| have hall (v : ℂ) : Q.slope (i + 2) v = 0 := by |
| obtain ⟨a, b, rfl⟩ := complex_decompose_tangent (Q.tangent_ne_zero i) v |
| change (Q.basis.coord (i + 2)).linear _ = 0 |
| rw [map_add, map_smul, map_smul] |
| change a * Q.slope (i + 2) (Q.tangent i) + |
| b * Q.slope (i + 2) (Complex.I * Q.tangent i) = 0 |
| rw [Q.slope_tangent_zero, hz, mul_zero, mul_zero, add_zero] |
| have h := Q.coord_sub (i + 2) (Q.vertex (i + 2)) (Q.vertex i) |
| change Q.basis.coord (i + 2) (Q.basis (i + 2)) - |
| Q.basis.coord (i + 2) (Q.basis i) = Q.slope (i + 2) _ at h |
| simp only [Q.basis.coord_apply, ite_eq_right (show i + 2 ≠ i by fin_cases i <;> decide), |
| hall, sub_zero] at h |
| exact one_ne_zero h |
|
|
| / |
| between two points in the closed table. This also controls tip clearance |
| without any injectivity-radius assumption. -/ |
| lemma dist_le_reflected_dist (Q : Triangle) (i : Fin 3) {x y : ℂ} |
| (hx : x ∈ Q.table) (hy : y ∈ Q.table) : |
| ‖x - y‖ ≤ ‖x - wallReflection Q i y‖ := by |
| have hv : Q.basis.coord (i + 2) (Q.vertex i) = 0 := |
| Q.basis.coord_apply (i + 2) i |>.trans (ite_eq_right (by decide +revert)) |
| have he (z : ℂ) : (Q.basis.coord (i + 2)).linear (z - Q.vertex i) = |
| Q.basis.coord (i + 2) z := by |
| have h := Q.coord_sub (i + 2) z (Q.vertex i) |
| rw [hv, sub_zero] at h |
| exact h.symm |
| have h := reflect_distance_le (Q.tangent_ne_zero i) |
| (Q.basis.coord (i + 2)).linear (Q.slope_tangent_zero i) (Q.slope_normal_ne_zero i) |
| (x := x - Q.vertex i) (y := y - Q.vertex i) (by |
| rw [he, he] |
| exact mul_nonneg ((Q.table_iff_coords x).mp hx _).le ((Q.table_iff_coords y).mp hy _).le) |
| rw [sub_sub_sub_cancel_right] at h |
| have hr : x - Q.vertex i - reflect (Q.tangent i) (y - Q.vertex i) = |
| x - wallReflection Q i y := by unfold wallReflection; abel |
| rwa [hr] at h |
|
|
| / |
| def clearance (Q : Triangle) (x : ℂ) : ℝ := Metric.infDist x (range Q.vertex) |
|
|
| lemma clearance_nonneg (Q : Triangle) (x : ℂ) : 0 ≤ Q.clearance x := |
| Metric.infDist_nonneg |
|
|
| lemma clearance_lipschitz (Q : Triangle) : LipschitzWith 1 Q.clearance := |
| Metric.lipschitz_infDist_pt (range Q.vertex) |
|
|
| lemma clearance_le_add (Q : Triangle) (x y : ℂ) : |
| Q.clearance y ≤ Q.clearance x + ‖x - y‖ := by |
| have h := Q.clearance_lipschitz.dist_le_mul y x |
| simp only [NNReal.coe_one, one_mul, dist_eq_norm, Real.norm_eq_abs] at h |
| rw [norm_sub_rev y x] at h |
| have hs := le_abs_self (Q.clearance y - Q.clearance x) |
| linarith |
|
|
| end Triangle |
|
|
| def SpatiallyZero (Q : Triangle) (R : ℝ) (f : SmoothPhase → ℂ) : Prop := |
| ∀ y ∈ Q.table, Q.clearance y < R → ∀ v b, f ((y, v), b) = 0 |
|
|
| lemma directS_zero_near_tips (Q : Triangle) {ε R : ℝ} (hε : 0 < ε) |
| {f : SmoothPhase → ℂ} (hf : SpatiallyZero Q R f) (b : ZMod 2) (v : Circle) |
| {x : ℂ} (hx : Q.clearance x + ε ≤ R) : directS Q ε f b v x = 0 := by |
| apply integral_eq_zero_of_ae |
| filter_upwards [ae_restrict_mem Q.measurableSet_table] with y hy |
| by_cases hk : kernel ε (x - y) = 0 |
| · simp only [hk, zero_smul, Pi.zero_apply] |
| · have hd : ‖x - y‖ < ε := by |
| have hmem : x - y ∈ support (kernel ε) := hk |
| rwa [kernel_support hε, mem_ball_zero_iff] at hmem |
| have hr := Q.clearance_le_add x y |
| have he := hf y hy (by linarith) v b |
| simp only [he, smul_zero, Pi.zero_apply] |
|
|
| lemma reflectedS_zero_near_tips (Q : Triangle) (i : Fin 3) {ε R : ℝ} (hε : 0 < ε) |
| {f : SmoothPhase → ℂ} (hf : SpatiallyZero Q R f) (b : ZMod 2) (v : Circle) |
| {x : ℂ} (hx : x ∈ Q.table) (hr : Q.clearance x + ε ≤ R) : |
| reflectedS Q i ε f b v x = 0 := by |
| apply integral_eq_zero_of_ae |
| filter_upwards [ae_restrict_mem Q.measurableSet_table] with y hy |
| by_cases hk : kernel ε (x - wallReflection Q i y) = 0 |
| · simp only [hk, zero_smul, Pi.zero_apply] |
| · have hd : ‖x - wallReflection Q i y‖ < ε := by |
| have hmem : x - wallReflection Q i y ∈ support (kernel ε) := hk |
| rwa [kernel_support hε, mem_ball_zero_iff] at hmem |
| have hg := Q.dist_le_reflected_dist i hx hy |
| have hr' := Q.clearance_le_add x y |
| have he := hf y hy (by linarith) (reflectedDirection Q i v) (b + 1) |
| simp only [he, smul_zero, Pi.zero_apply] |
|
|
| lemma reflectedSmoothing_zero_near_tips (Q : Triangle) {ε R : ℝ} (hε : 0 < ε) |
| {f : SmoothPhase → ℂ} (hf : SpatiallyZero Q R f) {z : SmoothPhase} |
| (hx : z.1.1 ∈ Q.table) (hr : Q.clearance z.1.1 + ε ≤ R) : |
| reflectedSmoothing Q ε f z = 0 := by |
| rw [reflectedSmoothing, directS_zero_near_tips Q hε hf _ _ hr] |
| simp only [reflectedS_zero_near_tips Q _ hε hf _ _ hx hr, Finset.sum_const_zero, add_zero] |
|
|
| namespace Triangle |
|
|
| def diameterBound (Q : Triangle) : ℝ := ∑ i : Fin 3, ∑ j : Fin 3, ‖Q.vertex i - Q.vertex j‖ |
|
|
| lemma diameterBound_nonneg (Q : Triangle) : 0 ≤ Q.diameterBound := |
| Finset.sum_nonneg (fun _ _ => Finset.sum_nonneg (fun _ _ => norm_nonneg _)) |
|
|
| lemma vertex_dist_le_diameterBound (Q : Triangle) (i j : Fin 3) : |
| ‖Q.vertex i - Q.vertex j‖ ≤ Q.diameterBound := by |
| apply (Finset.single_le_sum (fun k _ => norm_nonneg (Q.vertex i - Q.vertex k)) |
| (Finset.mem_univ j)).trans |
| exact Finset.single_le_sum (fun k _ => Finset.sum_nonneg |
| (fun l _ => norm_nonneg (Q.vertex k - Q.vertex l))) (Finset.mem_univ i) |
|
|
| lemma reconstruct_difference (Q : Triangle) (x : ℂ) (k : Fin 3) : |
| x - Q.vertex k = ∑ j : Fin 3, Q.basis.coord j x • (Q.vertex j - Q.vertex k) := by |
| simp only [smul_sub, Finset.sum_sub_distrib, ← Finset.sum_smul, |
| Q.basis.sum_coord_apply_eq_one, one_smul] |
| have h := Q.basis.linear_combination_coord_eq_self x |
| change ∑ i, Q.basis.coord i x • Q.vertex i = x at h |
| rw [h] |
|
|
| lemma clearance_of_coords_small_nonneg (Q : Triangle) {x : ℂ} |
| (hx : ∀ j, 0 ≤ Q.basis.coord j x) |
| (k : Fin 3) {δ : ℝ} (hδ : 0 ≤ δ) |
| (hc : ∀ i, i ≠ k → Q.basis.coord i x ≤ δ) : |
| Q.clearance x ≤ 3 * Q.diameterBound * δ := by |
| calc |
| Q.clearance x ≤ dist x (Q.vertex k) := |
| Metric.infDist_le_dist_of_mem (mem_range_self k) |
| _ = ‖∑ j : Fin 3, Q.basis.coord j x • (Q.vertex j - Q.vertex k)‖ := by |
| rw [dist_eq_norm, Q.reconstruct_difference] |
| _ ≤ ∑ j : Fin 3, ‖Q.basis.coord j x • (Q.vertex j - Q.vertex k)‖ := norm_sum_le _ _ |
| _ ≤ ∑ _j : Fin 3, δ * Q.diameterBound := by |
| apply Finset.sum_le_sum |
| intro j _ |
| by_cases hj : j = k |
| · simp only [hj, sub_self, smul_zero, norm_zero] |
| exact mul_nonneg hδ Q.diameterBound_nonneg |
| · rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg (hx j)] |
| exact mul_le_mul (hc j hj) (Q.vertex_dist_le_diameterBound j k) |
| (norm_nonneg _) hδ |
| _ = _ := by simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul]; ring |
|
|
| lemma clearance_of_coords_small (Q : Triangle) {x : ℂ} (hx : x ∈ Q.table) |
| (k : Fin 3) {δ : ℝ} (hδ : 0 ≤ δ) |
| (hc : ∀ i, i ≠ k → Q.basis.coord i x ≤ δ) : |
| Q.clearance x ≤ 3 * Q.diameterBound * δ := |
| Q.clearance_of_coords_small_nonneg (fun j => ((Q.table_iff_coords x).mp hx j).le) k hδ hc |
|
|
| / |
| def safetyFactor (Q : Triangle) : ℝ := 3 * Q.diameterBound * Q.coordinateBound + 1 |
|
|
| lemma safetyFactor_pos (Q : Triangle) : 0 < Q.safetyFactor := by |
| unfold safetyFactor |
| have h := mul_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 3) Q.diameterBound_nonneg) |
| Q.coordinateBound_nonneg |
| linarith |
|
|
| lemma unique_nearby_wall (Q : Triangle) {x : ℂ} (hx : x ∈ Q.table) {ε : ℝ} (hε : 0 < ε) |
| (hsafe : Q.safetyFactor * ε < Q.clearance x) {i j : Fin 3} |
| (hi : ∃ y ∈ Q.table, ‖x - wallReflection Q i y‖ ≤ ε) |
| (hj : ∃ y ∈ Q.table, ‖x - wallReflection Q j y‖ ≤ ε) : i = j := by |
| by_contra hij |
| obtain ⟨y, hy, hxy⟩ := hi |
| obtain ⟨z, hz, hxz⟩ := hj |
| have hci := Q.coord_small_of_reflected_near i hy hxy |
| have hcj := Q.coord_small_of_reflected_near j hz hxz |
| let k : Fin 3 := -((i + 2) + (j + 2)) |
| have hfin : ∀ i j l : Fin 3, i ≠ j → |
| l ≠ -((i + 2) + (j + 2)) → l = i + 2 ∨ l = j + 2 := by decide |
| have hcover (l : Fin 3) (hl : l ≠ k) : l = i + 2 ∨ l = j + 2 := |
| hfin i j l hij hl |
| have hh := Q.clearance_of_coords_small hx k |
| (mul_nonneg Q.coordinateBound_nonneg hε.le) (fun l hl => by |
| rcases hcover l hl with h | h |
| · rwa [h] |
| · rwa [h]) |
| unfold safetyFactor at hsafe |
| nlinarith |
|
|
| end Triangle |
|
|
| / |
| def spatialSlice (Q : Triangle) (f : SmoothPhase → ℂ) (b : ZMod 2) (v : Circle) : ℂ → ℂ := |
| Q.table.indicator (fun y => f ((y, v), b)) |
|
|
| def scalarKernelMap : ℂ →L[ℝ] ℝ →L[ℝ] ℂ := |
| (ContinuousLinearMap.lsmul ℝ ℝ).flip |
|
|
| lemma directS_eq_convolution (Q : Triangle) (ε : ℝ) (f : SmoothPhase → ℂ) |
| (b : ZMod 2) (v : Circle) : |
| directS Q ε f b v = convolution (spatialSlice Q f b v) (kernel ε) |
| scalarKernelMap volume := by |
| funext x |
| rw [convolution_def] |
| change (∫ y in Q.table, kernel ε (x - y) • f ((y, v), b)) = |
| ∫ y, kernel ε (x - y) • Q.table.indicator (fun z => f ((z, v), b)) y |
| rw [← integral_indicator Q.measurableSet_table] |
| apply integral_congr_ae |
| exact Filter.Eventually.of_forall fun y => by |
| by_cases hy : y ∈ Q.table <;> simp [indicator_of_mem, indicator_of_notMem, hy] |
|
|
| lemma directS_contDiff (Q : Triangle) {ε : ℝ} (hε : 0 < ε) |
| {f : SmoothPhase → ℂ} {b : ZMod 2} {v : Circle} |
| (hf : IntegrableOn (fun y => f ((y, v), b)) Q.table) : |
| ContDiff ℝ ∞ (directS Q ε f b v) := by |
| rw [directS_eq_convolution] |
| apply (kernel_hasCompactSupport hε).contDiff_convolution_right scalarKernelMap |
| · exact ((integrable_indicator_iff Q.measurableSet_table).mpr hf).locallyIntegrable |
| · exact kernel_contDiff ε |
|
|
| lemma reflectedS_eq_directS (Q : Triangle) (i : Fin 3) (ε : ℝ) |
| (f : SmoothPhase → ℂ) (b : ZMod 2) (v : Circle) : |
| reflectedS Q i ε f b v = |
| directS Q ε f (b + 1) (reflectedDirection Q i v) ∘ wallReflection Q i := by |
| funext x |
| apply integral_congr_ae |
| exact Filter.Eventually.of_forall fun y => by simp only [kernel_wall_transfer] |
|
|
| lemma wallReflection_contDiff (Q : Triangle) (i : Fin 3) : |
| ContDiff ℝ ∞ (wallReflection Q i) := by |
| change ContDiff ℝ ∞ (fun x => Q.vertex i + |
| reflectIsometry (Q.tangent i) (Q.tangent_ne_zero i) (x - Q.vertex i)) |
| exact contDiff_const.add ((reflectIsometry (Q.tangent i) (Q.tangent_ne_zero i)).contDiff.comp |
| (contDiff_id.sub contDiff_const)) |
|
|
| lemma reflectedS_contDiff (Q : Triangle) (i : Fin 3) {ε : ℝ} (hε : 0 < ε) |
| {f : SmoothPhase → ℂ} {b : ZMod 2} {v : Circle} |
| (hf : IntegrableOn (fun y => f ((y, reflectedDirection Q i v), b + 1)) Q.table) : |
| ContDiff ℝ ∞ (reflectedS Q i ε f b v) := by |
| rw [reflectedS_eq_directS] |
| exact (directS_contDiff Q hε hf).comp (wallReflection_contDiff Q i) |
|
|
| / |
| angular slice. No angular regularization, differentiability or boundedness of |
| `f` is required. -/ |
| lemma reflectedSmoothing_contDiff (Q : Triangle) {ε : ℝ} (hε : 0 < ε) |
| {f : SmoothPhase → ℂ} {b : ZMod 2} {v : Circle} |
| (hf : IntegrableOn (fun y => f ((y, v), b)) Q.table) |
| (hfr : ∀ i, IntegrableOn |
| (fun y => f ((y, reflectedDirection Q i v), b + 1)) Q.table) : |
| ContDiff ℝ ∞ (fun x => reflectedSmoothing Q ε f ((x, v), b)) := by |
| exact (directS_contDiff Q hε hf).add |
| (ContDiff.sum fun i _ => reflectedS_contDiff Q i hε (hfr i)) |
|
|
| lemma reflectedS_zero_of_coord (Q : Triangle) (i : Fin 3) {ε : ℝ} (hε : 0 < ε) |
| (f : SmoothPhase → ℂ) (b : ZMod 2) (v : Circle) {x : ℂ} |
| (hx : Q.coordinateBound * ε < Q.basis.coord (i + 2) x) : |
| reflectedS Q i ε f b v x = 0 := by |
| apply integral_eq_zero_of_ae |
| filter_upwards [ae_restrict_mem Q.measurableSet_table] with y hy |
| have hz : kernel ε (x - wallReflection Q i y) = 0 := by |
| by_contra hn |
| have hd : ‖x - wallReflection Q i y‖ < ε := by |
| have hm : x - wallReflection Q i y ∈ support (kernel ε) := hn |
| rwa [kernel_support hε, mem_ball_zero_iff] at hm |
| exact (not_le_of_gt hx) (Q.coord_small_of_reflected_near i hy hd.le) |
| simp only [hz, zero_smul, Pi.zero_apply] |
|
|
| lemma side_other_coord_large (Q : Triangle) {i j : Fin 3} {x : ℂ} |
| (hx : x ∈ Q.side i) (hji : j ≠ i) {ε : ℝ} (hε : 0 < ε) |
| (hsafe : Q.safetyFactor * ε < Q.clearance x) : |
| Q.coordinateBound * ε < Q.basis.coord (j + 2) x := by |
| by_contra hn |
| have hj := le_of_not_gt hn |
| have hi : Q.basis.coord (i + 2) x = 0 := (Q.side_coord_zero_iff hx _).mpr rfl |
| let k : Fin 3 := -((i + 2) + (j + 2)) |
| have hfin : ∀ i j l : Fin 3, i ≠ j → |
| l ≠ -((i + 2) + (j + 2)) → l = i + 2 ∨ l = j + 2 := by decide |
| have hp := mul_nonneg Q.coordinateBound_nonneg hε.le |
| have hb := Q.clearance_of_coords_small_nonneg (Q.side_coords_nonneg hx) k hp (fun l hl => by |
| rcases hfin i j l hji.symm hl with he | he |
| · rw [he, hi]; exact hp |
| · rwa [he]) |
| unfold Triangle.safetyFactor at hsafe |
| nlinarith |
|
|
| / |
| single unfolded two-sheet chart kernel. The assertion holds on a genuine |
| open neighborhood, so all spatial derivatives also glue. -/ |
| lemma reflectedSmoothing_seam_germ (Q : Triangle) {i : Fin 3} {q : ℂ} |
| (hq : q ∈ Q.side i) {ε : ℝ} (hε : 0 < ε) |
| (hsafe : Q.safetyFactor * ε < Q.clearance q) |
| (f : SmoothPhase → ℂ) (b : ZMod 2) (v : Circle) : |
| ∀ᶠ x in nhds q, |
| reflectedSmoothing Q ε f ((wallReflection Q i x, reflectedDirection Q i v), b + 1) = |
| reflectedSmoothing Q ε f ((x, v), b) := by |
| have hc (j : Fin 3) : Continuous (fun x => Q.basis.coord (j + 2) x) := |
| (Q.basis.coord (j + 2)).continuous_of_finiteDimensional |
| have he (j : Fin 3) : ∀ᶠ x in nhds q, j ≠ i → |
| Q.coordinateBound * ε < Q.basis.coord (j + 2) x ∧ |
| Q.coordinateBound * ε < Q.basis.coord (j + 2) (wallReflection Q i x) := by |
| by_cases hj : j = i |
| · exact Filter.Eventually.of_forall fun _ h => (h hj).elim |
| · have hh := side_other_coord_large Q hq hj hε hsafe |
| have h₁ := (hc j).continuousAt.eventually (Ioi_mem_nhds hh) |
| have hh' : Q.coordinateBound * ε < Q.basis.coord (j + 2) (wallReflection Q i q) := by |
| rwa [wallReflection_fixed_side Q hq] |
| have h₂ := ((hc j).comp (wallReflection_contDiff Q i).continuous).continuousAt |
| (x := q) |>.eventually (Ioi_mem_nhds hh') |
| filter_upwards [h₁, h₂] with x h₁ h₂ using fun _ => ⟨h₁, h₂⟩ |
| have hall := (Filter.eventually_all.mpr he) |
| filter_upwards [hall] with x hx |
| have hsum (b : ZMod 2) (v : Circle) {y : ℂ} |
| (hy : ∀ j, j ≠ i → Q.coordinateBound * ε < Q.basis.coord (j + 2) y) : |
| (∑ j : Fin 3, reflectedS Q j ε f b v y) = reflectedS Q i ε f b v y := by |
| apply Finset.sum_eq_single i |
| · intro j _ hj |
| exact reflectedS_zero_of_coord Q j hε f b v (hy j hj) |
| · simp |
| simp only [reflectedSmoothing, hsum b v (fun j hj => (hx j hj).1), |
| hsum (b + 1) (reflectedDirection Q i v) (fun j hj => (hx j hj).2)] |
| exact seamS_equivariant Q i ε f b v x |
|
|
| lemma directS_fderiv (Q : Triangle) {ε : ℝ} (hε : 0 < ε) |
| {f : SmoothPhase → ℂ} {b : ZMod 2} {v : Circle} |
| (hf : IntegrableOn (fun y => f ((y, v), b)) Q.table) (x : ℂ) : |
| fderiv ℝ (directS Q ε f b v) x = |
| ∫ y in Q.table, (fderiv ℝ (kernel ε) (x - y)).smulRight (f ((y, v), b)) := by |
| rw [directS_eq_convolution] |
| have hi : LocallyIntegrable (spatialSlice Q f b v) volume := |
| ((integrable_indicator_iff Q.measurableSet_table).mpr hf).locallyIntegrable |
| rw [((kernel_hasCompactSupport hε).hasFDerivAt_convolution_right scalarKernelMap hi |
| ((kernel_contDiff ε).of_le (by simp)) x).fderiv, convolution_def] |
| rw [← integral_indicator Q.measurableSet_table] |
| apply integral_congr_ae |
| exact Filter.Eventually.of_forall fun y => by |
| by_cases hy : y ∈ Q.table |
| · simp only [spatialSlice, indicator_of_mem hy] |
| rfl |
| · simp only [spatialSlice, indicator_of_notMem hy, map_zero, zero_apply] |
|
|
| lemma kernel_lintegral {ε : ℝ} (hε : 0 < ε) : |
| ∫⁻ x : ℂ, ENNReal.ofReal (kernel ε x) = 1 := by |
| rw [← ofReal_integral_eq_lintegral_ofReal (kernel_integrable hε) |
| (Filter.Eventually.of_forall (kernel_nonneg ε)), kernel_integral hε, ENNReal.ofReal_one] |
|
|
| lemma kernel_row_bound (Q : Triangle) {ε : ℝ} (hε : 0 < ε) (x : ℂ) : |
| ∫⁻ y in Q.table, ENNReal.ofReal (kernel ε (x - y)) ≤ 1 := by |
| calc |
| _ ≤ ∫⁻ y : ℂ, ENNReal.ofReal (kernel ε (x - y)) := |
| lintegral_mono' Measure.restrict_le_self (fun _ => le_rfl) |
| _ = 1 := (lintegral_sub_left_eq_self (fun y : ℂ => ENNReal.ofReal (kernel ε y)) x).trans |
| (kernel_lintegral hε) |
|
|
| lemma kernel_col_bound (Q : Triangle) {ε : ℝ} (hε : 0 < ε) (y : ℂ) : |
| ∫⁻ x in Q.table, ENNReal.ofReal (kernel ε (x - y)) ≤ 1 := by |
| calc |
| _ ≤ ∫⁻ x : ℂ, ENNReal.ofReal (kernel ε (x - y)) := |
| lintegral_mono' Measure.restrict_le_self (fun _ => le_rfl) |
| _ = 1 := (lintegral_sub_right_eq_self (fun x : ℂ => ENNReal.ofReal (kernel ε x)) y).trans |
| (kernel_lintegral hε) |
|
|
| lemma reflected_kernel_row_bound (Q : Triangle) (i : Fin 3) |
| {ε : ℝ} (hε : 0 < ε) (x : ℂ) : |
| ∫⁻ y in Q.table, ENNReal.ofReal (kernel ε (x - wallReflection Q i y)) ≤ 1 := by |
| simp_rw [← kernel_wall_transfer] |
| exact kernel_row_bound Q hε _ |
|
|
| lemma reflected_kernel_col_bound (Q : Triangle) (i : Fin 3) |
| {ε : ℝ} (hε : 0 < ε) (y : ℂ) : |
| ∫⁻ x in Q.table, ENNReal.ofReal (kernel ε (x - wallReflection Q i y)) ≤ 1 := |
| kernel_col_bound Q hε _ |
|
|
| end TriangularBilliards |
|
|
| end |
| end |
|
|
| end OAI |
|
|
