| import OAI.Geometry.TriangularCovering.Main |
| import OAI.Geometry.CylinderCovering.Radial.Triangle |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace RadialProjection |
| open TriangularCovering Set MeasureTheory |
| open scoped InnerProductSpace |
|
|
| lemma cross3_cross_right (u v w : Space) : |
| cross3 u (cross3 v w) = (inner ℝ u w) • v - (inner ℝ u v) • w := by |
| ext i |
| fin_cases i < |
|
|
| lemma cross3_normal {e a b : Space} (he : ‖e‖ = 1) |
| (ha : inner ℝ e a = 0) (hb : inner ℝ e b = 0) : |
| cross3 a b = (inner ℝ e (cross3 a b)) • e := by |
| have hc : cross3 e (cross3 a b) = 0 := by |
| rw [cross3_cross_right, ha, hb] |
| simp |
| have hh := cross3_cross_right e e (cross3 a b) |
| rw [hc] at hh |
| have hz : cross3 e 0 = 0 := by |
| ext i |
| fin_cases i < |
| rw [hz, real_inner_self_eq_norm_sq, he, one_pow, one_smul] at hh |
| exact (sub_eq_zero.mp hh.symm).symm |
|
|
| lemma sideways_norm {e w : Space} (he : ‖e‖ = 1) |
| (hw : inner ℝ e w = 0) : ‖e + w‖ = Real.sqrt (1 + ‖w‖ ^ 2) := by |
| have hsq : ‖e + w‖ ^ 2 = 1 + ‖w‖ ^ 2 := by |
| rw [norm_add_sq_real, he, hw] |
| ring |
| rw [← hsq, Real.sqrt_sq (norm_nonneg _)] |
|
|
| lemma sideways_ne_zero {e w : Space} (he : ‖e‖ = 1) |
| (hw : inner ℝ e w = 0) : e + w ≠ 0 := by |
| intro h |
| have hn := sideways_norm he hw |
| rw [h, norm_zero] at hn |
| have hp : 0 < Real.sqrt (1 + ‖w‖ ^ 2) := by positivity |
| linarith |
|
|
| lemma normal_cross_abs {e a b : Space} (he : ‖e‖ = 1) |
| (ha : inner ℝ e a = 0) (hb : inner ℝ e b = 0) : |
| |inner ℝ e (cross3 a b)| = |
| Real.sqrt (inner ℝ a a * inner ℝ b b - (inner ℝ a b) ^ 2) := by |
| have hh := triple_gram_identity e a b |
| rw [ha, hb, real_inner_self_eq_norm_sq e, he] at hh |
| norm_num at hh |
| rw [real_inner_self_eq_norm_sq a, real_inner_self_eq_norm_sq b, |
| ← hh, Real.sqrt_sq_eq_abs] |
|
|
| theorem normal_projection_factor {e a b w : Space} (he : ‖e‖ = 1) |
| (ha : inner ℝ e a = 0) (hb : inner ℝ e b = 0) |
| (hw : inner ℝ e w = 0) : |
| |inner ℝ (unit (e + w)) (cross3 a b)| = |
| Real.sqrt (inner ℝ a a * inner ℝ b b - (inner ℝ a b) ^ 2) / |
| Real.sqrt (1 + ‖w‖ ^ 2) := by |
| have hcrossw : inner ℝ w (cross3 a b) = 0 := by |
| rw [cross3_normal he ha hb, inner_smul_right, real_inner_comm e w, hw] |
| simp |
| rw [TriangularCovering.unit, inner_smul_left, inner_add_left, hcrossw, add_zero] |
| simp only [conj_trivial, abs_mul, abs_inv, abs_norm] |
| rw [normal_cross_abs he ha hb, sideways_norm he hw] |
| ring |
|
|
| lemma cross3_coordinates (a b : Space) (u₁ v₁ u₂ v₂ : ℝ) : |
| cross3 (u₁ • a + v₁ • b) (u₂ • a + v₂ • b) = |
| (u₁ * v₂ - v₁ * u₂) • cross3 a b := by |
| ext i |
| fin_cases i < |
|
|
| lemma collar_cross (p₀ a b : Space) (l r m d : ℝ) : |
| cross3 |
| ((p₀ + r • a + (m * r - d / 2 * (r - l)) • b) - |
| (p₀ + l • a + (m * l) • b)) |
| ((p₀ + r • a + (m * r + d / 2 * (r - l)) • b) - |
| (p₀ + l • a + (m * l) • b)) = |
| (d * (r - l) ^ 2) • cross3 a b := by |
| have h₁ : (p₀ + r • a + (m * r - d / 2 * (r - l)) • b) - |
| (p₀ + l • a + (m * l) • b) = |
| (r - l) • a + (m * (r - l) - d / 2 * (r - l)) • b := by module |
| have h₂ : (p₀ + r • a + (m * r + d / 2 * (r - l)) • b) - |
| (p₀ + l • a + (m * l) • b) = |
| (r - l) • a + (m * (r - l) + d / 2 * (r - l)) • b := by module |
| rw [h₁, h₂, cross3_coordinates] |
| congr 1 |
| ring |
|
|
| theorem collar_projection_area (p₀ e a b w : Space) (l r m d : ℝ) |
| (he : ‖e‖ = 1) (ha : inner ℝ e a = 0) (hb : inner ℝ e b = 0) |
| (hw : inner ℝ e w = 0) (hd : 0 ≤ d) : |
| area (projection (TriangularCovering.unit (e + w)) '' triangle |
| (p₀ + l • a + (m * l) • b) |
| (p₀ + r • a + (m * r - d / 2 * (r - l)) • b) |
| (p₀ + r • a + (m * r + d / 2 * (r - l)) • b)) = |
| Real.sqrt (inner ℝ a a * inner ℝ b b - (inner ℝ a b) ^ 2) * |
| d * (r - l) ^ 2 / (2 * Real.sqrt (1 + ‖w‖ ^ 2)) := by |
| unfold area |
| rw [projection_triangle_measure (unit_norm (sideways_ne_zero he hw)), |
| ENNReal.toReal_ofReal (by positivity), collar_cross, inner_smul_right, |
| abs_mul, abs_of_nonneg (mul_nonneg hd (sq_nonneg _)), |
| normal_projection_factor he ha hb hw] |
| ring |
| |
| theorem collar_projection_nondegenerate (p₀ e a b w : Space) (l r m d : ℝ) |
| (he : ‖e‖ = 1) (ha : inner ℝ e a = 0) (hb : inner ℝ e b = 0) |
| (hw : inner ℝ e w = 0) (hd : 0 < d) (hlr : l < r) |
| (hκ : 0 < Real.sqrt (inner ℝ a a * inner ℝ b b - (inner ℝ a b) ^ 2)) : |
| inner ℝ (TriangularCovering.unit (e + w)) |
| (cross3 |
| ((p₀ + r • a + (m * r - d / 2 * (r - l)) • b) - |
| (p₀ + l • a + (m * l) • b)) |
| ((p₀ + r • a + (m * r + d / 2 * (r - l)) • b) - |
| (p₀ + l • a + (m * l) • b))) ≠ 0 := by |
| rw [← abs_pos, collar_cross, inner_smul_right, abs_mul, |
| abs_of_nonneg (mul_nonneg hd.le (sq_nonneg _)), normal_projection_factor he ha hb hw] |
| exact mul_pos (mul_pos hd (sq_pos_of_pos (sub_pos.mpr hlr))) (div_pos hκ (by positivity)) |
| |
| lemma gram_sqrt_pos {a b : Space} |
| (hab : LinearIndependent ℝ (![a, b] : Fin 2 → Space)) : |
| 0 < Real.sqrt (inner ℝ a a * inner ℝ b b - (inner ℝ a b) ^ 2) := by |
| have hpi : LinearIndependent ℝ (![a.ofLp, b.ofLp] : Fin 2 → (Fin 3 → ℝ)) := by |
| have hh := hab.map' (EuclideanSpace.equiv (Fin 3) ℝ).toLinearMap |
| (LinearMap.ker_eq_bot.mpr (EuclideanSpace.equiv (Fin 3) ℝ).injective) |
| have hfun : (EuclideanSpace.equiv (Fin 3) ℝ).toLinearMap ∘ |
| (![a, b] : Fin 2 → Space) = ![a.ofLp, b.ofLp] := by |
| funext i |
| fin_cases i < |
| rw [hfun] at hh |
| exact hh |
| have hc : cross3 a b ≠ 0 := by |
| intro hz |
| apply (crossProduct_ne_zero_iff_linearIndependent.mpr hpi) |
| simpa [cross3] using congrArg WithLp.ofLp hz |
| rw [← cross3_gram, real_inner_self_eq_norm_sq, Real.sqrt_sq (norm_nonneg _)] |
| exact norm_pos_iff.mpr hc |
|
|
| def coordinateAffine (p₀ a b : Space) : (ℝ × ℝ) →ᵃ[ℝ] Space where |
| toFun := fun p => p₀ + p.1 • a + p.2 • b |
| linear := (LinearMap.fst ℝ ℝ ℝ).smulRight a + (LinearMap.snd ℝ ℝ ℝ).smulRight b |
| map_vadd' := by |
| intro p v |
| simp only [vadd_eq_add, Prod.fst_add, Prod.snd_add, LinearMap.add_apply, |
| LinearMap.smulRight_apply, LinearMap.fst_apply, LinearMap.snd_apply] |
| module |
| |
| lemma coordinate_region_image (p₀ a b : Space) {l r m d : ℝ} |
| (hlr : l < r) (hd : 0 < d) : |
| coordinateAffine p₀ a b '' CylinderCovering.RadialTriangle.region l r m d = |
| triangle (p₀ + l • a + (m * l) • b) |
| (p₀ + r • a + (m * r - d / 2 * (r - l)) • b) |
| (p₀ + r • a + (m * r + d / 2 * (r - l)) • b) := by |
| rw [CylinderCovering.RadialTriangle.region_eq_convexHull hlr hd, |
| (coordinateAffine p₀ a b).image_convexHull, triangle] |
| congr 1 |
| rw [← Set.range_comp] |
| congr 1 |
| funext i |
| fin_cases i <;> rfl |
| |
| theorem exists_collar_cylinder_exact (p₀ e a b w : Space) (l r m d : ℝ) |
| (he : ‖e‖ = 1) (ha : inner ℝ e a = 0) (hb : inner ℝ e b = 0) |
| (hw : inner ℝ e w = 0) (hd : 0 < d) (hlr : l < r) |
| (hab : LinearIndependent ℝ (![a, b] : Fin 2 → Space)) : |
| ∃ c : TriCylinder, |
| c.axis = TriangularCovering.unit (e + w) ∧ |
| c.base = projection (TriangularCovering.unit (e + w)) '' triangle |
| (p₀ + l • a + (m * l) • b) |
| (p₀ + r • a + (m * r - d / 2 * (r - l)) • b) |
| (p₀ + r • a + (m * r + d / 2 * (r - l)) • b) ∧ |
| area c.base = Real.sqrt (inner ℝ a a * inner ℝ b b - (inner ℝ a b) ^ 2) * |
| d * (r - l) ^ 2 / (2 * Real.sqrt (1 + ‖w‖ ^ 2)) ∧ |
| ∀ u v s : ℝ, l ≤ u → u ≤ r → |v - m * u| ≤ d / 2 * (u - l) → |
| p₀ + u • a + v • b + s • (e + w) ∈ c.carrier := by |
| let P := p₀ + l • a + (m * l) • b |
| let Q := p₀ + r • a + (m * r - d / 2 * (r - l)) • b |
| let R := p₀ + r • a + (m * r + d / 2 * (r - l)) • b |
| have hv := sideways_ne_zero he hw |
| have hcross := collar_projection_nondegenerate p₀ e a b w l r m d |
| he ha hb hw hd hlr (gram_sqrt_pos hab) |
| refine ⟨projectedCylinder (TriangularCovering.unit (e + w)) (unit_norm hv) |
| P Q R hcross, rfl, rfl, ?_, ?_⟩ |
| · exact collar_projection_area p₀ e a b w l r m d he ha hb hw hd.le |
| · intro u v s hlu hur huv |
| have hp : p₀ + u • a + v • b ∈ triangle P Q R := by |
| rw [← coordinate_region_image p₀ a b hlr hd] |
| exact ⟨(u, v), ⟨hlu, hur, huv⟩, rfl⟩ |
| exact projectedCylinder_mem_direction (e + w) hv P Q R hcross hp s rfl |
| |
| theorem exists_collar_cylinder (p₀ e a b w : Space) (l r m d : ℝ) |
| (he : ‖e‖ = 1) (ha : inner ℝ e a = 0) (hb : inner ℝ e b = 0) |
| (hw : inner ℝ e w = 0) (hd : 0 < d) (hlr : l < r) |
| (hab : LinearIndependent ℝ (![a, b] : Fin 2 → Space)) : |
| ∃ c : TriCylinder, |
| c.axis = TriangularCovering.unit (e + w) ∧ |
| area c.base = Real.sqrt (inner ℝ a a * inner ℝ b b - (inner ℝ a b) ^ 2) * |
| d * (r - l) ^ 2 / (2 * Real.sqrt (1 + ‖w‖ ^ 2)) ∧ |
| ∀ u v s : ℝ, l ≤ u → u ≤ r → |v - m * u| ≤ d / 2 * (u - l) → |
| p₀ + u • a + v • b + s • (e + w) ∈ c.carrier := by |
| obtain ⟨c, haxis, _, harea, hcover⟩ := |
| exists_collar_cylinder_exact p₀ e a b w l r m d he ha hb hw hd hlr hab |
| exact ⟨c, haxis, harea, hcover⟩ |
| |
| end RadialProjection |
| |
| end |
| |
| end OAI |
| |
