import OAI.Combinatorics.HalvingLines.Chains

namespace OAI

open Filter Topology

namespace PlanarHalving.Batches
open PlaneGraph
variable {n R k a : ℕ} {P : Fin n → Point}

noncomputable def System.flip (S : @System n R k a P) :
    @System n R (n-k) a (fun v => -P v) where
  slope := S.slope
  increasing := S.increasing
  marks b := (S.marks b)ᶜ
  card_marks b := by
    classical
    rw [Finset.card_compl, S.card_marks, Fintype.card_fin]
  separates b := by
    classical
    intro i hi j hj
    have hi' := Finset.mem_compl.mp hi
    have hj' : j ∈ S.marks b := by simpa using hj
    have h := S.separates b j hj' i hi'
    simp only [Sweep.projection, Prod.fst_neg, Prod.snd_neg] at *
    linarith
  distance b := by
    classical
    have he : (S.marks b.castSucc)ᶜ \ (S.marks b.succ)ᶜ = S.gain b := by
      ext u
      simp [System.gain, and_comm]
    rw [he, S.card_gain]

@[simp] lemma System.flip_loss (S : @System n R k a P) (b : Fin R) :
    S.flip.loss b = S.gain b := by
  classical
  ext u
  simp [System.loss, System.gain, System.flip, and_comm]
@[simp] lemma System.flip_gain (S : @System n R k a P) (b : Fin R) :
    S.flip.gain b = S.loss b := by
  classical
  ext u
  simp [System.loss, System.gain, System.flip, and_comm]

lemma System.flip_edge (S : @System n R k a P) (e : Fin n × Fin n) :
    e.swap ∈ S.flip.edges ↔ e ∈ S.edges := by
  rw [S.flip.mem_edges, S.mem_edges]
  simp only [Prod.fst_swap, Prod.snd_swap, System.flip_loss, System.flip_gain, and_comm]

lemma System.flip_vertices (S : @System n R k a P) : S.flip.vertices = S.vertices := by
  classical
  ext u
  simp only [System.vertices, Finset.mem_union, Finset.mem_image]
  constructor
  · rintro (⟨e,he,hu⟩ | ⟨e,he,hu⟩)
    · exact Or.inr ⟨e.swap, (S.flip_edge e.swap).mp (by simpa using he), hu⟩
    · exact Or.inl ⟨e.swap, (S.flip_edge e.swap).mp (by simpa using he), hu⟩
  · rintro (⟨e,he,hu⟩ | ⟨e,he,hu⟩)
    · exact Or.inr ⟨e.swap, (S.flip_edge e).mpr he, hu⟩
    · exact Or.inl ⟨e.swap, (S.flip_edge e).mpr he, hu⟩

noncomputable def System.concaveCover (S : @System n R k a P) [NeZero n] [NeZero a] :
    ConcaveCover S.drawing (Fin a × Fin n) where
  owner e := S.flip.convexOwner e.swap
  support e he f hf ho z hz := by
    have he' : e.swap ∈ S.flip.drawing.edges := (S.flip_edge e).mpr he
    have hf' : f.swap ∈ S.flip.drawing.edges := (S.flip_edge f).mpr hf
    have hz' : -z ∈ segment ℝ (-P f.2) (-P f.1) := by
      rw [segment_eq_image] at hz ⊢
      obtain ⟨u,hu,hz⟩ := hz
      refine ⟨1-u, ⟨by linarith only [hu.2], by linarith only [hu.1]⟩, ?_⟩
      rw [← hz]
      module
    have h := S.flip.convexCover.support e.swap he' f.swap hf' ho (-z) hz'
    change height (-P e.2) (-P e.1) (-z.1) ≤ -z.2 at h
    rw [height_neg_reverse _ _ (S.drawing.right e he).ne] at h
    exact neg_le_neg_iff.mp h

lemma System.concaveOwner_mem (S : @System n R k a P) [NeZero n] [NeZero a]
    {e : Fin n × Fin n} (he : e ∈ S.edges) :
    S.concaveCover.owner e ∈ Finset.univ ×ˢ S.vertices := by
  have h := S.flip.convexOwner_mem ((S.flip_edge e).mpr he)
  rwa [S.flip_vertices] at h

