lean/OAI/Combinatorics/HalvingLines/Intersections.lean

import OAI.Combinatorics.HalvingLines.Curves

namespace OAI

namespace PlanarHalving

namespace Zoom

open scoped NNReal Topology
open Filter

lemma intersects_parameter_graph {E : Type*} [NormedAddCommGroup E]
    [NormedSpace ℝ E] (ℓ ψ : E →L[ℝ] ℝ)
    (hjoint : Function.Injective (fun x : E => (ℓ x, ψ x)))
    (a : E) (R c d : ℝ) (hcd : c ≤ d)
    (γ : Set.Icc (-R) R → E) (β : Set.Icc c d → E)
    (hγ : Continuous γ) (hβ : Continuous β)
    (hlevel : ∀ s, ℓ (γ s - a) = s)
    (hinside : ∀ t, ℓ (β t - a) ∈ Set.Icc (-R) R)
    (hlower : ψ (β ⟨c, ⟨le_rfl, hcd⟩⟩) ≤
      ψ (γ ⟨ℓ (β ⟨c, ⟨le_rfl, hcd⟩⟩ - a), hinside _⟩))
    (hupper : ψ (γ ⟨ℓ (β ⟨d, ⟨hcd, le_rfl⟩⟩ - a), hinside _⟩) ≤
      ψ (β ⟨d, ⟨hcd, le_rfl⟩⟩)) :
    ∃ t s, β t = γ s := by
  let p (t : Set.Icc c d) : Set.Icc (-R) R := ⟨ℓ (β t - a), hinside t⟩
  have hp : Continuous p :=
    (ℓ.continuous.comp (hβ.sub continuous_const)).subtype_mk _
  let H (t : Set.Icc c d) : ℝ := ψ (β t) - ψ (γ (p t))
  have hH : Continuous H :=
    (ψ.continuous.comp hβ).sub (ψ.continuous.comp (hγ.comp hp))
  let c' : Set.Icc c d := ⟨c, ⟨le_rfl, hcd⟩⟩
  let d' : Set.Icc c d := ⟨d, ⟨hcd, le_rfl⟩⟩
  have hmem : (0 : ℝ) ∈ Set.Icc (H c') (H d') :=
    ⟨sub_nonpos.mpr hlower, sub_nonneg.mpr hupper⟩
  let : PreconnectedSpace (Set.Icc c d) :=
    isPreconnected_iff_preconnectedSpace.mp isPreconnected_Icc
  obtain ⟨t, ht⟩ := intermediate_value_univ c' d' hH hmem
  refine ⟨t, p t, hjoint (Prod.ext ?_ (sub_eq_zero.mp ht))⟩
  have he := hlevel (p t)
  change ℓ (γ (p t) - a) = ℓ (β t - a) at he
  simpa only [map_sub, sub_left_inj] using he.symm

