| import OAI.Geometry.RuledCovering.HyperbolicCover |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| open Set MeasureTheory Filter Metric |
| open scoped Topology ContDiff Pointwise |
|
|
| namespace RuledApproximation |
|
|
| lemma IsParallelogram.translate {E : Type*} [AddCommGroup E] [Module ℝ E] |
| {P : Set E} (hP : IsParallelogram P) (a : E) : |
| IsParallelogram ((fun x => a + x) '' P) := by |
| obtain ⟨c, u, v, hli, rfl⟩ := hP |
| refine ⟨a+c, u, v, hli, ?_⟩ |
| ext x |
| constructor |
| · rintro ⟨_, ⟨s, hs, t, ht, rfl⟩, rfl⟩ |
| exact ⟨s, hs, t, ht, by abel_nf⟩ |
| · rintro ⟨s, hs, t, ht, rfl⟩ |
| exact ⟨c+s•u+t•v, ⟨s, hs, t, ht, rfl⟩, by abel_nf⟩ |
|
|
| def rotatedPlane (u : Space) (R : Space ≃ₗᵢ[ℝ] Space) : |
| ((Submodule.span ℝ ({u} : Set Space))ᗮ) ≃ₗᵢ[ℝ] |
| ((Submodule.span ℝ ({R u} : Set Space))ᗮ) where |
| toFun b := ⟨R b, by |
| rw [Submodule.mem_orthogonal_singleton_iff_inner_right, R.inner_map_map] |
| exact Submodule.mem_orthogonal_singleton_iff_inner_right.mp b.property⟩ |
| invFun b := ⟨R.symm b, by |
| rw [Submodule.mem_orthogonal_singleton_iff_inner_right] |
| rw [← R.inner_map_map u (R.symm b), R.apply_symm_apply] |
| exact Submodule.mem_orthogonal_singleton_iff_inner_right.mp b.property⟩ |
| left_inv b := by ext; simp |
| right_inv b := by ext; simp |
| map_add' b c := by ext; simp |
| map_smul' a b := by ext; simp |
| norm_map' b := R.norm_map b |
|
|
| def Cylinder.rotate (C : Cylinder) (R : Space ≃ₗᵢ[ℝ] Space) : Cylinder where |
| axis := R C.axis |
| unit_axis := by rw [R.norm_map, C.unit_axis] |
| base := rotatedPlane C.axis R '' C.base |
|
|
| lemma Cylinder.rotate_carrier (C : Cylinder) (R : Space ≃ₗᵢ[ℝ] Space) : |
| (C.rotate R).carrier = R '' C.carrier := by |
| ext x |
| constructor |
| · rintro ⟨_, ⟨b, hb, rfl⟩, t, rfl⟩ |
| exact ⟨(b : Space) + t • C.axis, ⟨b, hb, t, rfl⟩, by change R ((b : Space) + t • C.axis) = R b + t • R C.axis; simp⟩ |
| · rintro ⟨_, ⟨b, hb, t, rfl⟩, rfl⟩ |
| exact ⟨rotatedPlane C.axis R b, ⟨b, hb, rfl⟩, t, by change R ((b : Space) + t • C.axis) = R b + t • R C.axis; simp⟩ |
|
|
| lemma Cylinder.rotate_area (C : Cylinder) (R : Space ≃ₗᵢ[ℝ] Space) : |
| (C.rotate R).area = C.area := by |
| change volume.real (rotatedPlane C.axis R '' C.base) = volume.real C.base |
| have he := (rotatedPlane C.axis R).measurePreserving.setIntegral_image_emb |
| (rotatedPlane C.axis R).toHomeomorph.measurableEmbedding (fun _ => (1 : ℝ)) C.base |
| simpa only [integral_const, measureReal_def, Measure.restrict_apply_univ, smul_eq_mul, mul_one] using he |
|
|
| lemma Cylinder.rotate_parallelogram {C : Cylinder} (hC : C.parallelogram) |
| (R : Space ≃ₗᵢ[ℝ] Space) : (C.rotate R).parallelogram := |
| hC.linear_image (rotatedPlane C.axis R).toLinearMap (rotatedPlane C.axis R).injective |
|
|
| def Cylinder.transversePart (C : Cylinder) (q : Space) : |
| ((Submodule.span ℝ ({C.axis} : Set Space))ᗮ) := |
| ⟨q - (inner ℝ C.axis q) • C.axis, by |
| rw [Submodule.mem_orthogonal_singleton_iff_inner_right, inner_sub_right, inner_smul_right, |
| real_inner_self_eq_norm_sq, C.unit_axis] |
| simp⟩ |
|
|
| def Cylinder.translate (C : Cylinder) (q : Space) : Cylinder where |
| axis := C.axis |
| unit_axis := C.unit_axis |
| base := (fun b => C.transversePart q + b) '' C.base |
|
|
| lemma Cylinder.translate_carrier (C : Cylinder) (q : Space) : |
| (C.translate q).carrier = (fun x => q + x) '' C.carrier := by |
| ext x |
| constructor |
| · rintro ⟨_, ⟨b, hb, rfl⟩, t, rfl⟩ |
| refine ⟨(b : Space) + (t - inner ℝ C.axis q) • C.axis, |
| ⟨b, hb, _, rfl⟩, ?_⟩ |
| change q + ((b : Space) + (t - inner ℝ C.axis q) • C.axis) = |
| (q - (inner ℝ C.axis q) • C.axis + b) + t • C.axis |
| module |
| · rintro ⟨_, ⟨b, hb, t, rfl⟩, rfl⟩ |
| refine ⟨C.transversePart q + b, ⟨b, hb, rfl⟩, t + inner ℝ C.axis q, ?_⟩ |
| change q + ((b : Space) + t • C.axis) = |
| (q - (inner ℝ C.axis q) • C.axis + b) + (t + inner ℝ C.axis q) • C.axis |
| module |
|
|
| lemma Cylinder.translate_area (C : Cylinder) (q : Space) : |
| (C.translate q).area = C.area := by |
| change volume.real ((fun b => C.transversePart q + b) '' C.base) = volume.real C.base |
| have he := (measurePreserving_add_left volume (C.transversePart q)).setIntegral_image_emb |
| (Homeomorph.addLeft (C.transversePart q)).measurableEmbedding (fun _ => (1 : ℝ)) C.base |
| simpa only [integral_const, measureReal_def, Measure.restrict_apply_univ, smul_eq_mul, mul_one] using he |
|
|
| lemma Cylinder.translate_parallelogram {C : Cylinder} (hC : C.parallelogram) (q : Space) : |
| (C.translate q).parallelogram := hC.translate (C.transversePart q) |
|
|
| /-- Exact Euclidean isometry transport preserves finite covers and perpendicular area. -/ |
| lemma HasFiniteCover.isometry {S : Set Space} {A : ℝ} |
| (hc : HasFiniteCover Cylinder.parallelogram S A) (F : Space ≃ᵢ Space) : |
| HasFiniteCover Cylinder.parallelogram (F '' S) A := by |
| obtain ⟨n, C, hC, hcov, hcost⟩ := hc |
| let R := F.toRealLinearIsometryEquiv |
| have hF (x : Space) : F x = F 0 + R x := by |
| simp [R, IsometryEquiv.toRealLinearIsometryEquiv_apply] |
| let D : Fin n → Cylinder := fun i => ((C i).rotate R).translate (F 0) |
| refine ⟨n, D, fun i => Cylinder.translate_parallelogram (Cylinder.rotate_parallelogram (hC i) R) (F 0), ?_, ?_⟩ |
| · rintro _ ⟨x, hx, rfl⟩ |
| obtain ⟨i, hi⟩ := mem_iUnion.mp (hcov hx) |
| refine mem_iUnion.mpr ⟨i, ?_⟩ |
| change F x ∈ (((C i).rotate R).translate (F 0)).carrier |
| rw [Cylinder.translate_carrier, Cylinder.rotate_carrier] |
| exact ⟨R x, ⟨x, hi, rfl⟩, (hF x).symm⟩ |
| · simpa [familyArea, D, Cylinder.translate_area, Cylinder.rotate_area] using hcost |
|
|
| end RuledApproximation |
|
|
| end |
|
|
| end OAI |
|
|
