| import OAI.Geometry.RuledCovering.NilpotentLattice |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| open Set MeasureTheory Filter Metric |
| open scoped Topology ContDiff Pointwise |
|
|
| namespace RuledApproximation |
|
|
| / |
| The factor is the exact area inflation caused by the derivative remainder. -/ |
| theorem framed_local_cover_of_shape (M : Coordinates ≃L[ℝ] Plane) {h L R delta : ℝ} |
| (shape : Cylinder → Prop) |
| (hshape : ∀ b : Coordinates, ∀ a : ℝ, 0 < a → ∀ g : Plane, |
| shape (projectedCylinder h g (M '' closedBall b a))) |
| (hh : 0 < h) (hL : 0 ≤ L) (hR : 0 ≤ R) (hd : 0 ≤ delta) |
| {K U : Set Coordinates} (hK : IsCompact K) (hU : IsOpen U) (hKU : K ⊆ U) |
| (v : Plane → Plane) (A : Coordinates →L[ℝ] Coordinates) |
| (hmodel : LatticeModel A L R) |
| (hrem : ∀ p ∈ U, ∀ b ∈ U, |
| ‖M.symm (v (M p)) - M.symm (v (M b)) - A (p - b)‖ ≤ delta * ‖p - b‖) |
| {F : Coordinates → ℝ} (hF : Continuous F) (hFpos : ∀ p, 0 ≤ F p) |
| (hFval : ∀ p ∈ U, F p = physicalWeight h (v (M p))) |
| {eps : ℝ} (heps : 0 < eps) : |
| HasFiniteCover shape (physicalRuled h (M '' K) v L) |
| (h * (1 + 2 * L * delta * R) ^ 2 * |
| (∫ p in M '' K, physicalWeight h (v p)) + eps) := by |
| classical |
| let B : ℝ := (1 + 2 * L * delta * R) ^ 2 |
| have hB : 0 < B := by dsimp [B]; positivity |
| have hscale : 0 < h * frameJacobian M * B := mul_pos (mul_pos hh (frameJacobian_pos M)) hB |
| obtain ⟨n, hn, S, hS, hSU, hcov, hcost⟩ := local_finite_certificate hK hU hKU |
| (fun p => M.symm (v (M p))) A hL hd hmodel hrem hF hFpos (div_pos heps hscale) |
| let : Fintype S := hS.fintype |
| let a : ℝ := (1 / 2 + L * delta * R) / n |
| have hnR : 0 < (n : ℝ) := by exact_mod_cast hn |
| have ha : 0 < a := by dsimp [a]; positivity |
| let C : S → Cylinder := fun b => projectedCylinder h (v (M b)) (M '' closedBall (b : Coordinates) a) |
| have harea (b : S) : (C b).area = h * frameJacobian M * (2 * a) ^ 2 * F b := by |
| dsimp only [C] |
| rw [projectedCylinder_area hh, frame_volume_image M isClosed_closedBall.measurableSet, |
| coordinates_closedBall_volume b ha.le, hFval b (hSU b.property)] |
| ring |
| have hBrel : (2 * a) ^ 2 = B / (n : ℝ) ^ 2 := by |
| dsimp [a, B] |
| ring |
| have hintegral : (∫ p in M '' K, physicalWeight h (v p)) = |
| frameJacobian M * ∫ x in K, F x := by |
| rw [frame_integral_image M hK.measurableSet] |
| congr 1 |
| apply setIntegral_congr_fun hK.measurableSet |
| intro x hx |
| exact (hFval x (hKU hx)).symm |
| apply HasFiniteCover.of_fintype C |
| · intro b |
| exact hshape b a ha (v (M b)) |
| · rintro x ⟨_, ⟨p, hp, rfl⟩, s, hs, rfl⟩ |
| obtain ⟨b, hb, hc⟩ := hcov p hp s hs |
| apply mem_iUnion.mpr |
| refine ⟨⟨b, hb⟩, ?_⟩ |
| apply physicalRuled_mem_projectedCylinder |
| refine ⟨p + s • (M.symm (v (M p)) - M.symm (v (M b))), ?_, ?_⟩ |
| · rw [mem_closedBall, dist_eq_norm] |
| convert hc using 1 |
| congr 1 |
| module |
| · simp |
| · have hsum : (∑ b : S, (C b).area) = |
| (h * frameJacobian M * B) * ((∑' b : S, F b) / (n : ℝ) ^ 2) := by |
| simp_rw [harea, hBrel] |
| rw [tsum_fintype, ← Finset.mul_sum] |
| ring |
| rw [hsum, hintegral] |
| have hc := (mul_lt_mul_of_pos_left hcost hscale).le |
| calc |
| _ ≤ (h * frameJacobian M * B) * |
| ((∫ x in K, F x) + eps / (h * frameJacobian M * B)) := hc |
| _ = _ := by |
| rw [mul_add, mul_div_cancel₀ _ hscale.ne'] |
| dsimp [B] |
| ring |
|
|
|
|
| / |
| with one prescribed arbitrarily small area inflation. -/ |
| theorem nilpotent_local_patch {h B : ℝ} (hh : 0 < h) (hB : 1 < B) |
| {v : Plane → Plane} {U : Set Plane} (hU : IsOpen U) (hv : ContDiffOn ℝ 1 v U) |
| {p : Plane} (hp : p ∈ U) (hnil : (fderiv ℝ v p).comp (fderiv ℝ v p) = 0) : |
| ∃ V : Set Plane, IsOpen V ∧ p ∈ V ∧ ∀ K : Set Plane, IsCompact K → K ⊆ V → |
| ∀ eps : ℝ, 0 < eps → HasFiniteCover (squareProjected h) (physicalRuled h K v 1) |
| (h * B * (∫ q in K, physicalWeight h (v q)) + eps) := by |
| obtain ⟨Q, d, hQ⟩ := nilpotent_frame (fderiv ℝ v p) hnil |
| let M := orthogonalFrame Q |
| have hM (z : Coordinates) : M.symm ((fderiv ℝ v p) (M z)) = ![d*z 1,0] := by |
| have hz := congrArg WithLp.ofLp (hQ (WithLp.toLp 2 z)) |
| exact hz |
| let A : Coordinates →L[ℝ] Coordinates := d • shearCLM |
| let R : ℝ := (1+|d|)/2 |
| have hR : 0 < R := by dsimp [R]; positivity |
| have hmodel : LatticeModel A 1 R := nilpotent_lattice_model d |
| obtain ⟨delta, hd, hDB⟩ := exists_small_inflation 1 R hB |
| let w : Coordinates → Coordinates := fun x => M.symm (v (M x)) |
| let Uc : Set Coordinates := M ⁻¹' U |
| have hUco : IsOpen Uc := hU.preimage M.continuous |
| have hpc : M.symm p ∈ Uc := by simpa [Uc] |
| have hvc : ContDiffOn ℝ 1 (fun x => v (M x)) Uc := |
| hv.comp M.contDiff.contDiffOn (fun x hx => hx) |
| have hwc : ContDiffOn ℝ 1 w Uc := M.symm.contDiff.comp_contDiffOn hvc |
| have hvder := (hv.contDiffAt (hU.mem_nhds hp)).differentiableAt (by norm_num) |
| have hwd : fderiv ℝ w (M.symm p) = A := by |
| have hvd : HasFDerivAt (fun x => v (M x)) |
| ((fderiv ℝ v p).comp M.toContinuousLinearMap) (M.symm p) := by |
| have hvdp : HasFDerivAt v (fderiv ℝ v p) (M (M.symm p)) := by |
| simpa using hvder.hasFDerivAt |
| exact hvdp.comp (M.symm p) M.hasFDerivAt |
| have hcomp := M.symm.hasFDerivAt.comp (M.symm p) hvd |
| change fderiv ℝ (M.symm ∘ (fun x => v (M x))) (M.symm p) = A |
| rw [hcomp.fderiv] |
| ext z i |
| have hz := congrArg (fun a : Coordinates => a i) (hM z) |
| fin_cases i <;> simpa [A, shearCLM, shearLinear] using hz |
| obtain ⟨r, hr, hrU, hrem⟩ := c1_local_remainder hUco hwc hpc hd |
| let Vc := ball (M.symm p) (r / 2) |
| have hrhalf : r / 2 < r := by linarith |
| have hclU : closedBall (M.symm p) (r / 2) ⊆ Uc := |
| (closedBall_subset_ball hrhalf).trans hrU |
| have hclF : ContinuousOn (fun x => physicalWeight h (v (M x))) |
| (closedBall (M.symm p) (r / 2)) := |
| (physicalWeight_continuous h).comp_continuousOn (hvc.continuousOn.mono hclU) |
| obtain ⟨F, hF, hFnon, hFeq⟩ := continuous_nonneg_extension isClosed_closedBall hclF |
| (fun x _ => (physicalWeight_pos h (v (M x))).le) |
| refine ⟨M '' Vc, M.isOpenMap _ isOpen_ball, ?_, ?_⟩ |
| · exact ⟨M.symm p, mem_ball_self (half_pos hr), M.apply_symm_apply p⟩ |
| · intro K hK hKV eps heps |
| let Kc := M.symm '' K |
| have hKc : IsCompact Kc := hK.image M.symm.continuous |
| have hKcV : Kc ⊆ Vc := by |
| rintro _ ⟨q, hq, rfl⟩ |
| obtain ⟨x, hx, rfl⟩ := hKV hq |
| simpa using hx |
| have himg : M '' Kc = K := by simp [Kc] |
| have hc := framed_local_cover_of_shape M (squareProjected h) |
| (fun b a ha g => ⟨_,g,orthogonal_closedBall_square Q b ha,rfl⟩) |
| hh (by norm_num : (0:ℝ)≤1) hR.le hd.le hKc isOpen_ball hKcV v A hmodel |
| (fun x hx y hy => by |
| rw [← hwd] |
| exact hrem x (ball_subset_ball hrhalf.le hx) y (ball_subset_ball hrhalf.le hy)) |
| hF hFnon (fun x hx => hFeq (ball_subset_closedBall hx)) heps |
| rw [himg] at hc |
| apply hc.mono Subset.rfl |
| have hI : 0 ≤ ∫ q in K, physicalWeight h (v q) := |
| integral_nonneg (fun q => (physicalWeight_pos h (v q)).le) |
| linarith [mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hDB.le hh.le) hI] |
|
|
| / |
| compact labels. -/ |
| theorem nilpotent_physical_cover {h : ℝ} {D : Set Plane} {v : Plane → Plane} |
| (hh : 0 < h) (hD : IsCompact D) (hv : SmoothNear 1 D v) |
| (hnil : ∀ p ∈ D, (fderiv ℝ v p).comp (fderiv ℝ v p) = 0) |
| {eps : ℝ} (heps : 0 < eps) : |
| HasFiniteCover (squareProjected h) (physicalRuled h D v 1) |
| (h * (∫ p in D, physicalWeight h (v p)) + eps) := by |
| obtain ⟨U, hU, hDU, hv⟩ := hv |
| have hF : IntegrableOn (fun p => physicalWeight h (v p)) D := |
| ((physicalWeight_continuous h).comp_continuousOn (hv.continuousOn.mono hDU)).integrableOn_compact hD |
| obtain ⟨B, hB, hbudget⟩ := exists_inflation_budget |
| (h * ∫ p in D, physicalWeight h (v p)) (half_pos heps) |
| have hc := globalize_local_covers h 1 v (fun p => physicalWeight h (v p)) (h*B) hD hF |
| (fun p hp => nilpotent_local_patch hh hB hU hv (hDU hp) (hnil p hp)) (half_pos heps) |
| apply hc.mono Subset.rfl |
| nlinarith |
|
|
| lemma unitSquare_parallelogram : IsParallelogram unitSquare := by |
| have he : unitSquare = (EuclideanSpace.equiv (Fin 2) ℝ).symm '' |
| closedBall (0 : Coordinates) (1/2:ℝ) := by |
| ext x |
| constructor |
| · intro hx |
| refine ⟨WithLp.ofLp x, ?_, rfl⟩ |
| rw [mem_closedBall,dist_zero_right,pi_norm_le_iff_of_nonneg (by norm_num : (0:ℝ)≤1/2)] |
| exact hx |
| · rintro ⟨y,hy,rfl⟩ |
| rw [mem_closedBall,dist_zero_right,pi_norm_le_iff_of_nonneg (by norm_num : (0:ℝ)≤1/2)] at hy |
| exact hy |
| rw [he] |
| exact (coordinates_closedBall_parallelogram 0 (by norm_num : (0:ℝ)<1/2)).linear_image |
| (EuclideanSpace.equiv (Fin 2) ℝ).symm.toLinearMap |
| (EuclideanSpace.equiv (Fin 2) ℝ).symm.injective |
|
|
| lemma IsSquareTile.parallelogram {T : Set Plane} (hT : IsSquareTile T) : |
| IsParallelogram T := by |
| obtain ⟨c,R,a,ha,rfl⟩ := hT |
| have hi : Function.Injective (a • R.toLinearMap) := by |
| intro x y hxy |
| apply R.injective |
| exact (smul_right_injective Plane ha.ne') hxy |
| have he : (fun x => c+a • R x) '' unitSquare = |
| (fun x => c+x) '' ((a • R.toLinearMap) '' unitSquare) := by |
| rw [← image_comp] |
| rfl |
| rw [he] |
| exact (unitSquare_parallelogram.linear_image (a • R.toLinearMap) hi).translate c |
|
|
| end RuledApproximation |
|
|
| end |
|
|
| end OAI |
|
|