lemma eventual_arc_intersection {E : Type*} [NormedAddCommGroup E]
    [NormedSpace ℝ E] (ℓ ψ : E →L[ℝ] ℝ)
    (hjoint : Function.Injective (fun x : E => (ℓ x, ψ x)))
    (a : ℕ → E) (a₀ c v w : E) (R D r : ℝ)
    (hD : 0 < D) (hr : 0 < r)
    (γ : ℕ → Set.Icc (-R) R → E) (β : ℕ → Set.Icc (-D) D → E)
    (ha : Tendsto a atTop (𝓝 a₀))
    (hγ : TendstoUniformly γ (fun s => a₀ + (s : ℝ) • v) atTop)
    (hβ : TendstoUniformly β (fun t => c + (t : ℝ) • w) atTop)
    (hcγ : ∀ n, Continuous (γ n)) (hcβ : ∀ n, Continuous (β n))
    (hlevel : ∀ᶠ n in atTop, ∀ s, ℓ (γ n s - a n) = s)
    (hinside : ∀ t : Set.Icc (-D) D, |ℓ (c + (t : ℝ) • w - a₀)| ≤ R - r)
    (hψv : ψ v = 0) (hψc : ψ c = ψ a₀) (hψw : 0 < ψ w) :
    ∀ᶠ n in atTop, ∃ t s, β n t = γ n s := by
  have hℓβ := ℓ.uniformContinuous.comp_tendstoUniformly hβ
  have hψβ := ψ.uniformContinuous.comp_tendstoUniformly hβ
  have hψγ := ψ.uniformContinuous.comp_tendstoUniformly hγ
  have ha' : ∀ᶠ n in atTop, |ℓ (a n) - ℓ a₀| < r / 2 := by
    have hh := ((ℓ.continuous.tendsto a₀).comp ha).eventually
      (Metric.ball_mem_nhds (ℓ a₀) (half_pos hr))
    simpa only [Metric.mem_ball, Real.dist_eq, Function.comp_apply] using hh
  have hℓβ' := Metric.tendstoUniformly_iff.mp hℓβ (r / 2) (half_pos hr)
  let e : ℝ := D * ψ w / 3
  have he : 0 < e := div_pos (mul_pos hD hψw) (by norm_num)
  have hψβ' := Metric.tendstoUniformly_iff.mp hψβ e he
  have hψγ' := Metric.tendstoUniformly_iff.mp hψγ e he
  filter_upwards [ha', hℓβ', hψβ', hψγ', hlevel] with n han hℓn hβn hγn hleveln
  have hi (t : Set.Icc (-D) D) : ℓ (β n t - a n) ∈ Set.Icc (-R) R := by
    have h₁ : -(r / 2) < ℓ (c + (t : ℝ) • w) - ℓ (β n t) ∧
        ℓ (c + (t : ℝ) • w) - ℓ (β n t) < r / 2 := abs_lt.mp (hℓn t)
    have h₂ := abs_lt.mp han
    have h₃ := abs_le.mp (hinside t)
    simp only [map_sub] at h₃ ⊢
    constructor <;> linarith
  let lo : Set.Icc (-D) D := ⟨-D, ⟨le_rfl, by linarith⟩⟩
  let up : Set.Icc (-D) D := ⟨D, ⟨by linarith, le_rfl⟩⟩
  have hl : ψ (β n lo) ≤ ψ (γ n ⟨ℓ (β n lo - a n), hi lo⟩) := by
    have hb := hβn lo
    have hg := hγn ⟨ℓ (β n lo - a n), hi lo⟩
    simp only [Function.comp_apply, Real.dist_eq, map_add, map_smul,
      hψv, hψc, smul_eq_mul, mul_zero, add_zero] at hb hg
    change |ψ a₀ + (-D) * ψ w - ψ (β n lo)| < e at hb
    have hb' := abs_lt.mp hb
    have hg' := abs_lt.mp hg
    dsimp [e] at hb' hg'
    nlinarith
  have hu : ψ (γ n ⟨ℓ (β n up - a n), hi up⟩) ≤ ψ (β n up) := by
    have hb := hβn up
    have hg := hγn ⟨ℓ (β n up - a n), hi up⟩
    simp only [Function.comp_apply, Real.dist_eq, map_add, map_smul,
      hψv, hψc, smul_eq_mul, mul_zero, add_zero] at hb hg
    change |ψ a₀ + D * ψ w - ψ (β n up)| < e at hb
    have hb' := abs_lt.mp hb
    have hg' := abs_lt.mp hg
    dsimp [e] at hb' hg'
    nlinarith
  exact intersects_parameter_graph ℓ ψ hjoint (a n) R (-D) D (by linarith)
    (γ n) (β n) (hcγ n) (hcβ n) hleveln hi hl hu

