| import OAI.Geometry.CylinderCovering.Radial.PairedSweepDefinitions |
|
|
| namespace OAI |
|
|
| open Set |
|
|
| noncomputable section |
| namespace CylinderCovering.RadialCapCoverage |
|
|
| theorem quadratic_crossing {a b y : ℝ} (hay : |y| ≤ a) : |
| ∃ q : ℝ, |q| ≤ 1 ∧ y = a * q - b * (1 - q ^ 2) / 2 ∧ 0 ≤ a + b * q := by |
| have ha : 0 ≤ a := (abs_nonneg y).trans hay |
| by_cases hb : b = 0 |
| · subst b |
| by_cases hza : a = 0 |
| · subst a |
| have hy : y = 0 := abs_eq_zero.mp (le_antisymm hay (abs_nonneg y)) |
| subst y |
| exact ⟨0, by norm_num, by norm_num, by norm_num⟩ |
| · refine ⟨y / a, ?_, ?_, ?_⟩ |
| · rw [abs_div, abs_of_nonneg ha] |
| exact (div_le_one (lt_of_le_of_ne ha (Ne.symm hza))).mpr hay |
| · simp only [zero_mul] |
| field_simp; ring |
| · simpa using ha |
| · have hab : |b * y| ≤ |b| * a := by |
| rw [abs_mul] |
| exact mul_le_mul_of_nonneg_left hay (abs_nonneg b) |
| have hlo := (abs_le.mp hab).1 |
| have hhi := (abs_le.mp hab).2 |
| have hb2 : |b| ^ 2 = b ^ 2 := sq_abs b |
| have hdisc : 0 ≤ a ^ 2 + b ^ 2 + 2 * b * y := by |
| nlinarith [sq_nonneg (a - |b|)] |
| let r := Real.sqrt (a ^ 2 + b ^ 2 + 2 * b * y) |
| have hr : 0 ≤ r := Real.sqrt_nonneg _ |
| have hr2 : r ^ 2 = a ^ 2 + b ^ 2 + 2 * b * y := Real.sq_sqrt hdisc |
| have hupper : r ≤ a + |b| := by nlinarith [abs_nonneg b] |
| have hlower : a - |b| ≤ r := by nlinarith [sq_nonneg (a - |b|)] |
| have habs : |r - a| ≤ |b| := abs_le.mpr ⟨by linarith, by linarith⟩ |
| refine ⟨(r - a) / b, ?_, ?_, ?_⟩ |
| · rw [abs_div] |
| exact (div_le_one (abs_pos.mpr hb)).mpr habs |
| · field_simp |
| nlinarith [hr2] |
| · have heq : a + b * ((r - a) / b) = r := by field_simp; ring |
| rw [heq] |
| exact hr |
|
|
| private theorem abs_mul_bound {x y A B : ℝ} (hx : |x| ≤ A) (hy : |y| ≤ B) |
| (hA : 0 ≤ A) : |x * y| ≤ A * B := by |
| rw [abs_mul] |
| exact mul_le_mul hx hy (abs_nonneg y) hA |
|
|
| theorem no_double_failure {eps x y t p q bp bq : ℝ} |
| (heps : 0 < eps) (hx : |x| ≤ 2) (hy : |y| ≤ 2) |
| (hp : |p| ≤ 1) (hq : |q| ≤ 1) |
| (hrootq : y = (1 - t) * q - eps * x * (1 - q ^ 2) / 2) |
| (hrootp : x = (1 + t) * p + eps * y * (1 - p ^ 2) / 2) |
| (hbp : 0 ≤ bp) (hbq : 0 ≤ bq) (hpadding : 9 * eps ≤ bp + bq) : |
| 1 - t + eps * x * q ≤ 1 + eps ^ 2 * (RadialCaps.H q + bq) ∨ |
| 1 + t - eps * y * p ≤ 1 + eps ^ 2 * (RadialCaps.H p + bp) := by |
| by_contra hfail |
| push Not at hfail |
| obtain ⟨hfq, hfp⟩ := hfail |
| have hep : 0 ≤ eps := heps.le |
| have hp2 : p ^ 2 ≤ 1 := by nlinarith only [hp, sq_abs p, abs_nonneg p] |
| have hq2 : q ^ 2 ≤ 1 := by nlinarith only [hq, sq_abs q, abs_nonneg q] |
| let dp := (1 - p ^ 2) / 2 |
| let dq := (1 - q ^ 2) / 2 |
| have hdp : 0 ≤ dp ∧ dp ≤ 1 / 2 := by dsimp [dp]; constructor <;> nlinarith only [hp2, sq_nonneg p] |
| have hdq : 0 ≤ dq ∧ dq ≤ 1 / 2 := by dsimp [dq]; constructor <;> nlinarith only [hq2, sq_nonneg q] |
| have hHp : 0 ≤ RadialCaps.H p := by unfold RadialCaps.H; positivity |
| have hHq : 0 ≤ RadialCaps.H q := by unfold RadialCaps.H; positivity |
| have htl : eps * y * p < t := by nlinarith only [hfp, mul_nonneg (sq_nonneg eps) (add_nonneg hHp hbp)] |
| have htu : t < eps * x * q := by nlinarith only [hfq, mul_nonneg (sq_nonneg eps) (add_nonneg hHq hbq)] |
| have hxp0 : |x * q| ≤ 2 := by simpa using abs_mul_bound hx hq (by norm_num) |
| have hyp0 : |y * p| ≤ 2 := by simpa using abs_mul_bound hy hp (by norm_num) |
| have ht : |t| ≤ 2 * eps := by |
| have h1 := (abs_le.mp hyp0).1 |
| have h2 := (abs_le.mp hxp0).2 |
| rw [abs_le] |
| constructor <;> nlinarith only [htl, htu, mul_le_mul_of_nonneg_left h1 hep, |
| mul_le_mul_of_nonneg_left h2 hep] |
| have hxp : |x - p| ≤ 3 * eps := by |
| have ht1 : |t * p| ≤ 2 * eps := by simpa using abs_mul_bound ht hp (by positivity) |
| have hy1 : |y * dp| ≤ 1 := by |
| have hh := abs_mul_bound hy (show |dp| ≤ 1 / 2 by rw [abs_of_nonneg hdp.1]; exact hdp.2) (by norm_num) |
| norm_num at hh ⊢ |
| exact hh |
| have hy2 : |eps * (y * dp)| ≤ eps := by |
| simpa using abs_mul_bound (show |eps| ≤ eps by rw [abs_of_nonneg hep]) hy1 hep |
| have heq : x - p = t * p + eps * (y * dp) := by dsimp [dp]; nlinarith only [hrootp] |
| rw [heq] |
| exact (abs_add_le _ _).trans (by linarith only [ht1, hy2]) |
| have hyq : |y - q| ≤ 3 * eps := by |
| have ht1 : |t * q| ≤ 2 * eps := by simpa using abs_mul_bound ht hq (by positivity) |
| have hx1 : |x * dq| ≤ 1 := by |
| have hh := abs_mul_bound hx (show |dq| ≤ 1 / 2 by rw [abs_of_nonneg hdq.1]; exact hdq.2) (by norm_num) |
| norm_num at hh ⊢ |
| exact hh |
| have hx2 : |eps * (x * dq)| ≤ eps := by |
| simpa using abs_mul_bound (show |eps| ≤ eps by rw [abs_of_nonneg hep]) hx1 hep |
| have heq : y - q = -(t * q + eps * (x * dq)) := by dsimp [dq]; nlinarith only [hrootq] |
| rw [heq, abs_neg] |
| exact (abs_add_le _ _).trans (by linarith only [ht1, hx2]) |
| have hpq : |p * q| ≤ 1 := by simpa using abs_mul_bound hp hq (by norm_num) |
| have hxe : |eps * q * (x - p)| ≤ 3 * eps ^ 2 := by |
| have h1 : |eps * q| ≤ eps := by |
| simpa using abs_mul_bound (show |eps| ≤ eps by rw [abs_of_nonneg hep]) hq hep |
| convert abs_mul_bound h1 hxp hep using 1 |
| ring |
| have hye : |eps * p * (y - q)| ≤ 3 * eps ^ 2 := by |
| have h1 : |eps * p| ≤ eps := by |
| simpa using abs_mul_bound (show |eps| ≤ eps by rw [abs_of_nonneg hep]) hp hep |
| convert abs_mul_bound h1 hyq hep using 1 |
| ring |
| have htinterface : |t - eps * p * q| ≤ 3 * eps ^ 2 := by |
| rw [abs_le] |
| constructor |
| · have hh := (abs_le.mp hye).1 |
| nlinarith only [hh, htl] |
| · have hh := (abs_le.mp hxe).2 |
| nlinarith only [hh, htu] |
| have htcoeff : |2 * eps * (p * q)| ≤ 2 * eps := by |
| simpa using abs_mul_bound (show |2 * eps| ≤ 2 * eps by rw [abs_of_nonneg (by positivity)]) hpq (by positivity) |
| have hterr : |2 * eps * (p * q) * (t - eps * p * q)| ≤ 6 * eps ^ 3 := by |
| convert abs_mul_bound htcoeff htinterface (by positivity) using 1 |
| ring |
| have hqD : |q * dp| ≤ 1 / 2 := by |
| simpa using abs_mul_bound hq (show |dp| ≤ 1 / 2 by rw [abs_of_nonneg hdp.1]; exact hdp.2) (by norm_num) |
| have hpD : |p * dq| ≤ 1 / 2 := by |
| simpa using abs_mul_bound hp (show |dq| ≤ 1 / 2 by rw [abs_of_nonneg hdq.1]; exact hdq.2) (by norm_num) |
| have herrq : |(y - q) * (q * dp)| ≤ 3 * eps / 2 := by |
| convert abs_mul_bound hyq hqD (by positivity) using 1 |
| ring |
| have herrp : |(x - p) * (p * dq)| ≤ 3 * eps / 2 := by |
| convert abs_mul_bound hxp hpD (by positivity) using 1 |
| ring |
| have heq : eps * (x * q - y * p) = 2 * eps * p * q * t + |
| eps ^ 2 * (y * q * dp + x * p * dq) := by |
| dsimp [dp, dq] |
| linear_combination eps * q * hrootp - eps * p * hrootq |
| have hmain : eps * (x * q - y * p) ≤ |
| eps ^ 2 * ((p ^ 2 + q ^ 2) / 2 + p ^ 2 * q ^ 2) + 9 * eps ^ 3 := by |
| have hte := (abs_le.mp hterr).2 |
| have hqe := mul_le_mul_of_nonneg_left (abs_le.mp herrq).2 (sq_nonneg eps) |
| have hpe := mul_le_mul_of_nonneg_left (abs_le.mp herrp).2 (sq_nonneg eps) |
| dsimp [dp, dq] at heq hqe hpe |
| nlinarith only [heq, hte, hqe, hpe] |
| have hpoly : (p ^ 2 + q ^ 2) / 2 + p ^ 2 * q ^ 2 ≤ |
| RadialCaps.H p + RadialCaps.H q := by |
| unfold RadialCaps.H |
| nlinarith only [sq_nonneg (p ^ 2 - q ^ 2)] |
| have hfinal : eps * (x * q - y * p) ≤ |
| eps ^ 2 * (RadialCaps.H p + RadialCaps.H q) + 9 * eps ^ 3 := hmain.trans (by |
| have hh := mul_le_mul_of_nonneg_left hpoly (sq_nonneg eps) |
| linarith only [hh]) |
| have hpad := mul_le_mul_of_nonneg_left hpadding (sq_nonneg eps) |
| nlinarith only [hfq, hfp, hfinal, hpad] |
|
|
| theorem padding_coverage {eps : ℝ} {R b : ℝ → ℝ} |
| (heps : 0 < eps) |
| (hcap : ∀ r ∈ Icc (-1 : ℝ) 1, R r = 1 + eps ^ 2 * (RadialCaps.H r + b r)) |
| (hb : ∀ r ∈ Icc (-1 : ℝ) 1, 0 ≤ b r) |
| (hpadding : ∀ p ∈ Icc (-1 : ℝ) 1, ∀ q ∈ Icc (-1 : ℝ) 1, |
| 9 * eps ≤ b p + b q) |
| {x y t : ℝ} (hx : |x| ≤ 1 + t) (hy : |y| ≤ 1 - t) : |
| (∃ q rho : ℝ, |q| ≤ 1 ∧ 0 ≤ rho ∧ rho ≤ R q ∧ |
| y = rho * q - eps * x * RadialCaps.G q ∧ t = 1 - rho + eps * x * q) ∨ |
| (∃ p sigma : ℝ, |p| ≤ 1 ∧ 0 ≤ sigma ∧ sigma ≤ R p ∧ |
| x = sigma * p + eps * y * RadialCaps.G p ∧ t = -1 + sigma + eps * y * p) := by |
| obtain ⟨q, hq, hrootq, hrho⟩ := quadratic_crossing (b := eps * x) hy |
| obtain ⟨p, hp, hrootp, hsigma⟩ := quadratic_crossing (b := -(eps * y)) hx |
| have hrootp' : x = (1 + t) * p + eps * y * (1 - p ^ 2) / 2 := by |
| nlinarith only [hrootp] |
| have hx2 : |x| ≤ 2 := by linarith only [hx, hy, abs_nonneg y] |
| have hy2 : |y| ≤ 2 := by linarith only [hx, hy, abs_nonneg x] |
| have hpI : p ∈ Icc (-1 : ℝ) 1 := abs_le.mp hp |
| have hqI : q ∈ Icc (-1 : ℝ) 1 := abs_le.mp hq |
| rcases no_double_failure heps hx2 hy2 hp hq hrootq hrootp' |
| (hb p hpI) (hb q hqI) (hpadding p hpI q hqI) with hu | hl |
| · left |
| refine ⟨q, 1 - t + eps * x * q, hq, hrho, ?_, ?_, ?_⟩ |
| · simpa only [hcap q hqI] using hu |
| · unfold RadialCaps.G |
| nlinarith only [hrootq] |
| · ring |
| · right |
| refine ⟨p, 1 + t - eps * y * p, hp, ?_, ?_, ?_, ?_⟩ |
| · nlinarith only [hsigma] |
| · simpa only [hcap p hpI] using hl |
| · unfold RadialCaps.G |
| nlinarith only [hrootp'] |
| · ring |
|
|
| theorem padding_covers {h eps : ℝ} {R b : ℝ → ℝ} |
| (heps : 0 < eps) |
| (hcap : ∀ r ∈ Icc (-1 : ℝ) 1, R r = 1 + eps ^ 2 * (RadialCaps.H r + b r)) |
| (hb : ∀ r ∈ Icc (-1 : ℝ) 1, 0 ≤ b r) |
| (hpadding : ∀ p ∈ Icc (-1 : ℝ) 1, ∀ q ∈ Icc (-1 : ℝ) 1, |
| 9 * eps ≤ b p + b q) : |
| RadialPairedSweep.tetrahedron h ⊆ |
| RadialPairedSweep.upperSweep h eps R ∪ RadialPairedSweep.lowerSweep h eps R := by |
| rintro z ⟨x, y, t, hx, hy, rfl⟩ |
| rcases padding_coverage heps hcap hb hpadding hx hy with hu | hl |
| · obtain ⟨q, rho, hq, hrho, hR, hyrep, htrep⟩ := hu |
| left |
| refine ⟨q, abs_le.mp hq, rho, ⟨hrho, hR⟩, x, ?_, ?_⟩ |
| · linarith only [hx, hy, abs_nonneg y] |
| · rw [← hyrep, ← htrep] |
| · obtain ⟨p, sigma, hp, hsigma, hR, hxrep, htrep⟩ := hl |
| right |
| refine ⟨p, abs_le.mp hp, sigma, ⟨hsigma, hR⟩, y, ?_, ?_⟩ |
| · linarith only [hx, hy, abs_nonneg x] |
| · rw [← hxrep, ← htrep] |
|
|
| theorem linear_covers {h beta eps : ℝ} (hbeta : 0 ≤ beta) |
| (heps : 0 < eps) (hsmall : eps ≤ 2 * beta / 9) : |
| RadialPairedSweep.tetrahedron h ⊆ |
| RadialPairedSweep.upperSweep h eps (RadialCaps.linearCap beta eps) ∪ |
| RadialPairedSweep.lowerSweep h eps (RadialCaps.linearCap beta eps) := by |
| apply padding_covers (b := fun _ => beta) heps |
| · intro r hr |
| rfl |
| · intro r hr |
| exact hbeta |
| · intro p hp q hq |
| linarith only [hsmall] |
|
|
| theorem cubic_covers {h c eps : ℝ} (hc : (9 : ℝ) / 2 ≤ c) (heps : 0 < eps) : |
| RadialPairedSweep.tetrahedron h ⊆ |
| RadialPairedSweep.upperSweep h eps (RadialCaps.cubicCap c eps) ∪ |
| RadialPairedSweep.lowerSweep h eps (RadialCaps.cubicCap c eps) := by |
| apply padding_covers (b := fun _ => c * eps) heps |
| · intro r hr |
| unfold RadialCaps.cubicCap |
| ring |
| · intro r hr |
| exact mul_nonneg (by linarith only [hc]) heps.le |
| · intro p hp q hq |
| nlinarith only [mul_le_mul_of_nonneg_right hc heps.le] |
|
|
| theorem fractional_power (eps : ℝ) (heps : 0 < eps) : |
| eps ^ (5 / 2 : ℝ) = eps ^ 2 * Real.sqrt eps := by |
| rw [show (5 / 2 : ℝ) = 2 + 1 / 2 by norm_num, Real.rpow_add heps] |
| rw [← Real.sqrt_eq_rpow] |
| norm_num |
|
|
| theorem fractional_covers {h c eps : ℝ} (hc : 0 < c) (heps : 0 < eps) |
| (hsmall : eps ≤ (2 * c / 9) ^ 2) : |
| RadialPairedSweep.tetrahedron h ⊆ |
| RadialPairedSweep.upperSweep h eps (RadialCaps.fractionalCap c eps) ∪ |
| RadialPairedSweep.lowerSweep h eps (RadialCaps.fractionalCap c eps) := by |
| have hsqrt : Real.sqrt eps ≤ 2 * c / 9 := by |
| nlinarith only [Real.sq_sqrt heps.le, Real.sqrt_nonneg eps, hc, hsmall] |
| apply padding_covers (b := fun _ => c * Real.sqrt eps) heps |
| · intro r hr |
| unfold RadialCaps.fractionalCap |
| rw [fractional_power eps heps] |
| ring |
| · intro r hr |
| exact mul_nonneg hc.le (Real.sqrt_nonneg eps) |
| · intro p hp q hq |
| have hh := mul_le_mul_of_nonneg_right hsqrt (Real.sqrt_nonneg eps) |
| nlinarith only [hh, Real.sq_sqrt heps.le] |
|
|
| end CylinderCovering.RadialCapCoverage |
|
|
| end |
|
|
| end OAI |
|
|