theorem System.crossing_cap (S : @System n R k a P) [NeZero n] [NeZero a]
    (hP : Position P) (hx : Function.Injective (fun v => (P v).1))
    (hD : S.drawing.NoMultiple) :
    S.drawing.crossings.card ≤ 2 * a^2 * S.vertices.card^2 := by
  have h := S.convexCover.crossing_bound_finset S.concaveCover hP hx hD
    (Finset.univ ×ˢ S.vertices) (Finset.univ ×ˢ S.vertices)
    (fun _ he => S.convexOwner_mem he) (fun _ he => S.concaveOwner_mem he)
  simpa [Finset.card_product, pow_two, mul_assoc, mul_left_comm, mul_comm] using h

end PlanarHalving.Batches

namespace PlanarHalving.PlaneGraph
variable {n : ℕ} {P : Fin n → Point}

def sortEdge (e : Fin n × Fin n) : Fin n × Fin n :=
  if e.1 < e.2 then e else e.swap

lemma sortEdge_order (e : Fin n × Fin n) (he : e.1 ≠ e.2) :
    (sortEdge e).1 < (sortEdge e).2 := by
  unfold sortEdge
  split_ifs with h
  · exact h
  · exact lt_of_le_of_ne (le_of_not_gt h) he.symm

lemma sortEdge_cases (e : Fin n × Fin n) : sortEdge e = e ∨ sortEdge e = e.swap := by
  unfold sortEdge
  split_ifs <;> simp

lemma sortEdge_coincide {e f : Fin n × Fin n} (he : sortEdge e = sortEdge f) :
    e = f ∨ e = f.swap := by
  rcases sortEdge_cases e with hh | hh <;> rcases sortEdge_cases f with hg | hg <;> rw [hh,hg] at he
  · exact Or.inl he
  · exact Or.inr he
  · exact Or.inr (by simpa using congrArg Prod.swap he)
  · exact Or.inl (Prod.swap_injective he)

lemma Drawing.sortEdge_injective (D : Drawing P) :
    (↑D.edges : Set (Fin n × Fin n)).InjOn (@sortEdge n) := by
  intro e he f hf h
  rcases sortEdge_coincide h with h | h
  · exact h
  · have hx := D.right e he
    have hy := D.right f hf
    rw [h] at hx
    exact False.elim (lt_asymm hx hy)

lemma openSegment_sortEdge (e : Fin n × Fin n) :
    openSegment ℝ (P (sortEdge e).1) (P (sortEdge e).2) =
      openSegment ℝ (P e.1) (P e.2) := by
  rcases sortEdge_cases e with h | h
  · rw [h]
  · rw [h]
    exact openSegment_symm ℝ _ _

lemma segment_sortEdge (e : Fin n × Fin n) :
    segment ℝ (P (sortEdge e).1) (P (sortEdge e).2) =
      segment ℝ (P e.1) (P e.2) := by
  rcases sortEdge_cases e with h | h
  · rw [h]
  · rw [h]
    exact segment_symm ℝ _ _

lemma Drawing.noMultiple_of_generic (D : Drawing P) (hP : Generic P) : D.NoMultiple := by
  intro e he f hf hef g hg hge hgf z hze hzf hzg
  have ho (i : Fin n × Fin n) (hi : i ∈ D.edges) : (sortEdge i).1 < (sortEdge i).2 :=
    sortEdge_order i (fun h => (D.right i hi).ne (congrArg (fun v => (P v).1) h))
  have hne {i j : Fin n × Fin n} (hi : i ∈ D.edges) (hj : j ∈ D.edges) (hn : i ≠ j) :
      sortEdge i ≠ sortEdge j := fun h => hn (D.sortEdge_injective hi hj h)
  apply hP.2.2.2 _ _ _ _ _ _ (ho e he) (ho f hf) (ho g hg)
    (hne he hf hef) (hne hg he hge) (hne hg hf hgf) z
  · rwa [openSegment_sortEdge]
  · rwa [openSegment_sortEdge]
  · rwa [segment_sortEdge]

lemma Generic.position (hP : Generic P) : Position P := hP.1
lemma Generic.x_injective (hP : Generic P) : Function.Injective (fun v => (P v).1) := by
  intro i j hij
  by_contra hn
  exact hP.2.1 i j hn hij

end PlanarHalving.PlaneGraph

namespace PlanarHalving.PlaneGraph
variable {V : Type*} [Fintype V] {P : V → Point}