lemma level_forces_nonzero {E : Type*} [NormedAddCommGroup E]
    [NormedSpace ℝ E] [ProperSpace E]
    (a b : ℕ → E) (a₀ v : E) (ℓ : E →L[ℝ] ℝ) (B : ℝ)
    (ha : Tendsto a atTop (𝓝 a₀))
    (hbound : ∀ᶠ n in atTop, ‖b n - a n‖ ≤ B)
    (hlevel : ∀ᶠ n in atTop, ℓ (b n - a n) = 1)
    (hdirection : ∀ (ρ : ℕ → ℕ), StrictMono ρ → ∀ b₀ : E,
      Tendsto (b ∘ ρ) atTop (𝓝 b₀) → ∃ r : ℝ, b₀ - a₀ = r • v) :
    ℓ v ≠ 0 := by
  obtain ⟨C, _, hC⟩ := (Metric.isBounded_range_of_tendsto a ha).exists_pos_norm_le
  have hb : ∀ᶠ n in atTop, b n ∈ Metric.closedBall (0 : E) (B + C) := by
    filter_upwards [hbound] with n hn
    rw [Metric.mem_closedBall, dist_zero_right]
    calc
      ‖b n‖ = ‖(b n - a n) + a n‖ := by rw [sub_add_cancel]
      _ ≤ ‖b n - a n‖ + ‖a n‖ := norm_add_le _ _
      _ ≤ B + C := add_le_add hn (hC _ (Set.mem_range_self n))
  obtain ⟨b₀, _, ρ, hρ, hlim⟩ :=
    (isCompact_closedBall (0 : E) (B + C)).isSeqCompact.subseq_of_frequently_in hb.frequently
  obtain ⟨r, hr⟩ := hdirection ρ hρ b₀ hlim
  have hm := (ℓ.continuous.tendsto (b₀ - a₀)).comp
    (hlim.sub (ha.comp hρ.tendsto_atTop))
  change Tendsto (fun n => ℓ (b (ρ n) - a (ρ n))) atTop
    (𝓝 (ℓ (b₀ - a₀))) at hm
  have he : ℓ (b₀ - a₀) = 1 :=
    tendsto_nhds_unique (hm.congr' (hρ.tendsto_atTop.eventually hlevel)) tendsto_const_nhds
  intro hv
  simp only [hr, map_smul, hv, smul_zero] at he
  exact zero_ne_one he

def DirectionalLimit {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (f : ℕ → E → E) (v w : E) : Prop :=
  ∀ (ρ : ℕ → ℕ), StrictMono ρ → ∀ (x y : ℕ → E),
    (∀ n, ∃ t : ℝ, y n = x n + t • v) → ∀ a b : E,
    Tendsto (fun n => f (ρ n) (x n)) atTop (𝓝 a) →
    Tendsto (fun n => f (ρ n) (y n)) atTop (𝓝 b) →
    ∃ r : ℝ, b - a = r • w

lemma controlled_line_arcs {E : Type*} [NormedAddCommGroup E]
    [NormedSpace ℝ E] [ProperSpace E]
    (f : ℕ → OpenPartialHomeomorph E E) (hsource : ∀ n, (f n).source = Set.univ)
    (hexhaust : ∀ K : Set E, IsCompact K → ∀ᶠ n in atTop, K ⊆ (f n).target)
    (x : ℕ → E) (a₀ v : E) (hv : v ≠ 0) (ℓ : E →L[ℝ] ℝ)
    (M : ℝ≥0) (hM : 0 < M) (R : ℝ) (hR : 0 ≤ R)
    (ha : Tendsto (fun n => f n (x n)) atTop (𝓝 a₀))
    (hmono : ∀ n, StrictMono (fun t : ℝ => ℓ (f n (x n + t • v) - f n (x n))))
    (hcone : ∀ n (t u : ℝ), ‖f n (x n + t • v) - f n (x n + u • v)‖ ≤
      M * |ℓ (f n (x n + t • v) - f n (x n + u • v))|) :
    ∃ γ : ℕ → Set.Icc (-R) R → E,
      (∀ n, LipschitzWith M (γ n)) ∧
      (∀ n s, ∃ t : ℝ, γ n s = f n (x n + t • v)) ∧
      (∀ᶠ n in atTop, ∀ s, ℓ (γ n s - f n (x n)) = s) ∧
      (∀ n, γ n ⟨0, ⟨neg_nonpos.mpr hR, hR⟩⟩ = f n (x n)) := by
  classical
  obtain ⟨C, _, hC⟩ := (Metric.isBounded_range_of_tendsto _ ha).exists_pos_norm_le
  have ht : ∀ᶠ n in atTop, Metric.closedBall (f n (x n)) (M * R) ⊆ (f n).target := by
    filter_upwards [hexhaust (Metric.closedBall (0 : E) (C + M * R))
      (isCompact_closedBall _ _)] with n hn
    intro y hy
    apply hn
    rw [Metric.mem_closedBall, dist_zero_right]
    calc
      ‖y‖ = ‖f n (x n) + (y - f n (x n))‖ := by rw [add_sub_cancel]
      _ ≤ ‖f n (x n)‖ + ‖y - f n (x n)‖ := norm_add_le _ _
      _ ≤ C + M * R := add_le_add (hC _ (Set.mem_range_self n))
        (by simpa only [Metric.mem_closedBall, dist_eq_norm] using hy)
  have hc (n : ℕ) : ∃ g : Set.Icc (-R) R → E,
      LipschitzWith M g ∧ (∀ s, ∃ t : ℝ, g s = f n (x n + t • v)) ∧
      (Metric.closedBall (f n (x n)) (M * R) ⊆ (f n).target →
        ∀ s, ℓ (g s - f n (x n)) = s) ∧
      g ⟨0, ⟨neg_nonpos.mpr hR, hR⟩⟩ = f n (x n) := by
    by_cases hi : Metric.closedBall (f n (x n)) (M * R) ⊆ (f n).target
    · obtain ⟨g, hg, hmem, hlevel, hz⟩ := line_parameter_curve (f n) (hsource n)
        (x n) v hv ℓ M R hM hR (hmono n) (hcone n) hi
      exact ⟨g, hg, hmem, fun _ => hlevel, hz⟩
    · refine ⟨fun _ => f n (x n), LipschitzWith.const' _, ?_,
        fun h => (hi h).elim, rfl⟩
      intro s
      exact ⟨0, by rw [zero_smul, add_zero]⟩
  choose γ hγ hmem hlevel hz using hc
  exact ⟨γ, hγ, hmem, ht.mono (fun n hn => hlevel n hn), hz⟩

lemma moving_line_arcs_tendsto {E : Type*} [NormedAddCommGroup E]
    [NormedSpace ℝ E] [ProperSpace E]
    (f : ℕ → OpenPartialHomeomorph E E) (hsource : ∀ n, (f n).source = Set.univ)
    (hexhaust : ∀ K : Set E, IsCompact K → ∀ᶠ n in atTop, K ⊆ (f n).target)
    (x : ℕ → E) (a₀ v w : E) (hv : v ≠ 0) (ℓ : E →L[ℝ] ℝ)
    (M : ℝ≥0) (hM : 0 < M)
    (ha : Tendsto (fun n => f n (x n)) atTop (𝓝 a₀))
    (hmono : ∀ n, StrictMono (fun t : ℝ => ℓ (f n (x n + t • v) - f n (x n))))
    (hcone : ∀ n (t u : ℝ), ‖f n (x n + t • v) - f n (x n + u • v)‖ ≤
      M * |ℓ (f n (x n + t • v) - f n (x n + u • v))|)
    (hdir : DirectionalLimit (fun n => f n) v w) :
    ℓ w ≠ 0 ∧ ∀ R : ℝ, ∀ _hR : 0 ≤ R,
      ∃ γ : ℕ → Set.Icc (-R) R → E,
        (∀ n, LipschitzWith M (γ n)) ∧
        (∀ n s, ∃ t : ℝ, γ n s = f n (x n + t • v)) ∧
        (∀ᶠ n in atTop, ∀ s, ℓ (γ n s - f n (x n)) = s) ∧
        TendstoUniformly γ (fun s => a₀ + ((s : ℝ) / ℓ w) • w) atTop := by
  have hdirs (R : ℝ) (γ : ℕ → Set.Icc (-R) R → E)
      (hmem : ∀ n s, ∃ t : ℝ, γ n s = f n (x n + t • v))
      (s : Set.Icc (-R) R) (ρ : ℕ → ℕ) (hρ : StrictMono ρ) (b₀ : E)
      (hb : Tendsto (fun n => γ (ρ n) s) atTop (𝓝 b₀)) :
      ∃ r : ℝ, b₀ - a₀ = r • w := by
    choose t ht using fun n => hmem (ρ n) s
    apply hdir ρ hρ (fun n => x (ρ n)) (fun n => x (ρ n) + t n • v)
      (fun n => ⟨t n, rfl⟩) a₀ b₀ (ha.comp hρ.tendsto_atTop)
    simpa only [← ht] using hb
  obtain ⟨γ₁, hLip₁, hmem₁, hlevel₁, hz₁⟩ := controlled_line_arcs f hsource hexhaust
    x a₀ v hv ℓ M hM 1 (by norm_num) ha hmono hcone
  let one : Set.Icc (-1 : ℝ) 1 := ⟨1, ⟨by norm_num, le_rfl⟩⟩
  have hw : ℓ w ≠ 0 := by
    apply level_forces_nonzero (fun n => f n (x n)) (fun n => γ₁ n one)
      a₀ w ℓ M ha ?_ (hlevel₁.mono fun _ hn => hn one) (hdirs 1 γ₁ hmem₁ one)
    apply Filter.Eventually.of_forall
    intro n
    have hh := (hLip₁ n).dist_le_mul one ⟨0, by norm_num, by norm_num⟩
    simpa only [hz₁, Subtype.dist_eq, dist_eq_norm, Real.norm_eq_abs,
      one, sub_zero, abs_one, mul_one] using hh
  refine ⟨hw, ?_⟩
  intro R hR
  obtain ⟨γ, hLip, hmem, hlevel, hz⟩ := controlled_line_arcs f hsource hexhaust
    x a₀ v hv ℓ M hM R hR ha hmono hcone
  exact ⟨γ, hLip, hmem, hlevel,
    parameter_curves_tendsto R hR γ (fun n => f n (x n)) a₀ w ℓ M ha hLip hz
      hlevel hw (hdirs R γ hmem)⟩

lemma line_intersection_tendsto {E : Type*} [NormedAddCommGroup E]
    [NormedSpace ℝ E] (ℓ ψ : E →L[ℝ] ℝ)
    (hjoint : Function.Injective (fun x : E => (ℓ x, ψ x)))
    (A B : ℕ → Set E) (z a : ℕ → E) (a₀ b₀ c v w : E) (q : ℝ)
    (ha : Tendsto a atTop (𝓝 a₀))
    (hc : c = b₀ + q • w) (hψv : ψ v = 0) (hψc : ψ c = ψ a₀)
    (hψw : 0 < ψ w)
    (hunique : ∀ n y, y ∈ A n → y ∈ B n → y = z n)
    (hA : ∀ R : ℝ, 0 ≤ R → ∃ γ : ℕ → Set.Icc (-R) R → E,
      (∀ n, Continuous (γ n)) ∧ (∀ n s, γ n s ∈ A n) ∧
      (∀ᶠ n in atTop, ∀ s, ℓ (γ n s - a n) = s) ∧
      TendstoUniformly γ (fun s => a₀ + (s : ℝ) • v) atTop)
    (hB : ∀ R : ℝ, 0 ≤ R → ∃ δ : ℕ → Set.Icc (-R) R → E,
      (∀ n, Continuous (δ n)) ∧ (∀ n s, δ n s ∈ B n) ∧
      TendstoUniformly δ (fun s => b₀ + (s : ℝ) • w) atTop) :
    Tendsto z atTop (𝓝 c) := by
  rw [Metric.tendsto_atTop]
  intro ε hε
  let d : ℝ := min ε 1 / (4 * (‖w‖ + |ℓ w| + 1))
  have hden : 0 < 4 * (‖w‖ + |ℓ w| + 1) := by positivity
  have hd : 0 < d := div_pos (lt_min hε zero_lt_one) hden
  have hdw : d * ‖w‖ < ε / 2 := by
    have hmul : d * (4 * (‖w‖ + |ℓ w| + 1)) = min ε 1 :=
      div_mul_cancel₀ _ (ne_of_gt hden)
    have hmin := min_le_left ε 1
    have ha := abs_nonneg (ℓ w)
    have hn := norm_nonneg w
    nlinarith only [hmul, hmin, ha, hn, hd]
  have hdl : d * |ℓ w| ≤ 1 / 2 := by
    have hmul : d * (4 * (‖w‖ + |ℓ w| + 1)) = min ε 1 :=
      div_mul_cancel₀ _ (ne_of_gt hden)
    have hmin := min_le_right ε 1
    have hn := norm_nonneg w
    have ha := abs_nonneg (ℓ w)
    nlinarith only [hmul, hmin, ha, hn, hd]
  let R : ℝ := |ℓ (c - a₀)| + 1
  obtain ⟨γ, hcγ, hmemγ, hlevel, hγ⟩ := hA R (by dsimp [R]; positivity)
  obtain ⟨δ, hcδ, hmemδ, hδ⟩ := hB (|q| + d) (by positivity)
  let p (t : Set.Icc (-d) d) : Set.Icc (-(|q| + d)) (|q| + d) :=
    ⟨q + t, by
      constructor
      · linarith only [t.property.1, neg_abs_le q]
      · linarith only [t.property.2, le_abs_self q]⟩
  have hp : Continuous p :=
    (continuous_const.add continuous_subtype_val).subtype_mk _
  let β (n : ℕ) (t : Set.Icc (-d) d) : E := δ n (p t)
  have hβ : TendstoUniformly β (fun t => c + (t : ℝ) • w) atTop := by
    have hh := hδ.comp p
    change TendstoUniformly β (fun t => b₀ + (q + (t : ℝ)) • w) atTop at hh
    simpa only [hc, add_smul, add_assoc] using hh
  have hi (t : Set.Icc (-d) d) : |ℓ (c + (t : ℝ) • w - a₀)| ≤ R - 1 / 2 := by
    have ht : |(t : ℝ)| ≤ d := abs_le.mpr t.property
    calc
      |ℓ (c + (t : ℝ) • w - a₀)| = |ℓ (c - a₀) + (t : ℝ) * ℓ w| := by
        congr 1
        rw [add_sub_right_comm, map_add, map_smul, smul_eq_mul]
      _ ≤ |ℓ (c - a₀)| + |(t : ℝ) * ℓ w| := abs_add_le _ _
      _ ≤ |ℓ (c - a₀)| + d * |ℓ w| := by
        rw [abs_mul]
        exact add_le_add le_rfl (mul_le_mul_of_nonneg_right ht (abs_nonneg _))
      _ ≤ R - 1 / 2 := by dsimp [R]; linarith
  have hinter := eventual_arc_intersection ℓ ψ hjoint a a₀ c v w R d (1 / 2)
    hd (by norm_num) γ β ha hγ hβ hcγ (fun n => (hcδ n).comp hp)
    hlevel hi hψv hψc hψw
  have hclose := Metric.tendstoUniformly_iff.mp hβ (ε / 2) (half_pos hε)
  obtain ⟨N, hN⟩ := eventually_atTop.mp (hinter.and hclose)
  refine ⟨N, ?_⟩
  intro n hn
  obtain ⟨⟨t, s, hts⟩, hclose⟩ := hN n hn
  have he : β n t = z n := hunique n (β n t) (hts ▸ hmemγ n s) (hmemδ n (p t))
  calc
    dist (z n) c = dist (β n t) c := by rw [he]
    _ ≤ dist (β n t) (c + (t : ℝ) • w) + dist (c + (t : ℝ) • w) c := dist_triangle _ _ _
    _ < ε / 2 + ε / 2 := by
      apply add_lt_add
      · exact (dist_comm _ _).trans_lt (hclose t)
      · rw [dist_eq_norm, add_sub_cancel_left, norm_smul, Real.norm_eq_abs]
        exact lt_of_le_of_lt (mul_le_mul_of_nonneg_right
          (abs_le.mpr t.property) (norm_nonneg w)) hdw
    _ = ε := by ring

def detPair (u v : Point) : ℝ := u.1 * v.2 - u.2 * v.1

lemma plane_span (u v : Point) (hdet : detPair u v ≠ 0) (x : Point) :
    ∃ r s : ℝ, x = r • u + s • v := by
  refine ⟨(x.1 * v.2 - x.2 * v.1) / detPair u v,
    (u.1 * x.2 - u.2 * x.1) / detPair u v, ?_⟩
  apply Prod.ext <;> dsimp
  · field_simp
    simp only [detPair]
    ring
  · field_simp
    simp only [detPair]
    ring

lemma transverse_covector (ℓ : Point →L[ℝ] ℝ) (u v : Point)
    (hℓu : ℓ u ≠ 0) (hdet : detPair u v ≠ 0) :
    ∃ ψ : Point →L[ℝ] ℝ,
      Function.Injective (fun x : Point => (ℓ x, ψ x)) ∧ ψ u = 0 ∧ ψ v = 1 := by
  let φ : Point →L[ℝ] ℝ :=
    u.1 • ContinuousLinearMap.snd ℝ ℝ ℝ - u.2 • ContinuousLinearMap.fst ℝ ℝ ℝ
  have hφu : φ u = 0 := by change u.1 * u.2 - u.2 * u.1 = 0; ring
  have hφv : φ v = detPair u v := rfl
  let ψ : Point →L[ℝ] ℝ := (detPair u v)⁻¹ • φ
  have hψu : ψ u = 0 := by simp [ψ, hφu]
  have hψv : ψ v = 1 := by simp [ψ, hφv, hdet]
  refine ⟨ψ, ?_, hψu, hψv⟩
  intro x y hxy
  obtain ⟨r, s, hrs⟩ := plane_span u v hdet (x - y)
  have h₁ : ℓ (x - y) = 0 := by
    rw [map_sub]
    exact sub_eq_zero.mpr (congrArg Prod.fst hxy)
  have h₂ : ψ (x - y) = 0 := by
    rw [map_sub]
    exact sub_eq_zero.mpr (congrArg Prod.snd hxy)
  have hs : s = 0 := by
    simpa only [hrs, map_add, map_smul, hψu, hψv, smul_zero, zero_add,
      smul_eq_mul, mul_one, mul_zero, zero_add] using h₂
  have hr : r = 0 := by
    have hh : r * ℓ u = 0 := by simpa only [hrs, hs, zero_smul, add_zero,
      map_smul, smul_eq_mul] using h₁
    exact (mul_eq_zero.mp hh).resolve_right hℓu
  apply sub_eq_zero.mp
  simpa only [hr, hs, zero_smul, add_zero] using hrs

lemma detPair_smul_right (u v : Point) (r : ℝ) :
    detPair u (r • v) = r * detPair u v := by
  dsimp [detPair]
  ring

end Zoom

end PlanarHalving

end OAI