| import OAI.Geometry.CylinderCovering.Physical.UnitEdgeFootprintsDefinitions |
| import OAI.Geometry.CylinderCovering.Radial.Projection |
| import OAI.Geometry.CylinderCovering.Footprints.Containment |
| import OAI.Geometry.CylinderCovering.Radial.Riemann |
|
|
| namespace OAI |
|
|
| open Set MeasureTheory |
| open scoped InnerProductSpace |
|
|
| noncomputable section |
| namespace CylinderCovering.UnitEdgeFootprints |
| open TriangularCovering |
|
|
| private def e : Space := !₂[1, 0, 0] |
| private def a : Space := !₂[0, 0, height] |
| private def b : Space := !₂[0, 1, 0] |
| private def velocity (η m : ℝ) : Space := |
| !₂[0, η * (1 / 4 + m ^ 2), 2 * height * η * m] |
|
|
| lemma height_pos : 0 < height := by unfold height; positivity |
| lemma height_sq : height ^ 2 = 1 / 2 := by norm_num [height, div_pow] |
|
|
| private lemma normal_unit : ‖e‖ = 1 := by |
| rw [← Real.sqrt_sq (norm_nonneg _), EuclideanSpace.real_norm_sq_eq] |
| norm_num [e, Fin.sum_univ_succ] |
|
|
| private lemma normal_a : inner ℝ e a = 0 := by simp [inner_coord, e, a] |
| private lemma normal_b : inner ℝ e b = 0 := by simp [inner_coord, e, b] |
| private lemma normal_velocity (η m : ℝ) : inner ℝ e (velocity η m) = 0 := by |
| simp [inner_coord, e, velocity] |
|
|
| private lemma raw_eq (η m : ℝ) : e + velocity η m = rawDirection η m := by |
| ext i |
| fin_cases i <;> simp [e, velocity, rawDirection] |
|
|
| private lemma chart_eq (u v : ℝ) : (0 : Space) + u • a + v • b = intercept u v := by |
| ext i |
| fin_cases i <;> simp [a, b, intercept] |
| ring |
|
|
| private lemma gram_factor : |
| Real.sqrt (inner ℝ a a * inner ℝ b b - (inner ℝ a b) ^ 2) = height := by |
| simp only [inner_coord, a, b] |
| dsimp |
| ring_nf |
| exact Real.sqrt_sq height_pos.le |
|
|
| private lemma velocity_norm_sq (η m : ℝ) : |
| ‖velocity η m‖ ^ 2 = η ^ 2 * ((1 / 4 + m ^ 2) ^ 2 + 2 * m ^ 2) := by |
| rw [EuclideanSpace.real_norm_sq_eq] |
| simp [velocity, Fin.sum_univ_succ] |
| nlinarith only [height_sq] |
|
|
| private lemma triangle_eq (η d M m : ℝ) : |
| triangle |
| (0 + (-η * d) • a + (m * (-η * d)) • b) |
| (0 + (M + η * d) • a + (m * (M + η * d) - d / 2 * ((M + η * d) - (-η * d))) • b) |
| (0 + (M + η * d) • a + (m * (M + η * d) + d / 2 * ((M + η * d) - (-η * d))) • b) = |
| foot η d M m := by |
| rw [chart_eq, chart_eq, chart_eq] |
| have hr : (M + η * d) - (-η * d) = M + 2 * η * d := by ring |
| rw [hr] |
| rfl |
|
|
| theorem local_realization : LocalRealizationStatement := by |
| intro η d M m hη hd hM |
| let l := -η * d |
| let r := M + η * d |
| have hlr : l < r := by dsimp [l, r]; nlinarith [mul_pos hη hd] |
| have hκ : 0 < Real.sqrt (inner ℝ a a * inner ℝ b b - (inner ℝ a b) ^ 2) := by |
| rw [gram_factor]; exact height_pos |
| have hcross := RadialProjection.collar_projection_nondegenerate 0 e a b (velocity η m) |
| l r m d normal_unit normal_a normal_b (normal_velocity η m) hd hlr hκ |
| let P := (0 : Space) + l • a + (m * l) • b |
| let Q := (0 : Space) + r • a + (m * r - d / 2 * (r - l)) • b |
| let R := (0 : Space) + r • a + (m * r + d / 2 * (r - l)) • b |
| let C := projectedCylinder (unit (e + velocity η m)) |
| (unit_norm (RadialProjection.sideways_ne_zero normal_unit (normal_velocity η m))) P Q R hcross |
| refine ⟨C, ?_, ?_, ?_, ?_⟩ |
| · change unit (e + velocity η m) = axis η m |
| rw [raw_eq] |
| rfl |
| · change projection (unit (e + velocity η m)) '' triangle P Q R = base η d M m |
| rw [raw_eq] |
| change projection (axis η m) '' triangle P Q R = _ |
| unfold P Q R l r |
| rw [triangle_eq] |
| rfl |
| · change area (projection (unit (e + velocity η m)) '' triangle P Q R) = _ |
| have ha := RadialProjection.collar_projection_area 0 e a b (velocity η m) |
| l r m d normal_unit normal_a normal_b (normal_velocity η m) hd.le |
| rw [gram_factor, velocity_norm_sq] at ha |
| rw [ha] |
| unfold areaFormula l r |
| congr 2 |
| ring |
| · intro s ρ x hsm hρ0 hρM hx |
| let u := ρ + 2 * η * x * (s - m) |
| let v := s * ρ + η * x * (s ^ 2 - m ^ 2) |
| have huv := FootprintContainment.unit_edge_triangle hη.le hd.le hx hsm hρ0 hρM |
| (show u = ρ + 2 * η * x * (s - m) by rfl) |
| (show v - m * u = (s - m) * ρ + η * x * (s - m) ^ 2 by dsimp [u, v]; ring) |
| have hp : (0 : Space) + u • a + v • b ∈ triangle P Q R := by |
| rw [← RadialProjection.coordinate_region_image 0 a b hlr hd] |
| refine ⟨(u, v), ?_, rfl⟩ |
| exact ⟨huv.1, huv.2.1, by simpa only [l, sub_neg_eq_add, neg_mul] using huv.2.2⟩ |
| apply projectedCylinder_mem_direction (e + velocity η m) |
| (RadialProjection.sideways_ne_zero normal_unit (normal_velocity η m)) P Q R hcross hp x |
| ext i |
| fin_cases i <;> simp [representedPoint, e, a, b, velocity, u, v] <;> ring |
|
|
| lemma mesh_eq (N : ℕ) : mesh N = 1 / (N : ℝ) := by |
| norm_num [mesh, RadialRiemann.step] |
|
|
| lemma midpoint_mem (N : ℕ) (i : Fin N) : |
| midpoint N i ∈ RadialRiemann.cell (-1 / 2) (1 / 2) N i := by |
| have hd := RadialRiemann.step_pos (by norm_num : (-1 / 2 : ℝ) < 1 / 2) |
| (Nat.zero_lt_of_lt i.isLt) |
| have hs := RadialRiemann.point_succ (-1 / 2 : ℝ) (1 / 2) N i |
| change _ ≤ _ ∧ _ ≤ _ |
| unfold midpoint |
| constructor <;> linarith |
|
|
| lemma midpoint_bound {N : ℕ} {i : Fin N} {s : ℝ} |
| (hs : s ∈ RadialRiemann.cell (-1 / 2) (1 / 2) N i) : |
| |s - midpoint N i| ≤ mesh N / 2 := by |
| have hi := RadialRiemann.point_succ (-1 / 2 : ℝ) (1 / 2) N i |
| rw [abs_le] |
| unfold midpoint mesh |
| constructor <;> linarith [hs.1, hs.2] |
|
|
| theorem sourceCap_continuous (η : ℝ) : Continuous (sourceCap η) := by |
| unfold sourceCap |
| fun_prop |
|
|
| theorem sourceCap_pos (η s : ℝ) : 0 < sourceCap η s := by |
| unfold sourceCap |
| apply Real.sqrt_pos.mpr |
| positivity |
|
|
| theorem family_realization : FamilyRealizationStatement := by |
| intro η hη R hR hR0 |
| have hab : (-1 / 2 : ℝ) < 1 / 2 := by norm_num |
| have hex : ∀ N (i : Fin N), ∃ C : TriCylinder, |
| C.axis = axis η (midpoint N i) ∧ |
| C.base = base η (mesh N) (maximumCap R N i) (midpoint N i) ∧ |
| area C.base = areaFormula η (mesh N) (maximumCap R N i) (midpoint N i) ∧ |
| ∀ s ρ x : ℝ, |s - midpoint N i| ≤ mesh N / 2 → 0 ≤ ρ → |
| ρ ≤ maximumCap R N i → |x| ≤ 1 / 2 → representedPoint η s ρ x ∈ C.carrier := by |
| intro N i |
| exact local_realization η (mesh N) (maximumCap R N i) (midpoint N i) hη |
| (RadialRiemann.step_pos hab (Nat.zero_lt_of_lt i.isLt)) |
| (RadialRiemann.capMax_nonneg hab hR hR0 i) |
| choose C haxis hbase harea hmem using hex |
| refine ⟨C, fun N i => ⟨haxis N i, hbase N i, harea N i⟩, ?_, ?_⟩ |
| · intro N hN z hz |
| obtain ⟨s, hs, ρ, hρ, x, hx, rfl⟩ := hz |
| obtain ⟨i, hi⟩ := RadialRiemann.exists_cell hN hs |
| refine ⟨i, hmem N i s ρ x (midpoint_bound hi) hρ.1 ?_ hx⟩ |
| exact hρ.2.trans (RadialRiemann.le_capMax hab hR hi) |
| · have hvel : ContinuousOn (velocity η) (Set.Icc (-1 / 2 : ℝ) (1 / 2)) := by |
| apply Continuous.continuousOn |
| unfold velocity |
| fun_prop |
| have hlim := RadialRiemann.physical_collar_tendsto hab hR hvel (2 * η) height |
| midpoint midpoint_mem |
| have hsum : (fun N => totalArea (C N)) = |
| (fun N => ∑ i : Fin N, |
| height * RadialRiemann.step (-1 / 2) (1 / 2) N * |
| (RadialRiemann.capMax R (-1 / 2) (1 / 2) N i + |
| (2 * η) * RadialRiemann.step (-1 / 2) (1 / 2) N) ^ 2 / |
| (2 * Real.sqrt (1 + ‖velocity η (midpoint N i)‖ ^ 2))) := by |
| funext N |
| unfold totalArea |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [harea N i, velocity_norm_sq] |
| rfl |
| rw [hsum] |
| convert hlim using 1 |
| congr 1 |
| unfold limitingArea |
| congr 1 |
| apply intervalIntegral.integral_congr |
| intro s _ |
| dsimp only |
| rw [velocity_norm_sq] |
|
|
| end CylinderCovering.UnitEdgeFootprints |
|
|
| end |
|
|
| end OAI |
|
|