noncomputable def Drawing.restrictEdges (D : Drawing P) (E : Finset (V × V)) : Drawing P := by
  classical
  exact {
    vertices := D.vertices
    edges := D.edges ∩ E
    right := fun e he => D.right e (Finset.mem_inter.mp he).1
    ends := fun e he => D.ends e (Finset.mem_inter.mp he).1 }

lemma Drawing.restrict_crossings (D : Drawing P) (E : Finset (V × V)) :
    (D.restrictEdges E).crossings ⊆ D.crossings := by
  classical
  intro w hw
  simp only [Drawing.crossings, Drawing.restrictEdges, Finset.mem_filter,
    Finset.mem_product, Finset.mem_inter] at hw ⊢
  exact ⟨⟨hw.1.1.1,hw.1.2.1⟩,hw.2⟩

end PlanarHalving.PlaneGraph

namespace PlanarHalving.Batches
open PlaneGraph
variable {n R k a : ℕ} {P : Fin n → Point}

lemma System.vertices_le (S : @System n R k a P) : S.vertices.card ≤ n := by
  exact (Finset.card_le_univ _).trans_eq (Fintype.card_fin n)

theorem System.localized_crossing (S : @System n R k a P) [NeZero n] [NeZero a]
    (hP : Generic P) (F : Finset (Fin n)) (hF : F ⊆ S.vertices) :
    ((S.edges.filter fun e => e.1 ∈ F).card : ℝ)^3 ≤
      4608 * (a : ℝ)^2 * F.card * (S.vertices.card : ℝ)^3 +
        13824 * (S.vertices.card : ℝ)^3 := by
  classical
  let D := S.drawing.restrictEdges (S.edges.filter fun e => e.1 ∈ F)
  have hv : D.vertices = S.vertices := rfl
  have he : D.edges = S.edges.filter (fun e => e.1 ∈ F) := by
    ext e
    simp [D, Drawing.restrictEdges, System.drawing]
  have hc := D.designated_crossing hP.1 (PlaneGraph.Generic.x_injective hP) F hF (by
    intro e he'
    rw [he] at he'
    exact Or.inl (Finset.mem_filter.mp he').2)
  rw [he,hv] at hc
  have hcr : (D.crossings.card : ℝ) ≤ 2 * (a : ℝ)^2 * (S.vertices.card : ℝ)^2 := by
    exact_mod_cast (Finset.card_le_card (S.drawing.restrict_crossings _)).trans
      (S.crossing_cap hP.1 (PlaneGraph.Generic.x_injective hP) (S.drawing.noMultiple_of_generic hP))
  apply hc.trans
  calc 2304 * (F.card : ℝ) * S.vertices.card * D.crossings.card +
        13824 * (S.vertices.card : ℝ)^3 ≤
      2304 * (F.card : ℝ) * S.vertices.card * (2 * (a : ℝ)^2 * (S.vertices.card : ℝ)^2) +
        13824 * (S.vertices.card : ℝ)^3 := by gcongr
    _ = _ := by ring

theorem System.cubed_bound (S : @System n R k a P) [NeZero n] [NeZero a]
    (hP : Generic P) :
    (R : ℝ)^3 * (a : ℝ)^4 ≤ 18432 * (n : ℝ)^4 := by
  classical
  have hc := S.localized_crossing hP S.vertices (by rfl)
  have he : S.edges.filter (fun e => e.1 ∈ S.vertices) = S.edges := by
    exact Finset.filter_eq_self.mpr (fun e he => (S.edge_ends he).1)
  rw [he, S.card_edges] at hc
  push_cast at hc
  have hs : (S.vertices.card : ℝ) ≤ n := by exact_mod_cast S.vertices_le
  have ha : (1 : ℝ) ≤ a := by exact_mod_cast (NeZero.one_le : 1 ≤ a)
  have hn : (1 : ℝ) ≤ n := by exact_mod_cast (NeZero.one_le : 1 ≤ n)
  have hs₁ : 4608 * (a : ℝ)^2 * S.vertices.card * (S.vertices.card : ℝ)^3 ≤
      4608 * (a : ℝ)^2 * (n : ℝ)^4 := by
    calc _ ≤ 4608 * (a : ℝ)^2 * n * (n : ℝ)^3 := by gcongr
      _ = _ := by ring
  have hs₂ : 13824 * (S.vertices.card : ℝ)^3 ≤ 13824 * (a : ℝ)^2 * (n : ℝ)^4 := by
    calc _ ≤ 13824 * (n : ℝ)^3 := by gcongr
      _ = 13824 * (1 : ℝ)^2 * (1 * (n : ℝ)^3) := by ring
      _ ≤ 13824 * (a : ℝ)^2 * (n * (n : ℝ)^3) := by gcongr
      _ = _ := by ring
  have hh : (a : ℝ)^2 * ((R : ℝ)^3 * (a : ℝ)^4) ≤
      (a : ℝ)^2 * (18432 * (n : ℝ)^4) := by
    nlinarith only [hc, hs₁, hs₂]
  exact (mul_le_mul_iff_right₀ (by positivity : 0 < (a : ℝ)^2)).mp hh

end PlanarHalving.Batches
namespace PlanarHalving.PlaneGraph
lemma height_of_mem_segment {p q z : Point} (hx : p.1 ≠ q.1)
    (hz : z ∈ segment ℝ p q) : z.2 = height p q z.1 := by
  rw [segment_eq_image] at hz
  obtain ⟨t,_,rfl⟩ := hz
  simp only [Prod.fst_add, Prod.snd_add, Prod.smul_fst, Prod.smul_snd, smul_eq_mul]
  unfold height slope
  field_simp
  ring
end PlanarHalving.PlaneGraph

namespace PlanarHalving.RankCoordinates
open Set

noncomputable def envelope {ι : Type*} [Fintype ι] [Nonempty ι]
    (m c : ι → ℝ) (x : ℝ) : ℝ :=
  Finset.univ.sup' Finset.univ_nonempty (fun i => m i*x+c i)

lemma le_envelope {ι : Type*} [Fintype ι] [Nonempty ι]
    (m c : ι → ℝ) (i : ι) (x : ℝ) : m i*x+c i ≤ envelope m c x :=
  Finset.le_sup' (fun j => m j*x+c j) (Finset.mem_univ i)

lemma envelope_le {ι : Type*} [Fintype ι] [Nonempty ι]
    (m c : ι → ℝ) (x y : ℝ) (h : ∀ i, m i*x+c i ≤ y) : envelope m c x ≤ y :=
  Finset.sup'_le Finset.univ_nonempty _ (fun i _ => h i)

lemma envelope_attains {ι : Type*} [Fintype ι] [Nonempty ι]
    (m c : ι → ℝ) (x : ℝ) : ∃ i, envelope m c x = m i*x+c i := by
  obtain ⟨i,_,hi⟩ := Finset.exists_max_image Finset.univ (fun i => m i*x+c i) Finset.univ_nonempty
  exact ⟨i, le_antisymm (envelope_le m c x _ (fun j => hi j (Finset.mem_univ j))) (le_envelope m c i x)⟩

lemma continuous_envelope {ι : Type*} [Fintype ι] [Nonempty ι]
    (m c : ι → ℝ) : Continuous (envelope m c) := by
  have hh : Continuous (Finset.univ.sup' Finset.univ_nonempty (fun i => fun x : ℝ => m i*x+c i)) :=
    Continuous.finset_sup' Finset.univ_nonempty (fun _ _ => by fun_prop)
  convert hh using 1
  funext x
  simp only [envelope, Finset.sup'_apply]

lemma convexOn_envelope {ι : Type*} [Fintype ι] [Nonempty ι]
    (m c : ι → ℝ) : ConvexOn ℝ Set.univ (envelope m c) := by
  refine ⟨convex_univ, ?_⟩
  intro x _ y _ a b ha hb hab
  simp only [smul_eq_mul]
  apply envelope_le
  intro i
  have h₁ := mul_le_mul_of_nonneg_left (le_envelope m c i x) ha
  have h₂ := mul_le_mul_of_nonneg_left (le_envelope m c i y) hb
  calc
    m i * (a*x+b*y)+c i = a*(m i*x+c i)+b*(m i*y+c i) := by
      have hh := congrArg (fun t => t * c i) hab
      nlinarith only [hh]
    _ ≤ _ := add_le_add h₁ h₂

lemma envelope_slopes {ι : Type*} [Fintype ι] [Nonempty ι]
    (m c : ι → ℝ) {l u : ℝ} (hm : ∀ i, l ≤ m i ∧ m i ≤ u)
    {x y : ℝ} (hxy : x ≤ y) :
    l*(y-x) ≤ envelope m c y - envelope m c x ∧
    envelope m c y - envelope m c x ≤ u*(y-x) := by
  obtain ⟨i,hi⟩ := envelope_attains m c x
  obtain ⟨j,hj⟩ := envelope_attains m c y
  have h₁ := le_envelope m c i y
  have h₂ := le_envelope m c j x
  have h₃ := mul_le_mul_of_nonneg_right (hm i).1 (sub_nonneg.mpr hxy)
  have h₄ := mul_le_mul_of_nonneg_right (hm j).2 (sub_nonneg.mpr hxy)
  constructor
  · rw [hi]
    linarith only [h₁,h₃]
  · rw [hj]
    linarith only [h₂,h₄]

end PlanarHalving.RankCoordinates

namespace PlanarHalving.Batches
open PlaneGraph RankCoordinates
variable {R : ℕ}

lemma ConvexPath.lower_ray (C : ConvexPath R) {l : ℝ}
    (hl : ∀ b : Fin R, C.point b.castSucc ≠ C.point b.succ → l ≤ slope (C.point b.castSucc) (C.point b.succ))
    (c : Fin (R+1)) :
    (C.point 0).2 + ( (C.point c).1 - (C.point 0).1)*l ≤ (C.point c).2 := by
  have h := fin_between_le (f := fun r => Sweep.projection l (C.point r)) 0 c (Fin.zero_le c) (by
    intro b _ _
    rcases C.right b with he | he
    · rw [he]
    · have hn : C.point b.castSucc ≠ C.point b.succ := fun h => he.ne (congrArg Prod.fst h)
      have hp := projection_step (C.point b.castSucc) (C.point b.succ) (t := l) he.ne
      have hprod := mul_nonneg (sub_nonneg.mpr he.le) (sub_nonneg.mpr (hl b hn))
      linarith only [hp,hprod])
  unfold Sweep.projection at h
  linarith only [h]

lemma ConvexPath.upper_ray (C : ConvexPath R) {u : ℝ}
    (hu : ∀ b : Fin R, C.point b.castSucc ≠ C.point b.succ → slope (C.point b.castSucc) (C.point b.succ) ≤ u)
    (c : Fin (R+1)) :
    (C.point (Fin.last R)).2 + ((C.point c).1 - (C.point (Fin.last R)).1)*u ≤ (C.point c).2 := by
  have h := fin_between_le (f := fun r => -Sweep.projection u (C.point r)) c (Fin.last R) (Fin.le_last c) (by
    intro b _ _
    rcases C.right b with he | he
    · rw [he]
    · have hn : C.point b.castSucc ≠ C.point b.succ := fun h => he.ne (congrArg Prod.fst h)
      have hp := projection_step (C.point b.castSucc) (C.point b.succ) (t := u) he.ne
      have hprod := mul_nonpos_of_nonneg_of_nonpos (sub_nonneg.mpr he.le) (sub_nonpos.mpr (hu b hn))
      linarith only [hp,hprod])
  unfold Sweep.projection at h
  linarith only [h]

noncomputable def ConvexPath.extensionSlopes (C : ConvexPath R) (l u : ℝ) : Fin R ⊕ Bool → ℝ
  | .inl b => if C.point b.castSucc = C.point b.succ then l else slope (C.point b.castSucc) (C.point b.succ)
  | .inr false => l
  | .inr true => u

noncomputable def ConvexPath.extensionIntercepts (C : ConvexPath R) (l u : ℝ) : Fin R ⊕ Bool → ℝ
  | .inl b => if C.point b.castSucc = C.point b.succ then (C.point 0).2 - l*(C.point 0).1
      else (C.point b.castSucc).2 - slope (C.point b.castSucc) (C.point b.succ)*(C.point b.castSucc).1
  | .inr false => (C.point 0).2 - l*(C.point 0).1
  | .inr true => (C.point (Fin.last R)).2 - u*(C.point (Fin.last R)).1

noncomputable def ConvexPath.extension (C : ConvexPath R) (l u : ℝ) : ℝ → ℝ :=
  envelope (C.extensionSlopes l u) (C.extensionIntercepts l u)

lemma ConvexPath.extension_slopes (C : ConvexPath R) {l u : ℝ} (hlu : l ≤ u)
    (hsl : ∀ b : Fin R, C.point b.castSucc ≠ C.point b.succ →
      l ≤ slope (C.point b.castSucc) (C.point b.succ) ∧ slope (C.point b.castSucc) (C.point b.succ) ≤ u) :
    ∀ i, l ≤ C.extensionSlopes l u i ∧ C.extensionSlopes l u i ≤ u := by
  intro i
  cases i with
  | inl b =>
    by_cases hb : C.point b.castSucc = C.point b.succ
    · simp only [ConvexPath.extensionSlopes, ite_eq_left hb]
      exact ⟨le_rfl,hlu⟩
    · simpa only [ConvexPath.extensionSlopes, ite_eq_right hb] using hsl b hb
  | inr b => cases b <;> simp only [ConvexPath.extensionSlopes] <;> exact ⟨by order, by order⟩

lemma ConvexPath.extension_below_vertex (C : ConvexPath R) {l u : ℝ}
    (hsl : ∀ b : Fin R, C.point b.castSucc ≠ C.point b.succ →
      l ≤ slope (C.point b.castSucc) (C.point b.succ) ∧ slope (C.point b.castSucc) (C.point b.succ) ≤ u)
    (c : Fin (R+1)) : C.extension l u (C.point c).1 ≤ (C.point c).2 := by
  apply envelope_le
  intro i
  have hl := C.lower_ray (fun b hb => (hsl b hb).1) c
  have hu := C.upper_ray (fun b hb => (hsl b hb).2) c
  cases i with
  | inl b =>
    by_cases hb : C.point b.castSucc = C.point b.succ
    · simp only [ConvexPath.extensionSlopes, ConvexPath.extensionIntercepts, ite_eq_left hb]
      linarith only [hl]
    · simp only [ConvexPath.extensionSlopes, ConvexPath.extensionIntercepts, ite_eq_right hb]
      have hh := C.support_vertex b hb c
      unfold height at hh
      linarith only [hh]
  | inr b => cases b <;> simp only [ConvexPath.extensionSlopes, ConvexPath.extensionIntercepts] <;> linarith only [hl,hu]

lemma ConvexPath.extension_edge (C : ConvexPath R) {l u : ℝ}
    (hsl : ∀ b : Fin R, C.point b.castSucc ≠ C.point b.succ →
      l ≤ slope (C.point b.castSucc) (C.point b.succ) ∧ slope (C.point b.castSucc) (C.point b.succ) ≤ u)
    (b : Fin R) (hb : C.point b.castSucc ≠ C.point b.succ) {z : Point}
    (hz : z ∈ segment ℝ (C.point b.castSucc) (C.point b.succ)) :
    C.extension l u z.1 = z.2 := by
  apply le_antisymm
  · rw [segment_eq_image] at hz
    obtain ⟨t,ht,rfl⟩ := hz
    have hc := convexOn_envelope (C.extensionSlopes l u) (C.extensionIntercepts l u)
    have hh := hc.2 (Set.mem_univ (C.point b.castSucc).1) (Set.mem_univ (C.point b.succ).1)
      (sub_nonneg.mpr ht.2) ht.1 (by ring : (1-t)+t=1)
    have h₀ := mul_le_mul_of_nonneg_left (C.extension_below_vertex hsl b.castSucc) (sub_nonneg.mpr ht.2)
    have h₁ := mul_le_mul_of_nonneg_left (C.extension_below_vertex hsl b.succ) ht.1
    simp only [Prod.fst_add, Prod.snd_add, Prod.smul_fst, Prod.smul_snd, smul_eq_mul] at *
    exact hh.trans (add_le_add h₀ h₁)
  · have hh := le_envelope (C.extensionSlopes l u) (C.extensionIntercepts l u) (.inl b) z.1
    simp only [ConvexPath.extensionSlopes, ConvexPath.extensionIntercepts, ite_eq_right hb] at hh
    have hz' := height_of_mem_segment (C.right b |>.resolve_left hb).ne hz
    unfold height at hz'
    change z.2 ≤ envelope (C.extensionSlopes l u) (C.extensionIntercepts l u) z.1
    linarith only [hh,hz']

end PlanarHalving.Batches

end OAI