lean/OAI/Geometry/CylinderCovering/Barycentric/Coverage.lean

import OAI.Geometry.CylinderCovering.Radial.Coordinates
import OAI.Geometry.CylinderCovering.Barycentric.SweepsDefinitions

namespace OAI

namespace CylinderCovering.BarycentricRadial

private theorem abs_mul_le_abs_left {x y : ℝ} (hy : |y| ≤ 1) :
    |x * y| ≤ |x| := by
  rw [abs_mul]
  exact mul_le_of_le_one_right (abs_nonneg x) hy

private theorem quadratic_bounds {w : ℝ} (hw : |w| ≤ 1) :
    0 ≤ (1 + w ^ 2) / 2 ∧ (1 + w ^ 2) / 2 ≤ 1 := by
  have hw2 : w ^ 2 ≤ 1 := by nlinarith [abs_le.mp hw, sq_abs w]
  constructor <;> nlinarith [sq_nonneg w]

theorem joint_excess_bound {k p q w z S T : ℝ}
    (hk : 0 ≤ k) (hkhalf : k ≤ 1 / 2)
    (hp : |p| ≤ 1) (hq : |q| ≤ 1) (hw : |w| ≤ 1) (hz : |z| ≤ 1)
    (hS : 1 / 2 ≤ S) (hT : 1 / 2 ≤ T)
    (hsum : 1 = S + T + k * p * w - k * q * z)
    (hfirst : q = S * w + k * p * ((1 + w ^ 2) / 2))
    (hsecond : p = T * z - k * q * ((1 + z ^ 2) / 2)) :
    S + T - 1 ≤
      k ^ 2 * ((w ^ 2 + w ^ 4) / 4 + (z ^ 2 + z ^ 4) / 4) + 10 * k ^ 3 := by
  let E := S + T - 1
  let gw := (1 + w ^ 2) / 2
  let gz := (1 + z ^ 2) / 2
  have hE0 : 0 ≤ E := by dsimp [E]; linarith
  have hST : |S - T| ≤ E := by rw [abs_le]; dsimp [E]; constructor <;> linarith
  have hgw := quadratic_bounds hw
  have hgz := quadratic_bounds hz
  have hgwabs : |gw| ≤ 1 := by dsimp [gw]; rw [abs_of_nonneg hgw.1]; exact hgw.2
  have hgzabs : |gz| ≤ 1 := by dsimp [gz]; rw [abs_of_nonneg hgz.1]; exact hgz.2
  have hpzg : |p * z * gw| ≤ 1 :=
    (abs_mul_le_abs_left hgwabs).trans ((abs_mul_le_abs_left hz).trans hp)
  have hqwg : |q * w * gz| ≤ 1 :=
    (abs_mul_le_abs_left hgzabs).trans ((abs_mul_le_abs_left hw).trans hq)
  have hSTwz : (S - T) * w * z ≤ E :=
    (le_abs_self _).trans ((abs_mul_le_abs_left hz).trans
      ((abs_mul_le_abs_left hw).trans hST))
  have hcross : q * z - p * w = (S - T) * w * z + k * (p * z * gw + q * w * gz) := by
    dsimp [gw, gz]
    linear_combination z * hfirst - w * hsecond
  have hidentity : E = k * ((S - T) * w * z) + k ^ 2 * (p * z * gw + q * w * gz) := by
    calc
      E = k * (q * z - p * w) := by dsimp [E]; linarith [hsum]
      _ = _ := by rw [hcross]; ring
  have hinner : p * z * gw + q * w * gz ≤ 2 := by
    linarith [(le_abs_self (p * z * gw)).trans hpzg,
      (le_abs_self (q * w * gz)).trans hqwg]
  have hpre : E ≤ k * E + 2 * k ^ 2 := by
    have := add_le_add (mul_le_mul_of_nonneg_left hSTwz hk)
      (mul_le_mul_of_nonneg_left hinner (sq_nonneg k))
    nlinarith only [this, hidentity]
  have hE : E ≤ 4 * k ^ 2 := by
    have := mul_le_mul_of_nonneg_right hkhalf hE0
    nlinarith only [this, hpre]
  have hk2 : 4 * k ^ 2 ≤ 2 * k := by
    nlinarith only [mul_nonneg hk (sub_nonneg.mpr hkhalf)]
  have hTpart : |(T - 1 / 2) * z| ≤ E := by
    apply (abs_mul_le_abs_left hz).trans
    rw [abs_of_nonneg (by linarith : 0 ≤ T - 1 / 2)]
    dsimp [E]
    linarith
  have hSpart : |(S - 1 / 2) * w| ≤ E := by
    apply (abs_mul_le_abs_left hw).trans
    rw [abs_of_nonneg (by linarith : 0 ≤ S - 1 / 2)]
    dsimp [E]
    linarith
  have hkqg : |k * q * gz| ≤ k := by
    apply (abs_mul_le_abs_left hgzabs).trans
    apply (abs_mul_le_abs_left hq).trans
    rw [abs_of_nonneg hk]
  have hkpg : |k * p * gw| ≤ k := by
    apply (abs_mul_le_abs_left hgwabs).trans
    apply (abs_mul_le_abs_left hp).trans
    rw [abs_of_nonneg hk]
  have hperr : |p - z / 2| ≤ 3 * k := by
    have heq : p - z / 2 = (T - 1 / 2) * z - k * q * gz := by
      dsimp [gz]; linarith [hsecond]
    rw [heq]
    have htri := (abs_sub ((T - 1 / 2) * z) (k * q * gz)).trans
      (add_le_add hTpart hkqg)
    linarith only [htri, hE, hk2]
  have hqerr : |q - w / 2| ≤ 3 * k := by
    have heq : q - w / 2 = (S - 1 / 2) * w + k * p * gw := by
      dsimp [gw]; linarith [hfirst]
    rw [heq]
    have htri := (abs_add_le ((S - 1 / 2) * w) (k * p * gw)).trans
      (add_le_add hSpart hkpg)
    linarith only [htri, hE, hk2]
  have hperr' : (p - z / 2) * z * gw ≤ 3 * k :=
    (le_abs_self _).trans ((abs_mul_le_abs_left hgwabs).trans
      ((abs_mul_le_abs_left hz).trans hperr))
  have hqerr' : (q - w / 2) * w * gz ≤ 3 * k :=
    (le_abs_self _).trans ((abs_mul_le_abs_left hgzabs).trans
      ((abs_mul_le_abs_left hw).trans hqerr))
  have hbase : p * z * gw + q * w * gz =
      (w ^ 2 + z ^ 2 + 2 * w ^ 2 * z ^ 2) / 4 +
      (p - z / 2) * z * gw + (q - w / 2) * w * gz := by
    dsimp [gw, gz]; ring
  have hinner' : p * z * gw + q * w * gz ≤
      (w ^ 2 + w ^ 4) / 4 + (z ^ 2 + z ^ 4) / 4 + 6 * k := by
    rw [hbase]
    nlinarith only [hperr', hqerr', sq_nonneg (w ^ 2 - z ^ 2)]
  have hfinal := add_le_add (mul_le_mul_of_nonneg_left hSTwz hk)
    (mul_le_mul_of_nonneg_left hinner' (sq_nonneg k))
  have hkE := mul_le_mul_of_nonneg_left hE hk
  rw [← hidentity] at hfinal
  change E ≤ _
  nlinarith only [hfinal, hkE]

theorem capped_alternative {k p q w z S T : ℝ}
    (hk : 0 < k) (hkbound : k ≤ 1 / 5000)
    (hp : |p| ≤ 1) (hq : |q| ≤ 1) (hw : |w| ≤ 1) (hz : |z| ≤ 1)
    (hsum : 1 = S + T + k * p * w - k * q * z)
    (hfirst : q = S * w + k * p * ((1 + w ^ 2) / 2))
    (hsecond : p = T * z - k * q * ((1 + z ^ 2) / 2)) :
    S ≤ 1 / 2 + k ^ 2 * ((w ^ 2 + w ^ 4) / 4 + 1 / 1000) ∨
    T ≤ 1 / 2 + k ^ 2 * ((z ^ 2 + z ^ 4) / 4 + 1 / 1000) := by
  by_contra h
  push Not at h
  have hw0 : 0 ≤ (w ^ 2 + w ^ 4) / 4 + (1 : ℝ) / 1000 := by positivity
  have hz0 : 0 ≤ (z ^ 2 + z ^ 4) / 4 + (1 : ℝ) / 1000 := by positivity
  have hS : 1 / 2 ≤ S := by nlinarith [mul_nonneg (sq_nonneg k) hw0]
  have hT : 1 / 2 ≤ T := by nlinarith [mul_nonneg (sq_nonneg k) hz0]
  have hupper := joint_excess_bound (le_of_lt hk) (by linarith) hp hq hw hz hS hT
    hsum hfirst hsecond
  have hsmall := mul_le_mul_of_nonneg_right hkbound (sq_nonneg k)
  nlinarith only [hupper, h.1, h.2, hsmall]

end CylinderCovering.BarycentricRadial

namespace RadialCoordinates

open Set

theorem nonnegative_complementary_representations {a b c d : ℝ}
    (ha : 0 ≤ a) (hb : 0 ≤ b) (hc : 0 ≤ c) (hd : 0 ≤ d)
    (hsum : a + b + c + d = 1) (k : ℝ) :
    ∃ t r S T : ℝ,
      t ∈ Icc 0 1 ∧ r ∈ Icc 0 1 ∧ 0 ≤ S ∧ 0 ≤ T ∧
      a = S * t + k * (c - d) * t ^ 2 ∧
      b = S * (1 - t) - k * (c - d) * (1 - t) ^ 2 ∧
      c = T * r - k * (a - b) * r ^ 2 ∧
      d = T * (1 - r) + k * (a - b) * (1 - r) ^ 2 ∧
      1 = S + T + k * (c - d) * angular t - k * (a - b) * angular r ∧
      a - b = S * angular t + k * (c - d) * ((1 + angular t ^ 2) / 2) ∧
      c - d = T * angular r - k * (a - b) * ((1 + angular r ^ 2) / 2) := by
  obtain ⟨t, S, ht, hS, hat, hbt⟩ :=
    CylinderCovering.BarycentricRadial.exists_nonnegative_radial_representation ha hb (k * (c-d))
  obtain ⟨r, T, hr, hT, hcr, hdr⟩ :=
    CylinderCovering.BarycentricRadial.exists_nonnegative_radial_representation hc hd ((-k) * (a-b))
  have heq1 := radial_representation_sum_difference hat hbt
  have heq2 := radial_representation_sum_difference hcr hdr
  refine ⟨t, r, S, T, ht, hr, hS, hT, hat, hbt, ?_, ?_, ?_, ?_, ?_⟩
  · nlinarith only [hcr]
  · nlinarith only [hdr]
  · nlinarith only [heq1.1, heq2.1, hsum]
  · nlinarith only [heq1.2]
  · nlinarith only [heq2.2]

theorem cap_eq_angular_polynomial (k t : ℝ) :
    cap k t = 1 / 2 + k ^ 2 *
      ((angular t ^ 2 + angular t ^ 4) / 4 + 1 / 1000) := by
  unfold cap capPolynomial
  ring

theorem barycentric_simplex_covered {k : ℝ} (hk : 0 < k) (hkbound : k ≤ 1 / 5000) :
    barycentricSimplex ⊆ firstSweep k ∪ secondSweep k := by
  intro v hv
  obtain ⟨hnonneg, hsum⟩ := hv
  have hsum' : v 0 + v 1 + v 2 + v 3 = 1 := by
    simpa [Fin.sum_univ_succ, add_assoc] using hsum
  obtain ⟨t, r, S, T, ht, hr, hS, hT, hat, hbt, hcr, hdr, heq, heq1, heq2⟩ :=
    nonnegative_complementary_representations (hnonneg 0) (hnonneg 1)
      (hnonneg 2) (hnonneg 3) hsum' k
  have hp : |v 2 - v 3| ≤ 1 := by
    rw [abs_le]
    constructor <;> linarith [hnonneg 0, hnonneg 1, hnonneg 2, hnonneg 3]
  have hq : |v 0 - v 1| ≤ 1 := by
    rw [abs_le]
    constructor <;> linarith [hnonneg 0, hnonneg 1, hnonneg 2, hnonneg 3]
  have hw : |angular t| ≤ 1 := by
    rw [abs_le]; unfold angular
    constructor <;> linarith [ht.1, ht.2]
  have hz : |angular r| ≤ 1 := by
    rw [abs_le]; unfold angular
    constructor <;> linarith [hr.1, hr.2]
  have hcap := CylinderCovering.BarycentricRadial.capped_alternative hk hkbound
    hp hq hw hz heq heq1 heq2
  rw [← cap_eq_angular_polynomial, ← cap_eq_angular_polynomial] at hcap
  rcases hcap with hcap | hcap
  · exact Or.inl ⟨hsum, t, S, ht, hS, hcap, hp, hat, hbt⟩
  · exact Or.inr ⟨hsum, r, T, hr, hT, hcap, hq, hcr, hdr⟩

end RadialCoordinates

end OAI