openAI-math-dataset / lean /OAI /Geometry /CylinderCovering /Convexity /CompactParallelogramApproximation.lean
| import OAI.Geometry.RuledCovering.Main | |
| import OAI.Geometry.CylinderCovering.Ruled.Similarity | |
| namespace OAI | |
| open Set MeasureTheory Metric | |
| open scoped Topology | |
| noncomputable section | |
| namespace RuledApproximation | |
| theorem compact_coordinates_parallelogram_cover {K : Set Coordinates} | |
| (hK : IsCompact K) {ε : ℝ} (hε : 0 < ε) : | |
| ∃ n : ℕ, ∃ P : Fin n → Set Coordinates, | |
| (∀ i, IsParallelogram (P i)) ∧ K ⊆ ⋃ i, P i ∧ | |
| (∑ i, volume.real (P i)) < volume.real K + ε := by | |
| classical | |
| have hmodel : LatticeModel (0 : Coordinates →L[ℝ] Coordinates) 1 (1/2) := by | |
| simpa using nilpotent_lattice_model 0 | |
| obtain ⟨m, hm, S, hS, _, hcover, hcost⟩ := local_finite_certificate | |
| hK isOpen_univ (subset_univ _) (fun _ => 0) 0 | |
| (show (0:ℝ) ≤ 1 by norm_num) (show (0:ℝ) ≤ 0 by norm_num) hmodel | |
| (by intros; simp) (continuous_const : Continuous (fun _ : Coordinates => (1:ℝ))) | |
| (fun _ => zero_le_one) hε | |
| let : Fintype S := hS.fintype | |
| let a : ℝ := (1/2) / m | |
| have hmR : (0:ℝ) < m := by exact_mod_cast hm | |
| have ha : 0 < a := div_pos (by norm_num) hmR | |
| let e := Fintype.equivFin S | |
| let P : Fin (Fintype.card S) → Set Coordinates := | |
| fun i => closedBall ((e.symm i : S) : Coordinates) a | |
| refine ⟨Fintype.card S, P, fun i => coordinates_closedBall_parallelogram _ ha, ?_, ?_⟩ | |
| · intro p hp | |
| obtain ⟨b, hb, hdist⟩ := hcover p hp 0 (by norm_num) | |
| refine mem_iUnion.mpr ⟨e ⟨b, hb⟩, ?_⟩ | |
| change p ∈ closedBall ((e.symm (e ⟨b, hb⟩) : S) : Coordinates) a | |
| simp only [Equiv.symm_apply_apply] | |
| rw [mem_closedBall, dist_eq_norm] | |
| simpa [a] using hdist | |
| · have harea (b : S) : volume.real (closedBall (b : Coordinates) a) = 1 / (m:ℝ)^2 := by | |
| rw [coordinates_closedBall_volume _ ha.le] | |
| dsimp [a] | |
| ring | |
| have hsum : (∑ i, volume.real (P i)) = (∑' b : S, (1:ℝ)) / (m:ℝ)^2 := by | |
| change (∑ i, volume.real (closedBall ((e.symm i : S) : Coordinates) a)) = _ | |
| rw [e.symm.sum_comp (fun b : S => volume.real (closedBall (b : Coordinates) a))] | |
| simp only [harea, tsum_fintype, Finset.sum_div] | |
| rw [hsum] | |
| simpa only [integral_const, measureReal_restrict_apply_univ, smul_eq_mul, mul_one] using hcost | |
| theorem compact_parallelogram_cover {E : Type*} [NormedAddCommGroup E] | |
| [InnerProductSpace ℝ E] [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] | |
| (hdim : Module.finrank ℝ E = 2) {K : Set E} (hK : IsCompact K) | |
| {ε : ℝ} (hε : 0 < ε) : | |
| ∃ n : ℕ, ∃ P : Fin n → Set E, | |
| (∀ i, IsParallelogram (P i)) ∧ K ⊆ ⋃ i, P i ∧ | |
| (∑ i, volume.real (P i)) < volume.real K + ε := by | |
| let e : E ≃ₗᵢ[ℝ] Plane := ((stdOrthonormalBasis ℝ E).reindex (finCongr hdim)).repr | |
| let M : Coordinates ≃L[ℝ] E := | |
| (EuclideanSpace.equiv (Fin 2) ℝ).symm.trans e.symm.toContinuousLinearEquiv | |
| have hmp : MeasurePreserving M volume volume := | |
| e.symm.measurePreserving.comp (PiLp.volume_preserving_toLp (Fin 2)) | |
| have harea (T : Set Coordinates) : volume.real (M '' T) = volume.real T := by | |
| have h := hmp.setIntegral_image_emb M.toHomeomorph.measurableEmbedding | |
| (fun _ => (1:ℝ)) T | |
| simpa only [integral_const, measureReal_def, Measure.restrict_apply_univ, | |
| smul_eq_mul, mul_one] using h | |
| let Kc := M.symm '' K | |
| have hKc : IsCompact Kc := hK.image M.symm.continuous | |
| have himage : M '' Kc = K := by simp [Kc] | |
| have hvolume : volume.real Kc = volume.real K := by | |
| rw [← harea Kc, himage] | |
| obtain ⟨n, P, hP, hcover, hcost⟩ := compact_coordinates_parallelogram_cover hKc hε | |
| refine ⟨n, fun i => M '' P i, fun i => (hP i).linear_image M.toLinearMap M.injective, | |
| ?_, ?_⟩ | |
| · intro x hx | |
| have hx' : M.symm x ∈ Kc := ⟨x, hx, rfl⟩ | |
| obtain ⟨i, hi⟩ := mem_iUnion.mp (hcover hx') | |
| exact mem_iUnion.mpr ⟨i, M.symm x, hi, M.apply_symm_apply x⟩ | |
| · simp only [harea] | |
| rwa [hvolume] at hcost | |
| theorem Cylinder.compact_parallelogram_cover (C : Cylinder) (hC : IsCompact C.base) | |
| {ε : ℝ} (hε : 0 < ε) : | |
| HasFiniteCover Cylinder.parallelogram C.carrier (C.area + ε) := by | |
| obtain ⟨n, P, hP, hcover, hcost⟩ := RuledApproximation.compact_parallelogram_cover | |
| (similarityPlane_finrank C.axis C.unit_axis) hC hε | |
| let D : Fin n → Cylinder := fun i => ⟨C.axis, C.unit_axis, P i⟩ | |
| refine ⟨n, D, hP, ?_, hcost.le⟩ | |
| rintro x ⟨b, hb, s, rfl⟩ | |
| obtain ⟨i, hi⟩ := mem_iUnion.mp (hcover hb) | |
| exact mem_iUnion.mpr ⟨i, b, hi, s, rfl⟩ | |
| lemma HasFiniteCover.finite_iUnion {ι : Type*} [Fintype ι] | |
| {shape : Cylinder → Prop} (S : ι → Set Space) (A : ι → ℝ) | |
| (h : ∀ i, HasFiniteCover shape (S i) (A i)) : | |
| HasFiniteCover shape (⋃ i, S i) (∑ i, A i) := by | |
| classical | |
| have aux (s : Finset ι) : HasFiniteCover shape (⋃ i ∈ s, S i) (∑ i ∈ s, A i) := by | |
| induction s using Finset.induction_on with | |
| | empty => simpa using HasFiniteCover.empty shape (show (0:ℝ) ≤ 0 by norm_num) | |
| | @insert i s hi ih => | |
| have heq : (⋃ j ∈ insert i s, S j) = S i ∪ ⋃ j ∈ s, S j := by | |
| ext x | |
| simp | |
| rw [heq, Finset.sum_insert hi] | |
| exact (h i).union ih | |
| simpa using aux Finset.univ | |
| theorem compact_family_parallelogram_cover {n : ℕ} (C : Fin n → Cylinder) | |
| (hC : ∀ i, IsCompact (C i).base) {ε : ℝ} (hε : 0 < ε) : | |
| HasFiniteCover Cylinder.parallelogram (familySet C) (familyArea C + ε) := by | |
| have hδ : 0 < ε / (n + 1 : ℝ) := div_pos hε (by positivity) | |
| have hc := HasFiniteCover.finite_iUnion (fun i => (C i).carrier) | |
| (fun i => (C i).area + ε / (n + 1 : ℝ)) | |
| (fun i => (C i).compact_parallelogram_cover (hC i) hδ) | |
| apply hc.mono Subset.rfl | |
| simp only [Finset.sum_add_distrib, Finset.sum_const, Finset.card_univ, | |
| Fintype.card_fin, nsmul_eq_mul, familyArea] | |
| have hn : 0 < (n + 1 : ℝ) := by positivity | |
| have hmul : (n : ℝ) * (ε / (n + 1 : ℝ)) ≤ ε := by | |
| rw [← mul_div_assoc, div_le_iff₀ hn] | |
| nlinarith only [hε] | |
| linarith only [hmul] | |
| end RuledApproximation | |
| end | |
| end OAI | |