Add lean source and binary files (part 43)

lean/OAI/Combinatorics/Crossing/StraightChainIntersections.lean

@@ -0,0 +1,49 @@
+import OAI.Combinatorics.Crossing.DrawnEdgeChains
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.PolygonalChain
+open scoped BigOperators
+variable {O T : Set Plane} {a b c d : Plane}
+
+theorem intersection_single_right (P : PolygonalChain O a b) (hc : c ∈ T) (hcd : segment ℝ c d ⊆ T) :
+    polygonIntersection P.vertices (single T c d hc hcd).vertices P.pieces 1=
+      ∑ i ∈ Finset.range P.pieces, segmentCrossingSign (P.vertices i) (P.vertices (i+1)) c d := by
+  simp [polygonIntersection,single]
+
+theorem intersection_single_left (P : PolygonalChain O a b) (hc : c ∈ T) (hcd : segment ℝ c d ⊆ T) :
+    polygonIntersection (single T c d hc hcd).vertices P.vertices 1 P.pieces=
+      ∑ i ∈ Finset.range P.pieces, segmentCrossingSign c d (P.vertices i) (P.vertices (i+1)) := by
+  simp [polygonIntersection,single]
+
+theorem transverse_single_right (P : PolygonalChain O a b) (hc : c ∈ T) (hcd : segment ℝ c d ⊆ T)
+    (h : ∀ i : Fin P.pieces, SegmentPairTransverse (P.vertices i.val) (P.vertices (i.val+1)) c d) :
+    P.Transverse (single T c d hc hcd) := by
+  intro i j
+  have hj : j.val=0 := by have hj : j.val<1 := j.isLt; omega
+  simpa [single,hj] using h i
+
+theorem transverse_single_left (P : PolygonalChain O a b) (hc : c ∈ T) (hcd : segment ℝ c d ⊆ T)
+    (h : ∀ i : Fin P.pieces, SegmentPairTransverse c d (P.vertices i.val) (P.vertices (i.val+1))) :
+    (single T c d hc hcd).Transverse P :=
+  P.transverse_swap _ (P.transverse_single_right hc hcd (fun i => segmentPairTransverse_swap _ _ _ _ (h i)))
+
+theorem intersection_single_right_zero (P : PolygonalChain O a b) (hc : c ∈ T) (hcd : segment ℝ c d ⊆ T)
+    (h : ∀ i : Fin P.pieces, ¬ ClosedSegmentsMeet (P.vertices i.val) (P.vertices (i.val+1)) c d) :
+    polygonIntersection P.vertices (single T c d hc hcd).vertices P.pieces 1=0 := by
+  rw [P.intersection_single_right]
+  apply Finset.sum_eq_zero
+  intro i hi
+  exact segmentCrossingSign_eq_zero_of_not_meet _ _ _ _ (h ⟨i,Finset.mem_range.mp hi⟩)
+
+theorem intersection_single_single (ha : a ∈ O) (hab : segment ℝ a b ⊆ O)
+    (hc : c ∈ T) (hcd : segment ℝ c d ⊆ T) :
+    polygonIntersection (single O a b ha hab).vertices (single T c d hc hcd).vertices 1 1=
+      segmentCrossingSign a b c d := by simp [polygonIntersection,single]
+
+end Zarankiewicz.PolygonalChain
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/StraightChainTransversality.lean

@@ -0,0 +1,30 @@
+import OAI.Combinatorics.Crossing.StraightChainIntersections
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.PolygonalChain
+open scoped BigOperators
+variable {O T : Set Plane} {a b c d : Plane}
+
+theorem transverse_single_single (ha : a ∈ O) (hab : segment ℝ a b ⊆ O)
+    (hc : c ∈ T) (hcd : segment ℝ c d ⊆ T) (h : SegmentPairTransverse a b c d) :
+    (single O a b ha hab).Transverse (single T c d hc hcd) := by
+  intro i j
+  have hi : i.val=0 := by have hh : i.val<1 := i.isLt; omega
+  have hj : j.val=0 := by have hh : j.val<1 := j.isLt; omega
+  simpa [single,hi,hj] using h
+
+theorem intersection_single_left_zero (P : PolygonalChain O a b) (hc : c ∈ T) (hcd : segment ℝ c d ⊆ T)
+    (h : ∀ i : Fin P.pieces, ¬ ClosedSegmentsMeet c d (P.vertices i.val) (P.vertices (i.val+1))) :
+    polygonIntersection (single T c d hc hcd).vertices P.vertices 1 P.pieces=0 := by
+  rw [P.intersection_single_left]
+  apply Finset.sum_eq_zero
+  intro i hi
+  exact segmentCrossingSign_eq_zero_of_not_meet _ _ _ _ (h ⟨i,Finset.mem_range.mp hi⟩)
+
+end Zarankiewicz.PolygonalChain
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/SubdivisionPointEndpoints.lean

@@ -0,0 +1,34 @@
+import OAI.Combinatorics.Crossing.DrawingSubdivisionGraph
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+variable {m n : ℕ} {D : AdmissibleDrawing m n}
+
+theorem subdivision_point_endpoint (P : ∀ e, PolygonalParametrization (D.edge e))
+    (x : Plane) (hpoint : ∀ e t, D.edge e t=x → t ∈ Set.range (P e).knot)
+    (e : BipartiteEdge m n) (i : Fin (P e).pieces) (hx : x ∈ (P e).pieceTrace i) :
+    x=D.edge e ((P e).knot i.castSucc) ∨ x=D.edge e ((P e).knot i.succ) := by
+  obtain ⟨t,ht⟩ := (P e).pieceTrace_subset_range i hx
+  obtain ⟨j,hj⟩ := hpoint e t ht
+  have he : D.edge e ((P e).knot j)=x := (congrArg (D.edge e) hj).trans ht
+  have hh := (P e).pieceTrace_knot_endpoint (D.edge_injective e) i j (he.symm ▸ hx)
+  simpa only [he] using hh
+
+theorem drawingSubdivisionGraph_point_endpoint (P : ∀ e, PolygonalParametrization (D.edge e))
+    (x : Plane) (hpoint : ∀ e t, D.edge e t=x → t ∈ Set.range (P e).knot)
+    (a b : Plane) (hab : (drawingSubdivisionGraph P).Adj a b) (hx : x ∈ segment ℝ a b) :
+    x=a ∨ x=b := by
+  obtain ⟨hab,p,hp⟩ := hab
+  rcases hp with ⟨rfl,rfl⟩ | ⟨rfl,rfl⟩
+  · exact subdivision_point_endpoint P x hpoint p.1 p.2 hx
+  · have hx' : x ∈ segment ℝ (drawingPieceStart P p) (drawingPieceEnd P p) := by
+      simpa only [segment_symm] using hx
+    exact (subdivision_point_endpoint P x hpoint p.1 p.2 hx').symm
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/SubdivisionSegments.lean

@@ -0,0 +1,91 @@
+import OAI.Combinatorics.Crossing.AffineSubdivisionRefinement
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.PolygonalParametrization
+variable {a b : Plane} {γ : Path a b}
+
+def pieceTrace (P : PolygonalParametrization γ) (i : Fin P.pieces) : Set Plane :=
+  segment ℝ (γ (P.knot i.castSucc)) (γ (P.knot i.succ))
+
+theorem pieceTrace_parameter (P : PolygonalParametrization γ) (i : Fin P.pieces)
+    (x : Plane) (hx : x ∈ P.pieceTrace i) :
+    ∃ t : unitInterval, γ (intervalSegment (P.knot i.castSucc) (P.knot i.succ) t)=x := by
+  rw [pieceTrace,← Path.range_segment] at hx
+  obtain ⟨t,ht⟩ := hx
+  refine ⟨t,(P.affine i t).trans ?_⟩
+  simpa only [Path.segment_apply,AffineMap.lineMap_apply_module,segmentPoint] using ht
+
+theorem pieceTrace_subset_range (P : PolygonalParametrization γ) (i : Fin P.pieces) :
+    P.pieceTrace i ⊆ Set.range γ := by
+  intro x hx
+  obtain ⟨t,ht⟩ := P.pieceTrace_parameter i x hx
+  exact ⟨intervalSegment (P.knot i.castSucc) (P.knot i.succ) t,ht⟩
+
+theorem pieceTrace_knot_endpoint (P : PolygonalParametrization γ) (hγ : Function.Injective γ)
+    (i : Fin P.pieces) (j : Fin (P.pieces+1))
+    (hx : γ (P.knot j) ∈ P.pieceTrace i) :
+    γ (P.knot j)=γ (P.knot i.castSucc) ∨ γ (P.knot j)=γ (P.knot i.succ) := by
+  obtain ⟨t,ht⟩ := P.pieceTrace_parameter i _ hx
+  by_cases ht0 : t=0
+  · subst t
+    simpa [intervalSegment] using Or.inl ht.symm
+  by_cases ht1 : t=1
+  · subst t
+    simpa [intervalSegment] using Or.inr ht.symm
+  have hmid := intervalSegment_strict_between (P.knot i.castSucc) (P.knot i.succ) t
+    (P.increasing (by change i.val < i.val+1; omega))
+    ⟨lt_of_le_of_ne (show 0 ≤ t from t.property.1) (Ne.symm ht0),
+      lt_of_le_of_ne (show t ≤ 1 from t.property.2) ht1⟩
+  have he := hγ ht
+  rw [he] at hmid
+  exact False.elim (strictMono_no_between_successors P.knot P.increasing i j hmid)
+
+theorem pieceTrace_other_piece_endpoint (P : PolygonalParametrization γ) (hγ : Function.Injective γ)
+    (i j : Fin P.pieces) (hij : i ≠ j) (x : Plane)
+    (hx : x ∈ P.pieceTrace i) (hy : x ∈ P.pieceTrace j) :
+    x=γ (P.knot i.castSucc) ∨ x=γ (P.knot i.succ) := by
+  obtain ⟨s,hs⟩ := P.pieceTrace_parameter i x hx
+  obtain ⟨t,ht⟩ := P.pieceTrace_parameter j x hy
+  by_cases hs0 : s=0
+  · subst s
+    exact Or.inl (by simpa [intervalSegment] using hs.symm)
+  by_cases hs1 : s=1
+  · subst s
+    exact Or.inr (by simpa [intervalSegment] using hs.symm)
+  have hsbetween := intervalSegment_strict_between (P.knot i.castSucc) (P.knot i.succ) s
+    (P.increasing (by change i.val < i.val+1; omega))
+    ⟨lt_of_le_of_ne (show 0 ≤ s from s.property.1) (Ne.symm hs0),
+      lt_of_le_of_ne (show s ≤ 1 from s.property.2) hs1⟩
+  have htbetween := intervalSegment_between (P.knot j.castSucc) (P.knot j.succ) t
+    (P.increasing.monotone (by change j.val ≤ j.val+1; omega))
+  have he := hγ (hs.trans ht.symm)
+  rw [he] at hsbetween
+  rcases lt_or_gt_of_ne hij with hij | hji
+  · have hgap := P.increasing.monotone (show i.succ ≤ j.castSucc by change i.val+1 ≤ j.val; exact hij)
+    exact False.elim (hsbetween.2.not_ge (hgap.trans htbetween.1))
+  · have hgap := P.increasing.monotone (show j.succ ≤ i.castSucc by change j.val+1 ≤ i.val; exact hji)
+    exact False.elim (hsbetween.1.not_ge (htbetween.2.trans hgap))
+
+end Zarankiewicz.PolygonalParametrization
+namespace Zarankiewicz
+variable {m n : ℕ}
+
+theorem subdivision_mark_endpoint (D : AdmissibleDrawing m n)
+    (P : ∀ e, PolygonalParametrization (D.edge e))
+    (hmark : ∀ e t, D.edge e t ∈ drawingMarks D.toFiniteIntersectionDrawing → t ∈ Set.range (P e).knot)
+    (e : BipartiteEdge m n) (i : Fin (P e).pieces) (x : Plane)
+    (hx : x ∈ (P e).pieceTrace i) (hm : x ∈ drawingMarks D.toFiniteIntersectionDrawing) :
+    x=D.edge e ((P e).knot i.castSucc) ∨ x=D.edge e ((P e).knot i.succ) := by
+  obtain ⟨t,ht⟩ := (P e).pieceTrace_subset_range i hx
+  obtain ⟨j,hj⟩ := hmark e t (ht.symm ▸ hm)
+  have he : D.edge e ((P e).knot j)=x := (congrArg (D.edge e) hj).trans ht
+  have hh := (P e).pieceTrace_knot_endpoint (D.edge_injective e) i j (he.symm ▸ hx)
+  simpa only [he] using hh
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/SublevelExtrema.lean

@@ -0,0 +1,67 @@
+import OAI.Combinatorics.Crossing.FirstLastVisits
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+
+theorem sublevel_passage_extrema (f : ℝ → ℝ) (hf : Continuous f) (r τ : ℝ)
+    (hτ : τ ∈ Set.Icc (0 : ℝ) 1) (hvisit : f τ < r) :
+    ∃ a b : ℝ, a ∈ Set.Icc (0 : ℝ) 1 ∧ b ∈ Set.Icc (0 : ℝ) 1 ∧
+      a ≤ τ ∧ τ ≤ b ∧ f a ≤ r ∧ f b ≤ r ∧
+      (∀ t ∈ Set.Icc (0 : ℝ) 1, f t ≤ r → a ≤ t ∧ t ≤ b) ∧
+      (0 < a → f a=r) ∧ (b < 1 → f b=r) ∧
+      (0 < τ → a < τ) ∧ (τ < 1 → τ < b) := by
+  let S : Set ℝ := Set.Icc 0 1 ∩ {t | f t ≤ r}
+  have hS : IsCompact S := isCompact_Icc.inter_right (isClosed_le hf continuous_const)
+  have hτS : τ ∈ S := ⟨hτ,hvisit.le⟩
+  obtain ⟨a,ha⟩ := hS.exists_isLeast ⟨τ,hτS⟩
+  obtain ⟨b,hb⟩ := hS.exists_isGreatest ⟨τ,hτS⟩
+  have hfa (ha0 : 0 < a) : f a=r := by
+    have hf0 : r < f 0 := by
+      apply lt_of_not_ge
+      intro h
+      have hh := ha.2 (show (0 : ℝ) ∈ S from ⟨⟨le_rfl,zero_le_one⟩,h⟩)
+      linarith
+    apply le_antisymm ha.1.2
+    by_contra hn
+    have hlt : f a < r := lt_of_not_ge hn
+    obtain ⟨t,ht,he⟩ := intermediate_value_Icc' ha.1.1.1 hf.continuousOn ⟨hlt.le,hf0.le⟩
+    have hmem : t ∈ S := ⟨⟨ht.1,ht.2.trans ha.1.1.2⟩,he.le⟩
+    have hta : t=a := le_antisymm ht.2 (ha.2 hmem)
+    rw [hta] at he
+    exact hlt.ne he
+  have hfb (hb1 : b < 1) : f b=r := by
+    have hf1 : r < f 1 := by
+      apply lt_of_not_ge
+      intro h
+      have hh := hb.2 (show (1 : ℝ) ∈ S from ⟨⟨zero_le_one,le_rfl⟩,h⟩)
+      linarith
+    apply le_antisymm hb.1.2
+    by_contra hn
+    have hlt : f b < r := lt_of_not_ge hn
+    obtain ⟨t,ht,he⟩ := intermediate_value_Icc hb.1.1.2 hf.continuousOn ⟨hlt.le,hf1.le⟩
+    have hmem : t ∈ S := ⟨⟨hb.1.1.1.trans ht.1,ht.2⟩,he.le⟩
+    have htb : t=b := le_antisymm (hb.2 hmem) ht.1
+    rw [htb] at he
+    exact hlt.ne he
+  refine ⟨a,b,ha.1.1,hb.1.1,ha.2 hτS,hb.2 hτS,ha.1.2,hb.1.2,
+    fun t ht hh => ⟨ha.2 ⟨ht,hh⟩,hb.2 ⟨ht,hh⟩⟩,hfa,hfb,?_,?_⟩
+  · intro ht0
+    apply lt_of_le_of_ne (ha.2 hτS)
+    intro he
+    have h := hfa (he.symm ▸ ht0)
+    rw [he] at h
+    exact hvisit.ne h
+  · intro ht1
+    apply lt_of_le_of_ne (hb.2 hτS)
+    intro he
+    have h := hfb (he ▸ ht1)
+    rw [← he] at h
+    exact hvisit.ne h
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/SubspaceIntersection.lean

@@ -0,0 +1,60 @@
+import OAI.Combinatorics.Crossing.StageDegreeBound
+import OAI.Combinatorics.Crossing.DegreeCounting
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+open Module Submodule
+open scoped BigOperators
+variable {W : Type*} [AddCommGroup W] [Module ℝ W] [FiniteDimensional ℝ W]
+
+theorem subspace_intersection_bound (m : ℕ) (U V : Fin m → Submodule ℝ W)
+    (hUV : ∀ i, Disjoint (U i) (V i)) :
+    (∑ i, ∑ j, finrank ℝ ↥(U i ⊓ V j)) ≤ (m*m/4) * finrank ℝ W := by
+  let node : Fin m → ℝ := fun i => (i.val : ℝ)
+  have hn : Function.Injective node := by
+    intro i j hij
+    apply Fin.ext
+    dsimp only [node] at hij
+    exact_mod_cast hij
+  have ht : ∀ i, node i ≠ (-1 : ℝ) := by
+    intro i
+    have hnonneg : (0 : ℝ) ≤ node i := Nat.cast_nonneg i.val
+    linarith
+  let ell := columnIncrement U node ⊤ (-1)
+  have hsum : (∑ i, ∑ j, finrank ℝ ↥(U i ⊓ V j)) =
+      ∑ h ∈ Finset.range m, ∑ j, rankIncrement U node (V j) h := by
+    rw [Finset.sum_comm]
+    calc
+      (∑ j, ∑ i, finrank ℝ ↥(U i ⊓ V j)) =
+          ∑ j, ∑ h ∈ Finset.range m, rankIncrement U node (V j) h := by
+        apply Finset.sum_congr rfl
+        intro j hj
+        simpa only [Fintype.card_fin] using (interpolation_identity U node (V j) hn).symm
+      _ = _ := Finset.sum_comm
+  have hell : (∑ e ∈ Finset.range m, ell e) ≤ finrank ℝ W := by
+    change (∑ e ∈ Finset.range m, columnIncrement U node ⊤ (-1) e) ≤ _
+    rw [sum_columnIncrement]
+    have he := Submodule.finrank_le (evaluationFiltration U node ⊤ (-1) m)
+    simpa using he
+  rw [hsum]
+  calc
+    (∑ h ∈ Finset.range m, ∑ j, rankIncrement U node (V j) h) ≤
+        ∑ h ∈ Finset.range m, ∑ e ∈ Finset.range (h+1), e * ell e := by
+      apply Finset.sum_le_sum
+      intro h hh
+      exact stage_degree_bound U V node hn hUV (-1) ht h
+    _ ≤ (m*m/4) * finrank ℝ W := total_degree_cost_le ell m (finrank ℝ W) hell
+
+theorem lemma2_1 (m N : ℕ) (U V : Fin m → Submodule ℝ W)
+    (hN : finrank ℝ W = N) (hUV : ∀ i, U i ⊓ V i = ⊥) :
+    (∑ i, ∑ j, finrank ℝ ↥(U i ⊓ V j)) ≤ (m*m/4) * N := by
+  rw [← hN]
+  exact subspace_intersection_bound m U V (fun i => disjoint_iff.mpr (hUV i))
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/SubspaceProjection.lean

@@ -0,0 +1,50 @@
+import Mathlib.LinearAlgebra.FiniteDimensional.Lemmas
+import Mathlib.LinearAlgebra.Quotient.Basic
+import Mathlib.Basic.Real.Basic
+import Lean.Elab.Tactic.Omega
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+open Module Submodule
+variable {W W' : Type*} [AddCommGroup W] [Module ℝ W] [FiniteDimensional ℝ W]
+variable [AddCommGroup W'] [Module ℝ W']
+
+theorem finrank_map_add_le (f : W →ₗ[ℝ] W') (E T : Submodule ℝ W)
+    (hTE : T ≤ E) (hTk : T ≤ LinearMap.ker f) :
+    finrank ℝ (E.map f) + finrank ℝ T ≤ finrank ℝ E := by
+  let g := f.comp E.subtype
+  have hk : T.comap E.subtype ≤ LinearMap.ker g := fun x hx => hTk hx
+  have hd := Submodule.finrank_mono hk
+  rw [(Submodule.comapSubtypeEquivOfLe hTE).finrank_eq] at hd
+  have hr := g.finrank_range_add_finrank_ker
+  have he : LinearMap.range g = E.map f := by
+    dsimp only [g]
+    rw [LinearMap.range_comp, Submodule.range_subtype]
+  rw [he] at hr
+  omega
+
+theorem finrank_map_of_disjoint
+    {W W' : Type*} [AddCommGroup W] [Module ℝ W] [FiniteDimensional ℝ W]
+    [AddCommGroup W'] [Module ℝ W']
+    (f : W →ₗ[ℝ] W') (E : Submodule ℝ W)
+    (hE : Disjoint E (LinearMap.ker f)) : finrank ℝ (E.map f) = finrank ℝ E := by
+  let g := f.comp E.subtype
+  have hg : Function.Injective g := by
+    apply LinearMap.ker_eq_bot.mp
+    apply le_antisymm _ bot_le
+    intro x hx
+    have hm : x.val ∈ E ⊓ LinearMap.ker f := ⟨x.property, hx⟩
+    rw [hE.eq_bot] at hm
+    exact (Submodule.mem_bot ℝ).mpr (Subtype.ext ((Submodule.mem_bot ℝ).mp hm))
+  have hr := LinearMap.finrank_range_of_inj hg
+  change finrank ℝ (LinearMap.range (f.comp E.subtype)) = finrank ℝ E at hr
+  rw [LinearMap.range_comp, Submodule.range_subtype] at hr
+  exact hr
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/SurgeryCrossingContainment.lean

@@ -0,0 +1,63 @@
+import OAI.Combinatorics.Crossing.SurgeryRouteIntersections
+import OAI.Combinatorics.Crossing.ReplaceDrawingRangeCases
+import OAI.Combinatorics.Crossing.DrawingRangeCrossings
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.PolygonalExterior
+variable {m n : ℕ} {D : AdmissibleDrawing m n} {C : DrawingPassages D.toFiniteIntersectionDrawing}
+  (E : PolygonalExterior C) (v : BipartiteVertex m n → Plane) (hvinj : Function.Injective v)
+  (hv : ∀ j, squaredLength (v j-D.vertex j) < C.radius^2)
+  (hdet : ∀ j (p q : C.PortsAt (C.vertexMark j)), p ≠ q →
+    det2 (C.portPoint p.val-v j) (C.portPoint q.val-v j) ≠ 0)
+  (P : ∀ e, PolygonalParametrization ((E.assembledAdmissible v hvinj hv hdet).edge e))
+  {p q : C.InnerIndex}
+
+theorem adjacentSurgeryDrawing_crossings_subset
+    (Kp : ExteriorCrossingCut C P p) (Kq : ExteriorCrossingCut C P q)
+    (hpq : p ≠ q) (hm : C.innerMark p=C.innerMark q) (hadj : p.1.1=q.1.1 ∨ p.1.2=q.1.2)
+    (hcross : SegmentsCrossProperly (C.portPoint (C.incomingPort p)) (C.portPoint (C.outgoingPort p))
+      (C.portPoint (C.incomingPort q)) (C.portPoint (C.outgoingPort q)))
+    (hemb : StraightEdgeEmbedding (crossingSurgeryGraph C P p q) id) :
+    crossingPoints (adjacentSurgeryDrawing Kp Kq hm hadj hv hemb) ⊆
+      crossingPoints (E.assembledAdmissible v hvinj hv hdet).toContinuousDrawing := by
+  let B := (E.assembledAdmissible v hvinj hv hdet).toContinuousDrawing
+  let A := adjacentSurgeryDrawing Kp Kq hm hadj hv hemb
+  intro x hx
+  obtain ⟨e,f,hef,hxe,hxf⟩ := hx
+  have havoid : ∀ j, x ≠ B.vertex j := edgeInterior_not_vertex A e x hxe
+  have hpair (hx : x ∈ Set.range (adjacentSurgeryRouteP Kp Kq hm hadj))
+      (hy : x ∈ Set.range (adjacentSurgeryRouteQ Kp Kq hm hadj)) : x ∈ crossingPoints B := by
+    have hh := E.adjacentSurgeryRoutes_meeting_each_other v hvinj hv hdet P Kp Kq hpq hm hadj hcross x hx hy
+    exact crossing_of_ranges_not_vertices B p.1 q.1
+      (fun he => hpq (C.innerIndex_eq_of_edge_mark p q he hm)) x hh.1 hh.2 havoid
+  have hmixed (g : BipartiteEdge m n) (hgp : g ≠ p.1) (hgq : g ≠ q.1)
+      (hx : x ∈ Set.range (adjacentSurgeryRouteP Kp Kq hm hadj) ∨
+        x ∈ Set.range (adjacentSurgeryRouteQ Kp Kq hm hadj))
+      (hy : x ∈ Set.range (B.edge g)) : x ∈ crossingPoints B := by
+    rcases E.adjacentSurgeryRoutes_meeting_other v hvinj hv hdet P Kp Kq hpq hm hadj g hgp hgq x hx hy with h | h
+    · exact crossing_of_ranges_not_vertices B p.1 g (Ne.symm hgp) x h hy havoid
+    · exact crossing_of_ranges_not_vertices B q.1 g (Ne.symm hgq) x h hy havoid
+  have hcases (g : BipartiteEdge m n) (hg : x ∈ Set.range (A.edge g)) :=
+    B.replaceTwoRoutes_range_cases p.1 q.1 (adjacentSurgeryRouteP Kp Kq hm hadj)
+      (adjacentSurgeryRouteQ Kp Kq hm hadj) g x hg
+  rcases hcases e (edgeInterior_subset_range A e hxe) with ⟨hep,hx⟩ | ⟨heq,hx⟩ | ⟨hep,heq,hx⟩
+  · rcases hcases f (edgeInterior_subset_range A f hxf) with ⟨hfp,hy⟩ | ⟨hfq,hy⟩ | ⟨hfp,hfq,hy⟩
+    · exact False.elim (hef (hep.trans hfp.symm))
+    · exact hpair hx hy
+    · exact hmixed f hfp hfq (Or.inl hx) hy
+  · rcases hcases f (edgeInterior_subset_range A f hxf) with ⟨hfp,hy⟩ | ⟨hfq,hy⟩ | ⟨hfp,hfq,hy⟩
+    · exact hpair hy hx
+    · exact False.elim (hef (heq.trans hfq.symm))
+    · exact hmixed f hfp hfq (Or.inr hx) hy
+  · rcases hcases f (edgeInterior_subset_range A f hxf) with ⟨hfp,hy⟩ | ⟨hfq,hy⟩ | ⟨hfp,hfq,hy⟩
+    · exact hmixed e hep heq (Or.inl hy) hx
+    · exact hmixed e hep heq (Or.inr hy) hx
+    · exact crossing_of_ranges_not_vertices B e f hef x hx hy havoid
+
+end Zarankiewicz.PolygonalExterior
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/SurgeryCutWalks.lean

@@ -0,0 +1,47 @@
+import OAI.Combinatorics.Crossing.CrossingSurgeryGraph
+import OAI.Combinatorics.Crossing.CrossingCutWalks
+import OAI.Combinatorics.Crossing.GraphWalkRealizationLaws
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+variable {m n : ℕ} {D D' : AdmissibleDrawing m n}
+
+def surgeryPrefixWalk (C : DrawingPassages D.toFiniteIntersectionDrawing)
+    (P : ∀ e, PolygonalParametrization (D'.edge e)) (p q r : C.InnerIndex)
+    (i : ℕ) (hi : (drawingEdgeWalk P r.1).getVert i=C.portPoint (C.incomingPort r))
+    (hout : Disjoint (Set.range (graphWalkPath id ((drawingEdgeWalk P r.1).take i))) (C.crossingDisk p)) :
+    (crossingSurgeryGraph C P p q).Walk (D'.vertex (.inl r.1.1)) (C.portPoint (C.incomingPort r)) :=
+  ((exteriorGraphWalk ((drawingEdgeWalk P r.1).take i) (C.crossingDisk p) hout).mapLe
+    (exterior_le_crossingSurgeryGraph C P p q)).copy rfl hi
+
+def surgerySuffixWalk (C : DrawingPassages D.toFiniteIntersectionDrawing)
+    (P : ∀ e, PolygonalParametrization (D'.edge e)) (p q r : C.InnerIndex)
+    (j : ℕ) (hj : (drawingEdgeWalk P r.1).getVert j=C.portPoint (C.outgoingPort r))
+    (hout : Disjoint (Set.range (graphWalkPath id ((drawingEdgeWalk P r.1).drop j))) (C.crossingDisk p)) :
+    (crossingSurgeryGraph C P p q).Walk (C.portPoint (C.outgoingPort r)) (D'.vertex (.inr r.1.2)) :=
+  ((exteriorGraphWalk ((drawingEdgeWalk P r.1).drop j) (C.crossingDisk p) hout).mapLe
+    (exterior_le_crossingSurgeryGraph C P p q)).copy hj rfl
+
+theorem surgeryPrefixWalk_trace (C : DrawingPassages D.toFiniteIntersectionDrawing)
+    (P : ∀ e, PolygonalParametrization (D'.edge e)) (p q r : C.InnerIndex)
+    (i : ℕ) (hi : (drawingEdgeWalk P r.1).getVert i=C.portPoint (C.incomingPort r))
+    (hout : Disjoint (Set.range (graphWalkPath id ((drawingEdgeWalk P r.1).take i))) (C.crossingDisk p)) :
+    Set.range (graphWalkPath id (surgeryPrefixWalk C P p q r i hi hout))=
+      Set.range (graphWalkPath id ((drawingEdgeWalk P r.1).take i)) := by
+  rw [surgeryPrefixWalk,graphWalkPath_copy_range,graphWalkPath_mapLe_range,exteriorGraphWalk_trace]
+
+theorem surgerySuffixWalk_trace (C : DrawingPassages D.toFiniteIntersectionDrawing)
+    (P : ∀ e, PolygonalParametrization (D'.edge e)) (p q r : C.InnerIndex)
+    (j : ℕ) (hj : (drawingEdgeWalk P r.1).getVert j=C.portPoint (C.outgoingPort r))
+    (hout : Disjoint (Set.range (graphWalkPath id ((drawingEdgeWalk P r.1).drop j))) (C.crossingDisk p)) :
+    Set.range (graphWalkPath id (surgerySuffixWalk C P p q r j hj hout))=
+      Set.range (graphWalkPath id ((drawingEdgeWalk P r.1).drop j)) := by
+  rw [surgerySuffixWalk,graphWalkPath_copy_range,graphWalkPath_mapLe_range,exteriorGraphWalk_trace]
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/SurgeryFiniteDrawing.lean

@@ -0,0 +1,42 @@
+import OAI.Combinatorics.Crossing.SurgeryNoTriples
+import OAI.Combinatorics.Crossing.SurgeryStrictPointCount
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.PolygonalExterior
+variable {m n : ℕ} {D : AdmissibleDrawing m n} {C : DrawingPassages D.toFiniteIntersectionDrawing}
+  (E : PolygonalExterior C) (v : BipartiteVertex m n → Plane) (hvinj : Function.Injective v)
+  (hv : ∀ j, squaredLength (v j-D.vertex j) < C.radius^2)
+  (hdet : ∀ j (p q : C.PortsAt (C.vertexMark j)), p ≠ q →
+    det2 (C.portPoint p.val-v j) (C.portPoint q.val-v j) ≠ 0)
+  (P : ∀ e, PolygonalParametrization ((E.assembledAdmissible v hvinj hv hdet).edge e))
+  {p q : C.InnerIndex}
+
+def adjacentSurgeryFiniteDrawing
+    (Kp : ExteriorCrossingCut C P p) (Kq : ExteriorCrossingCut C P q)
+    (hpq : p ≠ q) (hm : C.innerMark p=C.innerMark q) (hadj : p.1.1=q.1.1 ∨ p.1.2=q.1.2)
+    (hemb : StraightEdgeEmbedding (crossingSurgeryGraph C P p q) id)
+    (x : Plane) (hxp : x ∈ Set.range (C.crossingChord p)) (hxq : x ∈ Set.range (C.crossingChord q)) :
+    FiniteIntersectionDrawing m n where
+  toContinuousDrawing := adjacentSurgeryDrawing Kp Kq hm hadj hv hemb
+  crossings_finite := (E.adjacentSurgeryDrawing_strict_crossing_ncard v hvinj hv hdet P Kp Kq hpq hm hadj hemb x hxp hxq).1
+  no_triples := E.adjacentSurgeryDrawing_no_triples v hvinj hv hdet P Kp Kq hpq hm hadj
+    (C.crossingChord_meeting_segmentsCrossProperly p q hpq x hxp hxq) hemb
+
+theorem adjacentSurgeryFiniteDrawing_count_lt
+    (Kp : ExteriorCrossingCut C P p) (Kq : ExteriorCrossingCut C P q)
+    (hpq : p ≠ q) (hm : C.innerMark p=C.innerMark q) (hadj : p.1.1=q.1.1 ∨ p.1.2=q.1.2)
+    (hemb : StraightEdgeEmbedding (crossingSurgeryGraph C P p q) id)
+    (x : Plane) (hxp : x ∈ Set.range (C.crossingChord p)) (hxq : x ∈ Set.range (C.crossingChord q)) :
+    finiteCrossingCount (E.adjacentSurgeryFiniteDrawing v hvinj hv hdet P Kp Kq hpq hm hadj hemb x hxp hxq) <
+      crossingCount (E.assembledAdmissible v hvinj hv hdet) := by
+  rw [finiteCrossingCount_eq_ncard]
+  have h := (E.adjacentSurgeryDrawing_strict_crossing_ncard v hvinj hv hdet P Kp Kq hpq hm hadj hemb x hxp hxq).2
+  exact h.trans_eq (Set.ncard_eq_toFinset_card _ (E.assembledAdmissible v hvinj hv hdet).crossings_finite)
+
+end Zarankiewicz.PolygonalExterior
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/SurgeryNoTriples.lean

@@ -0,0 +1,100 @@
+import OAI.Combinatorics.Crossing.SurgeryCrossingContainment
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.PolygonalExterior
+variable {m n : ℕ} {D : AdmissibleDrawing m n} {C : DrawingPassages D.toFiniteIntersectionDrawing}
+  (E : PolygonalExterior C) (v : BipartiteVertex m n → Plane) (hvinj : Function.Injective v)
+  (hv : ∀ j, squaredLength (v j-D.vertex j) < C.radius^2)
+  (hdet : ∀ j (p q : C.PortsAt (C.vertexMark j)), p ≠ q →
+    det2 (C.portPoint p.val-v j) (C.portPoint q.val-v j) ≠ 0)
+  (P : ∀ e, PolygonalParametrization ((E.assembledAdmissible v hvinj hv hdet).edge e))
+  {p q : C.InnerIndex}
+
+theorem adjacentSurgeryDrawing_no_triples
+    (Kp : ExteriorCrossingCut C P p) (Kq : ExteriorCrossingCut C P q)
+    (hpq : p ≠ q) (hm : C.innerMark p=C.innerMark q) (hadj : p.1.1=q.1.1 ∨ p.1.2=q.1.2)
+    (hcross : SegmentsCrossProperly (C.portPoint (C.incomingPort p)) (C.portPoint (C.outgoingPort p))
+      (C.portPoint (C.incomingPort q)) (C.portPoint (C.outgoingPort q)))
+    (hemb : StraightEdgeEmbedding (crossingSurgeryGraph C P p q) id)
+    (e f g : BipartiteEdge m n) (hef : e ≠ f) (heg : e ≠ g) (hfg : f ≠ g) :
+    edgeInterior (adjacentSurgeryDrawing Kp Kq hm hadj hv hemb) e ∩
+      edgeInterior (adjacentSurgeryDrawing Kp Kq hm hadj hv hemb) f ∩
+      edgeInterior (adjacentSurgeryDrawing Kp Kq hm hadj hv hemb) g = ∅ := by
+  let B := E.assembledAdmissible v hvinj hv hdet
+  let A := adjacentSurgeryDrawing Kp Kq hm hadj hv hemb
+  apply Set.eq_empty_iff_forall_notMem.mpr
+  intro x hx
+  obtain ⟨⟨hxe,hxf⟩,hxg⟩ := hx
+  have havoid : ∀ j, x ≠ B.vertex j := edgeInterior_not_vertex A e x hxe
+  have hthree (a b c : BipartiteEdge m n) (hab : a ≠ b) (hac : a ≠ c) (hbc : b ≠ c)
+      (ha : x ∈ Set.range (B.edge a)) (hb : x ∈ Set.range (B.edge b))
+      (hc : x ∈ Set.range (B.edge c)) : False := by
+    have hmem : x ∈ edgeInterior B.toContinuousDrawing a ∩ edgeInterior B.toContinuousDrawing b ∩
+        edgeInterior B.toContinuousDrawing c :=
+      ⟨⟨edgeInterior_of_range_not_vertices _ a x ha havoid,
+        edgeInterior_of_range_not_vertices _ b x hb havoid⟩,edgeInterior_of_range_not_vertices _ c x hc havoid⟩
+    rw [B.no_triples a b c hab hac hbc] at hmem
+    exact hmem
+  have htwo (a : BipartiteEdge m n) (hap : a ≠ p.1) (haq : a ≠ q.1)
+      (hp : x ∈ Set.range (adjacentSurgeryRouteP Kp Kq hm hadj))
+      (hq : x ∈ Set.range (adjacentSurgeryRouteQ Kp Kq hm hadj))
+      (ha : x ∈ Set.range (B.edge a)) : False := by
+    have hh := E.adjacentSurgeryRoutes_meeting_each_other v hvinj hv hdet P Kp Kq hpq hm hadj hcross x hp hq
+    exact hthree p.1 q.1 a (fun he => hpq (C.innerIndex_eq_of_edge_mark p q he hm))
+      (Ne.symm hap) (Ne.symm haq) hh.1 hh.2 ha
+  have hone (a b : BipartiteEdge m n) (hab : a ≠ b)
+      (hap : a ≠ p.1) (haq : a ≠ q.1) (hbp : b ≠ p.1) (hbq : b ≠ q.1)
+      (hh : x ∈ Set.range (adjacentSurgeryRouteP Kp Kq hm hadj) ∨
+        x ∈ Set.range (adjacentSurgeryRouteQ Kp Kq hm hadj))
+      (ha : x ∈ Set.range (B.edge a)) (hb : x ∈ Set.range (B.edge b)) : False := by
+    rcases E.adjacentSurgeryRoutes_meeting_other v hvinj hv hdet P Kp Kq hpq hm hadj a hap haq x hh ha with hp | hq
+    · exact hthree p.1 a b (Ne.symm hap) (Ne.symm hbp) hab hp ha hb
+    · exact hthree q.1 a b (Ne.symm haq) (Ne.symm hbq) hab hq ha hb
+  have hcases (a : BipartiteEdge m n) (ha : x ∈ Set.range (A.edge a)) :=
+    B.toContinuousDrawing.replaceTwoRoutes_range_cases p.1 q.1 (adjacentSurgeryRouteP Kp Kq hm hadj)
+      (adjacentSurgeryRouteQ Kp Kq hm hadj) a x ha
+  have hec := hcases e (edgeInterior_subset_range A e hxe)
+  have hfc := hcases f (edgeInterior_subset_range A f hxf)
+  have hgc := hcases g (edgeInterior_subset_range A g hxg)
+  rcases hec with ⟨hep,hx⟩ | ⟨heq,hx⟩ | ⟨hep,heq,hx⟩
+  · rcases hfc with ⟨hfp,hy⟩ | ⟨hfq,hy⟩ | ⟨hfp,hfq,hy⟩
+    · exact hef (hep.trans hfp.symm)
+    · rcases hgc with ⟨hgp,hz⟩ | ⟨hgq,hz⟩ | ⟨hgp,hgq,hz⟩
+      · exact heg (hep.trans hgp.symm)
+      · exact hfg (hfq.trans hgq.symm)
+      · exact htwo g hgp hgq hx hy hz
+    · rcases hgc with ⟨hgp,hz⟩ | ⟨hgq,hz⟩ | ⟨hgp,hgq,hz⟩
+      · exact heg (hep.trans hgp.symm)
+      · exact htwo f hfp hfq hx hz hy
+      · exact hone f g hfg hfp hfq hgp hgq (Or.inl hx) hy hz
+  · rcases hfc with ⟨hfp,hy⟩ | ⟨hfq,hy⟩ | ⟨hfp,hfq,hy⟩
+    · rcases hgc with ⟨hgp,hz⟩ | ⟨hgq,hz⟩ | ⟨hgp,hgq,hz⟩
+      · exact hfg (hfp.trans hgp.symm)
+      · exact heg (heq.trans hgq.symm)
+      · exact htwo g hgp hgq hy hx hz
+    · exact hef (heq.trans hfq.symm)
+    · rcases hgc with ⟨hgp,hz⟩ | ⟨hgq,hz⟩ | ⟨hgp,hgq,hz⟩
+      · exact htwo f hfp hfq hz hx hy
+      · exact heg (heq.trans hgq.symm)
+      · exact hone f g hfg hfp hfq hgp hgq (Or.inr hx) hy hz
+  · rcases hfc with ⟨hfp,hy⟩ | ⟨hfq,hy⟩ | ⟨hfp,hfq,hy⟩
+    · rcases hgc with ⟨hgp,hz⟩ | ⟨hgq,hz⟩ | ⟨hgp,hgq,hz⟩
+      · exact hfg (hfp.trans hgp.symm)
+      · exact htwo e hep heq hy hz hx
+      · exact hone e g heg hep heq hgp hgq (Or.inl hy) hx hz
+    · rcases hgc with ⟨hgp,hz⟩ | ⟨hgq,hz⟩ | ⟨hgp,hgq,hz⟩
+      · exact htwo e hep heq hz hy hx
+      · exact hfg (hfq.trans hgq.symm)
+      · exact hone e g heg hep heq hgp hgq (Or.inr hy) hx hz
+    · rcases hgc with ⟨hgp,hz⟩ | ⟨hgq,hz⟩ | ⟨hgp,hgq,hz⟩
+      · exact hone e f hef hep heq hfp hfq (Or.inl hz) hx hy
+      · exact hone e f hef hep heq hfp hfq (Or.inr hz) hx hy
+      · exact hthree e f g hef heg hfg hx hy hz
+
+end Zarankiewicz.PolygonalExterior
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/SurgeryPathWitnesses.lean

@@ -0,0 +1,41 @@
+import OAI.Combinatorics.Crossing.SurgeryCutWalks
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+
+def walkThroughChord {G : SimpleGraph Plane} {a u v b : Plane}
+    (A : G.Walk a u) (h : G.Adj u v) (B : G.Walk v b) : G.Walk a b :=
+  (A.append h.toWalk).append B
+
+theorem walkThroughChord_range {G : SimpleGraph Plane} {a u v b : Plane}
+    (A : G.Walk a u) (h : G.Adj u v) (B : G.Walk v b) :
+    Set.range (graphWalkPath id (walkThroughChord A h B))=
+      (Set.range (graphWalkPath id A) ∪ segment ℝ u v) ∪ Set.range (graphWalkPath id B) := by
+  rw [walkThroughChord,graphWalkPath_append_range,graphWalkPath_append_range,graphWalkPath_toWalk_range]
+
+theorem exists_simple_path_through_chord {G : SimpleGraph Plane}
+    (hemb : StraightEdgeEmbedding G id) {a u v b : Plane} (hab : a ≠ b)
+    (A : G.Walk a u) (h : G.Adj u v) (B : G.Walk v b) :
+    ∃ γ : Path a b, Function.Injective γ ∧ HasFiniteAffineCover γ ∧
+      Set.range γ ⊆ (Set.range (graphWalkPath id A) ∪ segment ℝ u v) ∪ Set.range (graphWalkPath id B) := by
+  classical
+  let p := walkThroughChord A h B
+  refine ⟨graphWalkPath id p.bypass,
+    graphWalkPath_injective id hemb hab p.bypass p.bypass_isPath,
+    graphWalkPath_hasFiniteAffineCover id p.bypass,?_⟩
+  exact (graphWalkPath_bypass_range_subset id p).trans (by rw [walkThroughChord_range])
+
+variable {m n : ℕ} {D D' : AdmissibleDrawing m n}
+
+theorem surgery_mixed_endpoints_ne (C : DrawingPassages D.toFiniteIntersectionDrawing)
+    (p q : C.InnerIndex) : D'.vertex (.inl p.1.1) ≠ D'.vertex (.inr q.1.2) := by
+  intro h
+  cases D'.vertex_injective h
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/SurgeryRouteIntersections.lean

@@ -0,0 +1,78 @@
+import OAI.Combinatorics.Crossing.ReconnectedIntersectionCases
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.PolygonalExterior
+variable {m n : ℕ} {D : AdmissibleDrawing m n} {C : DrawingPassages D.toFiniteIntersectionDrawing}
+  (E : PolygonalExterior C) (v : BipartiteVertex m n → Plane) (hvinj : Function.Injective v)
+  (hv : ∀ j, squaredLength (v j-D.vertex j) < C.radius^2)
+  (hdet : ∀ j (p q : C.PortsAt (C.vertexMark j)), p ≠ q →
+    det2 (C.portPoint p.val-v j) (C.portPoint q.val-v j) ≠ 0)
+  (P : ∀ e, PolygonalParametrization ((E.assembledAdmissible v hvinj hv hdet).edge e))
+  {p q : C.InnerIndex}
+
+theorem reconnectedForwardPath_meeting_other
+    (Kp : ExteriorCrossingCut C P p) (Kq : ExteriorCrossingCut C P q)
+    (hpq : p ≠ q) (hm : C.innerMark p=C.innerMark q)
+    (e : BipartiteEdge m n) (hep : e ≠ p.1) (heq : e ≠ q.1)
+    (x : Plane) (hx : x ∈ Set.range (reconnectedForwardPath Kp Kq hm))
+    (hy : x ∈ Set.range (E.assembledEdge v e)) :
+    x ∈ Set.range (E.assembledEdge v p.1) ∨ x ∈ Set.range (E.assembledEdge v q.1) := by
+  rcases reconnectedForwardPath_trace Kp Kq hm hx with (hx | hx) | hx
+  · exact Or.inl (Kp.prefix_subset_edge hx)
+  · exact False.elim (Set.disjoint_left.mp (E.reconnection_other_edge_disjoint v hv p q hpq hm true e hep heq) hx hy)
+  · exact Or.inr (Kq.suffix_subset_edge hx)
+
+theorem reconnectedBackwardPath_meeting_other
+    (Kp : ExteriorCrossingCut C P p) (Kq : ExteriorCrossingCut C P q)
+    (hpq : p ≠ q) (hm : C.innerMark p=C.innerMark q)
+    (e : BipartiteEdge m n) (hep : e ≠ p.1) (heq : e ≠ q.1)
+    (x : Plane) (hx : x ∈ Set.range (reconnectedBackwardPath Kp Kq hm))
+    (hy : x ∈ Set.range (E.assembledEdge v e)) :
+    x ∈ Set.range (E.assembledEdge v p.1) ∨ x ∈ Set.range (E.assembledEdge v q.1) := by
+  rcases reconnectedBackwardPath_trace Kp Kq hm hx with (hx | hx) | hx
+  · exact Or.inr (Kq.prefix_subset_edge hx)
+  · exact False.elim (Set.disjoint_left.mp (E.reconnection_other_edge_disjoint v hv p q hpq hm false e hep heq) hx hy)
+  · exact Or.inl (Kp.suffix_subset_edge hx)
+
+theorem adjacentSurgeryRoutes_meeting_other
+    (Kp : ExteriorCrossingCut C P p) (Kq : ExteriorCrossingCut C P q)
+    (hpq : p ≠ q) (hm : C.innerMark p=C.innerMark q) (hadj : p.1.1=q.1.1 ∨ p.1.2=q.1.2)
+    (e : BipartiteEdge m n) (hep : e ≠ p.1) (heq : e ≠ q.1)
+    (x : Plane) (hx : x ∈ Set.range (adjacentSurgeryRouteP Kp Kq hm hadj) ∨
+      x ∈ Set.range (adjacentSurgeryRouteQ Kp Kq hm hadj))
+    (hy : x ∈ Set.range (E.assembledEdge v e)) :
+    x ∈ Set.range (E.assembledEdge v p.1) ∨ x ∈ Set.range (E.assembledEdge v q.1) := by
+  have hf := E.reconnectedForwardPath_meeting_other v hvinj hv hdet P Kp Kq hpq hm e hep heq x
+  have hb := E.reconnectedBackwardPath_meeting_other v hvinj hv hdet P Kp Kq hpq hm e hep heq x
+  rcases hx with hx | hx
+  · unfold adjacentSurgeryRouteP at hx
+    split at hx
+    · exact hb hx hy
+    · exact hf hx hy
+  · unfold adjacentSurgeryRouteQ at hx
+    split at hx
+    · exact hf hx hy
+    · exact hb hx hy
+
+theorem adjacentSurgeryRoutes_meeting_each_other
+    (Kp : ExteriorCrossingCut C P p) (Kq : ExteriorCrossingCut C P q)
+    (hpq : p ≠ q) (hm : C.innerMark p=C.innerMark q) (hadj : p.1.1=q.1.1 ∨ p.1.2=q.1.2)
+    (hcross : SegmentsCrossProperly (C.portPoint (C.incomingPort p)) (C.portPoint (C.outgoingPort p))
+      (C.portPoint (C.incomingPort q)) (C.portPoint (C.outgoingPort q)))
+    (x : Plane) (hx : x ∈ Set.range (adjacentSurgeryRouteP Kp Kq hm hadj))
+    (hy : x ∈ Set.range (adjacentSurgeryRouteQ Kp Kq hm hadj)) :
+    x ∈ Set.range (E.assembledEdge v p.1) ∧ x ∈ Set.range (E.assembledEdge v q.1) := by
+  have hh := E.reconnected_paths_meeting_old_edges v hvinj hv hdet P Kp Kq hpq hm hcross x
+  by_cases h : p.1.1=q.1.1
+  · simp only [adjacentSurgeryRouteP,adjacentSurgeryRouteQ,dite_eq_left h] at hx hy
+    exact hh hy hx
+  · simp only [adjacentSurgeryRouteP,adjacentSurgeryRouteQ,dite_eq_right h] at hx hy
+    exact hh hx hy
+
+end Zarankiewicz.PolygonalExterior
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/SurgeryStrictPointCount.lean

@@ -0,0 +1,56 @@
+import OAI.Combinatorics.Crossing.SurgeryCrossingContainment
+import Mathlib.Data.Set.Card
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.PolygonalExterior
+variable {m n : ℕ} {D : AdmissibleDrawing m n} {C : DrawingPassages D.toFiniteIntersectionDrawing}
+  (E : PolygonalExterior C) (v : BipartiteVertex m n → Plane) (hvinj : Function.Injective v)
+  (hv : ∀ j, squaredLength (v j-D.vertex j) < C.radius^2)
+  (hdet : ∀ j (p q : C.PortsAt (C.vertexMark j)), p ≠ q →
+    det2 (C.portPoint p.val-v j) (C.portPoint q.val-v j) ≠ 0)
+  {p q : C.InnerIndex}
+
+theorem crossingChord_meeting_is_assembled_crossing (hpq : p ≠ q) (x : Plane)
+    (hxp : x ∈ Set.range (C.crossingChord p)) (hxq : x ∈ Set.range (C.crossingChord q)) :
+    x ∈ crossingPoints (E.assembledAdmissible v hvinj hv hdet).toContinuousDrawing := by
+  have hm := C.chord_meeting_marks_eq p q hxp hxq
+  have hxin := (C.reconnection_avoids_chord_meeting p q hpq x hxp hxq).1
+  have hxinq : x ∈ C.crossingDisk q := by
+    simpa only [DrawingPassages.crossingDisk,hm] using hxin
+  apply crossing_of_ranges_not_vertices (E.assembledAdmissible v hvinj hv hdet).toContinuousDrawing
+    p.1 q.1 (fun he => hpq (C.innerIndex_eq_of_edge_mark p q he hm)) x
+    ((E.assembled_range_in_crossingDisk v hv p x hxin).mpr hxp)
+    ((E.assembled_range_in_crossingDisk v hv q x hxinq).mpr hxq)
+  intro j he
+  exact Set.disjoint_left.mp (C.crossingDisk_disjoint_vertex_disk p j) hxin (he.symm ▸ (hv j).le)
+
+theorem adjacentSurgeryDrawing_strict_crossing_ncard
+    (P : ∀ e, PolygonalParametrization ((E.assembledAdmissible v hvinj hv hdet).edge e))
+    (Kp : ExteriorCrossingCut C P p) (Kq : ExteriorCrossingCut C P q)
+    (hpq : p ≠ q) (hm : C.innerMark p=C.innerMark q) (hadj : p.1.1=q.1.1 ∨ p.1.2=q.1.2)
+    (hemb : StraightEdgeEmbedding (crossingSurgeryGraph C P p q) id)
+    (x : Plane) (hxp : x ∈ Set.range (C.crossingChord p)) (hxq : x ∈ Set.range (C.crossingChord q)) :
+    (crossingPoints (adjacentSurgeryDrawing Kp Kq hm hadj hv hemb)).Finite ∧
+      (crossingPoints (adjacentSurgeryDrawing Kp Kq hm hadj hv hemb)).ncard <
+        (crossingPoints (E.assembledAdmissible v hvinj hv hdet).toContinuousDrawing).ncard := by
+  have hcross := C.crossingChord_meeting_segmentsCrossProperly p q hpq x hxp hxq
+  have hsub := E.adjacentSurgeryDrawing_crossings_subset v hvinj hv hdet P Kp Kq hpq hm hadj hcross hemb
+  have hfinite := (E.assembledAdmissible v hvinj hv hdet).crossings_finite
+  have hremoved := adjacentSurgeryDrawing_avoids_crossing Kp Kq hm hpq hadj hv hemb x hxp hxq (by
+    intro e hep heq hx
+    exact Set.disjoint_left.mp (E.assembled_other_edge_avoids_crossingDisk v hv p q hpq hm e hep heq)
+      hx (C.reconnection_avoids_chord_meeting p q hpq x hxp hxq).1)
+  have hnot : x ∉ crossingPoints (adjacentSurgeryDrawing Kp Kq hm hadj hv hemb) := by
+    rintro ⟨e,f,hef,hxe,hxf⟩
+    exact hremoved e (edgeInterior_subset_range _ e hxe)
+  refine ⟨hfinite.subset hsub,Set.ncard_lt_ncard ⟨hsub,?_⟩ hfinite⟩
+  intro hrev
+  exact hnot (hrev (E.crossingChord_meeting_is_assembled_crossing v hvinj hv hdet hpq x hxp hxq))
+
+end Zarankiewicz.PolygonalExterior
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TangentTrackIdentity.lean

@@ -0,0 +1,66 @@
+import OAI.Combinatorics.Crossing.CircleOffsetLine
+import OAI.Combinatorics.Crossing.CircleConnectors
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+
+theorem det2_rotateQuarter_self (d : Plane) : det2 d (rotateQuarter d)=squaredLength d := by
+  dsimp [det2,rotateQuarter,squaredLength]
+  ring
+
+theorem normalShift_eq_circleTrackScale (d w : Plane) (hd : d ≠ 0) (hw : w ≠ 0)
+    (hpar : det2 d w=0) : normalShift d=circleTrackScale d w • rotateQuarter w := by
+  let c := dot2 d w/squaredLength d
+  have hp : w=c • d := vector_parallel_of_det_zero d w hd hpar
+  have hc : c ≠ 0 := by
+    intro h
+    rw [h,zero_smul] at hp
+    exact hw hp
+  have hrot : rotateQuarter w=c • rotateQuarter d := by
+    rw [hp]
+    apply Prod.ext
+    · dsimp [rotateQuarter]
+      ring
+    · rfl
+  have hL := ne_of_gt (squaredLength_pos d hd)
+  unfold normalShift circleTrackScale
+  rw [hrot,det2_smul_right,det2_rotateQuarter_self,smul_smul]
+  congr 1
+  field_simp
+
+theorem similarity_circleTangentOffset (o u v : Plane) (δ : ℝ) :
+    similarityPoint o u (circleTangentOffset v δ)=
+      similarityPoint o u v+δ • rotateQuarter (similarityPoint o u v-o) := by
+  apply Prod.ext <;> dsimp [similarityPoint,circleTangentOffset,rotateQuarter] <;> ring
+
+theorem tangentOffset_eq_normalShift (o u v d : Plane) (hd : d ≠ 0)
+    (hw : similarityPoint o u v-o ≠ 0) (hpar : det2 d (similarityPoint o u v-o)=0)
+    (ε : ℝ) :
+    similarityPoint o u (circleTangentOffset v (circleTrackScale d (similarityPoint o u v-o)*ε))=
+      similarityPoint o u v+ε • normalShift d := by
+  rw [similarity_circleTangentOffset,normalShift_eq_circleTrackScale d _ hd hw hpar,smul_smul]
+  congr 2
+  ring
+
+theorem similarityPoint_squaredLength (o u x : Plane) :
+    squaredLength (similarityPoint o u x-o)=squaredLength u*squaredLength x := by
+  dsimp [similarityPoint,squaredLength]
+  ring
+
+theorem physical_circleConnector_strictly_outside (o u v : Plane) (hu : u ≠ 0)
+    (hv : squaredLength v=1) (δ : ℝ) (hδ : |δ|<1) (hne : δ ≠ 0)
+    (t : ℝ) (ht : 0<t) :
+    squaredLength u < squaredLength
+      (segmentPoint (similarityPoint o u (circleOffset v δ))
+        (similarityPoint o u (circleTangentOffset v δ)) t-o) := by
+  rw [← similarityPoint_segment,similarityPoint_squaredLength]
+  have hh := circleConnector_strictly_outside v hv δ hδ hne t ht
+  nlinarith [squaredLength_pos u hu]
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TrackChordSeparation.lean

@@ -0,0 +1,52 @@
+import OAI.Combinatorics.Crossing.RoundDiskChords
+import OAI.Combinatorics.Crossing.PhysicalVertexChords
+import OAI.Combinatorics.Crossing.SpokePieceIsolation
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+namespace VertexTruncation
+variable {m n : ℕ} {D : ContinuousDrawing m n} (V : VertexTruncation D)
+
+theorem track_in_disk_is_port (j : BipartiteVertex m n) (e : BipartiteEdge m n) (x : Plane)
+    (hx : x ∈ Set.range (V.path e)) (hmem : x ∈ closedRoundDisk (D.vertex j) V.radius) :
+    ∃ f : IncidentEdges j, x=V.spokePort j f := by
+  rcases V.vertex_disk_cases j e x hx with ⟨hj,he⟩ | ⟨hj,he⟩ | hout
+  · refine ⟨⟨e,Or.inl hj⟩,?_⟩
+    simpa only [spokePort,drawingSpokePort,ite_eq_left hj,startPort] using he
+  · have hnot : j ≠ Sum.inl e.1 := by
+      intro hh
+      cases hh.symm.trans hj
+    refine ⟨⟨e,Or.inr hj⟩,?_⟩
+    simpa only [spokePort,drawingSpokePort,ite_eq_right hnot,endPort] using he
+  · exact False.elim (not_lt_of_ge hmem hout)
+
+end VertexTruncation
+namespace TruncatedSpokeCoordinates
+variable {m n : ℕ} {D : ContinuousDrawing m n} {V : VertexTruncation D}
+  (C : TruncatedSpokeCoordinates V)
+
+theorem track_shifted_chord_disjoint (j : BipartiteVertex m n) (c d : IncidentEdges j)
+    (ε : ℝ) (hc : |V.spokeScale j c*ε|≤1) (hd : |V.spokeScale j d*ε|≤1)
+    (hsep : ∀ f g : IncidentEdges j, V.spokePort j f ≠ C.shiftedPort j g ε)
+    (e : BipartiteEdge m n) (i : Fin (V.pieces e)) :
+    ¬ ClosedSegmentsMeet (V.vertices e i.val) (V.vertices e (i.val+1))
+      (C.shiftedPort j c ε) (C.shiftedPort j d ε) := by
+  intro hmeet
+  obtain ⟨x,hx,hy⟩ := (closedSegmentsMeet_iff_nonempty_inter _ _ _ _).mp hmeet
+  have hcirclec := C.shiftedPort_circle j c ε hc
+  have hcircled := C.shiftedPort_circle j d ε hd
+  have hmem := round_chord_subset_closed_disk (D.vertex j) _ _ V.radius hcirclec hcircled hy
+  obtain ⟨f,hf⟩ := V.track_in_disk_is_port j e x (V.piece_subset_range e i.val i.isLt hx) hmem
+  have hboundary : squaredLength (x-D.vertex j)=V.radius^2 := by rw [hf,V.spokePort_circle]
+  rcases round_chord_boundary_endpoints (D.vertex j) _ _ x V.radius hcirclec hcircled hy hboundary with h | h
+  · exact hsep f c (hf.symm.trans h)
+  · exact hsep f d (hf.symm.trans h)
+
+end TruncatedSpokeCoordinates
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TrackEndpointConnections.lean

@@ -0,0 +1,43 @@
+import OAI.Combinatorics.Crossing.TruncatedSpokeCoordinates
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.VertexTruncation
+variable {m n : ℕ} {D : ContinuousDrawing m n} (V : VertexTruncation D)
+
+def leftIncident (_V : VertexTruncation D) (e : BipartiteEdge m n) : IncidentEdges (m:=m) (n:=n) (Sum.inl e.1) := ⟨e,Or.inl rfl⟩
+def rightIncident (_V : VertexTruncation D) (e : BipartiteEdge m n) : IncidentEdges (m:=m) (n:=n) (Sum.inr e.2) := ⟨e,Or.inr rfl⟩
+
+theorem vertices_first (e : BipartiteEdge m n) : V.vertices e 0=V.startPort e :=
+  (V.chain e).truncatedVertices_first V.radius
+
+theorem vertices_last (e : BipartiteEdge m n) : V.vertices e (V.pieces e)=V.endPort e :=
+  (V.chain e).truncatedVertices_last (V.pieces_pos e) V.radius
+
+theorem spokePort_left (e : BipartiteEdge m n) :
+    V.spokePort (Sum.inl e.1) (V.leftIncident e)=V.startPort e := by
+  simp [spokePort,drawingSpokePort,leftIncident,startPort]
+
+theorem spokePort_right (e : BipartiteEdge m n) :
+    V.spokePort (Sum.inr e.2) (V.rightIncident e)=V.endPort e := by
+  simp [spokePort,drawingSpokePort,rightIncident,endPort]
+
+theorem shiftedTrack_first (C : TruncatedSpokeCoordinates V) (e : BipartiteEdge m n) (ε : ℝ) :
+    shiftedTrack (V.vertices e) (V.pieces e) ε 0=
+      C.tangentPort (Sum.inl e.1) (V.leftIncident e) ε := by
+  simp [shiftedTrack,trackOffset,TruncatedSpokeCoordinates.tangentPort,spokeDirection,
+    spokeIndex,leftIncident,V.vertices_first,spokePort,drawingSpokePort,startPort]
+
+theorem shiftedTrack_last (C : TruncatedSpokeCoordinates V) (e : BipartiteEdge m n) (ε : ℝ) :
+    shiftedTrack (V.vertices e) (V.pieces e) ε (V.pieces e)=
+      C.tangentPort (Sum.inr e.2) (V.rightIncident e) ε := by
+  have hn : V.pieces e ≠ 0 := ne_of_gt (V.pieces_pos e)
+  simp [shiftedTrack,trackOffset,hn,TruncatedSpokeCoordinates.tangentPort,spokeDirection,
+    spokeIndex,rightIncident,V.vertices_last,spokePort,drawingSpokePort,endPort]
+
+end Zarankiewicz.VertexTruncation
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TransversalityStability.lean

@@ -0,0 +1,50 @@
+import OAI.Combinatorics.Crossing.SegmentContinuity
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+open scoped Topology Classical
+
+theorem segmentPairTransverse_of_proper (a b c d : Plane) (h : SegmentsCrossProperly a b c d) :
+    SegmentPairTransverse a b c d := by
+  obtain ⟨hn,t₀,ht₀,u₀,hu₀,he₀⟩ := h
+  intro t ht u hu he
+  obtain ⟨rfl,rfl⟩ := segment_intersection_parameters_unique a b c d hn t u t₀ u₀ he he₀
+  exact ⟨hn,ht₀,hu₀⟩
+
+theorem segmentPairTransverse_swap (a b c d : Plane) (h : SegmentPairTransverse a b c d) :
+    SegmentPairTransverse c d a b := by
+  intro t ht u hu he
+  obtain ⟨hn,hu',ht'⟩ := h u hu t ht he.symm
+  refine ⟨?_,ht',hu'⟩
+  rw [det2_swap]
+  exact neg_ne_zero.mpr hn
+
+theorem eventually_segmentPairTransverse (a b c d : Plane) (h : SegmentPairTransverse a b c d) :
+    ∀ᶠ ab : Plane × Plane in 𝓝 (a,b), SegmentPairTransverse ab.1 ab.2 c d := by
+  by_cases hc : SegmentsCrossProperly a b c d
+  · have hsign : segmentCrossingSign a b c d ≠ 0 := by
+      unfold segmentCrossingSign
+      rw [ite_eq_left hc]
+      split_ifs <;> norm_num
+    filter_upwards [eventually_segmentCrossingSign_of_proper a b c d hc] with ab hab
+    apply segmentPairTransverse_of_proper
+    by_contra hn
+    have hz : segmentCrossingSign ab.1 ab.2 c d = 0 := by simp [segmentCrossingSign,hn]
+    exact hsign (hab.symm.trans hz)
+  · have hn : ¬ ClosedSegmentsMeet a b c d := by
+      rintro ⟨t,ht,u,hu,he⟩
+      obtain ⟨hd,ht',hu'⟩ := h t ht u hu he
+      exact hc ⟨hd,t,ht',u,hu',he⟩
+    have hevent := (isClosed_closedSegmentsMeet c d).isOpen_compl.mem_nhds
+      (show (a,b) ∈ {ab : Plane × Plane | ClosedSegmentsMeet ab.1 ab.2 c d}ᶜ from hn)
+    filter_upwards [hevent] with ab hab
+    intro t ht u hu he
+    exact False.elim (hab ⟨t,ht,u,hu,he⟩)
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TransversePolygonIntersection.lean

@@ -0,0 +1,56 @@
+import OAI.Combinatorics.Crossing.GenericPolygonIntersection
+import OAI.Combinatorics.Crossing.GenericPointFamily
+import OAI.Combinatorics.Crossing.PolygonStability
+import OAI.Combinatorics.Crossing.PeriodicPolygon
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+
+theorem segmentCrossingSign_self_left (a c d : Plane) : segmentCrossingSign a a c d = 0 := by
+  simp [segmentCrossingSign,SegmentsCrossProperly,det2]
+
+theorem polygon_intersection_zero_transverse (v w : ℕ → Plane) (n m : ℕ)
+    (hc : v n=v 0) (hd : w m=w 0)
+    (hw : ∀ j : Fin m, w (j.val+1) ≠ w j.val)
+    (ht : ∀ i : Fin n, ∀ j : Fin m,
+      SegmentPairTransverse (v i.val) (v (i.val+1)) (w j.val) (w (j.val+1))) :
+    polygonIntersection v w n m = 0 := by
+  by_cases hn : 1<n
+  · have hn0 : 0<n := by omega
+    obtain ⟨ε,hε,hstable⟩ := exists_polygon_intersection_stability_radius v w n m ht
+    obtain ⟨p,hnear,hinj,hpq,hline,hpar,hcorn⟩ := exists_generic_point_family
+      (fun j : Fin (m+1) => w j.val) (fun j : Fin m => w j.val)
+      (fun j : Fin m => w (j.val+1)-w j.val) (fun j => sub_ne_zero.mpr (hw j))
+      n (fun i => v i.val) (fun _ => ε) (fun _ => hε)
+    let v' := periodicPolygon n hn0 p
+    have hclose : v' n=v' 0 := periodicPolygon_closed n hn0 p
+    have hv' (i : Fin n) : v' (i.val+1) ≠ v' i.val :=
+      hinj.ne (cyclicIndex_succ_ne n hn i)
+    have hpoint (i : Fin (n+1)) (j : Fin (m+1)) : w j.val ≠ v' i.val := hpq _ j
+    have hposition : PolygonLinePosition v' w n m := by
+      refine ⟨?_,?_,?_⟩
+      · intro i j
+        exact hpar _ _ (Ne.symm (cyclicIndex_succ_ne n hn i)) j
+      · intro i j
+        change det2 (w (j.val+1)-w j.val) (p (cyclicIndex n hn0 i.val)-w j.val) ≠ 0
+        rw [det2_swap]
+        exact neg_ne_zero.mpr (hline _ j)
+      · intro i j
+        exact hcorn _ _ (Ne.symm (cyclicIndex_succ_ne n hn i)) j
+    have hzero := polygon_intersection_zero_in_line_position v' w n m hclose hd hv' hw hpoint hposition
+    have heq := hstable v' (periodicPolygon_near n hn0 v hc p ε hnear)
+    rwa [heq] at hzero
+  · have hn' : n=0 ∨ n=1 := by omega
+    rcases hn' with rfl | rfl
+    · simp [polygonIntersection]
+    · simp only [polygonIntersection,Finset.sum_range_one]
+      rw [hc]
+      simp only [segmentCrossingSign_self_left,Finset.sum_const_zero]
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TriangleEntryExit.lean

@@ -0,0 +1,71 @@
+import OAI.Combinatorics.Crossing.TriangleSideEvent
+import OAI.Combinatorics.Crossing.SortedSideEvents
+import OAI.Combinatorics.Crossing.PolygonalWalks
+import Mathlib.Tactic.FinCases
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+open scoped BigOperators Classical
+
+def triangleStart (a b c : Plane) : Fin 3 → Plane := ![a,b,c]
+def triangleEnd (a b c : Plane) : Fin 3 → Plane := ![b,c,a]
+def triangleIndicator (a b c z : Plane) : ℝ :=
+  ∏ i : Fin 3, positiveIndicator (orient2 (triangleStart a b c i) (triangleEnd a b c i) z)
+
+theorem triangle_area_cycle (a b c : Plane) : orient2 b c a = orient2 a b c := by
+  dsimp [orient2,det2]
+  ring
+
+theorem affine_side_factor (a b c d : Plane) (hn : det2 (b-a) (d-c) ≠ 0) (t : ℝ) :
+    orient2 a b (segmentPoint c d t) =
+      det2 (b-a) (d-c) * (t-secondIntersectionParameter a b c d) := by
+  rw [orient2_segment]
+  change (1-t)*orient2 a b c+t*orient2 a b d =
+    det2 (b-a) (d-c)*(t-(-orient2 a b c / det2 (b-a) (d-c)))
+  field_simp
+  linear_combination t * (orient2_difference a b c d)
+
+theorem triangle_segment_entry_exit (a b c d e : Plane)
+    (harea : 0 < orient2 a b c)
+    (hn : ∀ i : Fin 3, det2 (triangleEnd a b c i-triangleStart a b c i) (e-d) ≠ 0)
+    (hr : Function.Injective (fun i : Fin 3 =>
+      secondIntersectionParameter (triangleStart a b c i) (triangleEnd a b c i) d e))
+    (h0 : ∀ i : Fin 3, secondIntersectionParameter (triangleStart a b c i) (triangleEnd a b c i) d e ≠ 0)
+    (h1 : ∀ i : Fin 3, secondIntersectionParameter (triangleStart a b c i) (triangleEnd a b c i) d e ≠ 1) :
+    triangleSegmentIntersection a b c d e = triangleIndicator a b c e-triangleIndicator a b c d := by
+  let r := fun i : Fin 3 => secondIntersectionParameter (triangleStart a b c i) (triangleEnd a b c i) d e
+  let b' := fun i : Fin 3 => det2 (triangleEnd a b c i-triangleStart a b c i) (e-d)
+  have hf (i : Fin 3) (t : ℝ) : b' i*(t-r i) =
+      orient2 (triangleStart a b c i) (triangleEnd a b c i) (segmentPoint d e t) :=
+    (affine_side_factor _ _ d e (hn i) t).symm
+  have hc1 : 0 < orient2 b c a := by rwa [triangle_area_cycle]
+  have hc2 : 0 < orient2 c a b := by rwa [triangle_area_cycle,triangle_area_cycle]
+  have hs (i : Fin 3) :
+      segmentCrossingSign (triangleStart a b c i) (triangleEnd a b c i) d e =
+        if 0<r i ∧ r i<1 then slopeSign (b' i) *
+          (∏ j : Fin 3, if j=i then 1 else positiveIndicator
+            (orient2 (triangleStart a b c j) (triangleEnd a b c j) (segmentPoint d e (r i)))) else 0 := by
+    fin_cases i
+    · simpa [r,b',triangleStart,triangleEnd,Fin.prod_univ_succ] using
+        segmentCrossingSign_triangle_event a b c d e harea (hn 0)
+    · simpa [r,b',triangleStart,triangleEnd,Fin.prod_univ_succ,mul_comm] using
+        segmentCrossingSign_triangle_event b c a d e hc1 (hn 1)
+    · simpa [r,b',triangleStart,triangleEnd,Fin.prod_univ_succ] using
+        segmentCrossingSign_triangle_event c a b d e hc2 (hn 2)
+  have h := sum_affine_side_events_unordered 3 r b' hr hn h0 h1
+  simp_rw [hf] at h
+  simp only [segmentPoint_one,segmentPoint_zero] at h
+  calc
+    triangleSegmentIntersection a b c d e =
+        ∑ i : Fin 3, segmentCrossingSign (triangleStart a b c i) (triangleEnd a b c i) d e := by
+      simp [triangleSegmentIntersection,triangleStart,triangleEnd,Fin.sum_univ_succ]
+      ring
+    _ = _ := by simpa only [hs,triangleIndicator] using h
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TriangleFactorization.lean

@@ -0,0 +1,75 @@
+import OAI.Combinatorics.Crossing.HalfOrderReduction
+import OAI.Combinatorics.Crossing.WeightedGram
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+open scoped BigOperators
+
+def triangleDiagonalWeight (s : ℕ) (node : OrderedNode s → ℝ) (j : BiExponent s) : ℝ :=
+  let pq := triangleNodePair s (triangleCoordEquiv s j)
+  triangleCoefficient s pq.1 pq.2 * detectorWeight node pq.1 pq.2
+
+theorem triangleDiagonalWeight_ne_zero (s : ℕ) (node : OrderedNode s → ℝ)
+    (hn : Function.Injective node) (j : BiExponent s) : triangleDiagonalWeight s node j ≠ 0 := by
+  let pq := triangleNodePair s (triangleCoordEquiv s j)
+  have hmem : (pq.1.val,pq.2.val) ∈ twoTriangle s := (triangleCoordEquiv s j).property
+  have hpq : pq.1 ≠ pq.2 := by
+    intro he
+    have hv := congrArg Subtype.val he
+    rw [mem_twoTriangle] at hmem
+    omega
+  exact mul_ne_zero ((triangleCoefficient_ne_zero_iff s pq.1 pq.2).mpr hmem)
+    (detectorWeight_ne_zero node hn hpq)
+
+theorem rankDetector_triangle_sum (s : ℕ) (node : OrderedNode s → ℝ) :
+    rankDetector s node (fun p q => triangleCoefficient s p q) =
+      ∑ j : BiExponent s,
+        let pq := triangleNodePair s (triangleCoordEquiv s j)
+        triangleCoefficient s pq.1 pq.2 • detectorAtom s node pq.1 pq.2 := by
+  let f := fun pq : OrderedNode s × OrderedNode s =>
+    triangleCoefficient s pq.1 pq.2 • detectorAtom s node pq.1 pq.2
+  have hfull : rankDetector s node (fun p q => triangleCoefficient s p q) = ∑ pq, f pq :=
+    (Fintype.sum_prod_type f).symm
+  have hfilter : (∑ pq ∈ orderedTriangle s, f pq) = ∑ pq, f pq := by
+    apply Finset.sum_subset (Finset.filter_subset _ _)
+    intro pq hpq hnot
+    have hm : (pq.1.val,pq.2.val) ∉ twoTriangle s := by simpa [orderedTriangle] using hnot
+    have hz : triangleCoefficient s pq.1 pq.2 = 0 :=
+      not_ne_iff.mp (mt (triangleCoefficient_ne_zero_iff s pq.1 pq.2).mp hm)
+    simp only [f, hz, zero_smul]
+  rw [hfull, ← hfilter, ← Finset.sum_coe_sort]
+  exact ((triangleCoordEquiv s).trans (triangleNodeEquiv s)).sum_comp
+    (fun pq : ↥(orderedTriangle s) => f pq.val) |>.symm
+
+theorem rankDetector_triangle_factorization (s : ℕ) (node : OrderedNode s → ℝ) :
+    rankDetector s node (fun p q => triangleCoefficient s p q) =
+      triangleMatrix s (extendOrderedNode s node) * Matrix.diagonal (triangleDiagonalWeight s node) *
+        (triangleMatrix s (extendOrderedNode s node)).transpose := by
+  rw [rankDetector_triangle_sum, weightedGram_eq_sum]
+  apply Finset.sum_congr rfl
+  intro j hj
+  simp only [triangleDiagonalWeight, detectorAtom, smul_smul]
+  congr 2
+  · funext ab
+    exact (triangleMatrix_ordered_entry s node ab j).symm
+  · funext ab
+    exact (triangleMatrix_ordered_entry s node ab j).symm
+
+theorem rankDetector_ordered_isUnit (s : ℕ) (node : OrderedNode s → ℝ)
+    (hn : Function.Injective node) :
+    IsUnit (rankDetector s node (halfOrderMatrix (OrderedNode s))) := by
+  rw [rankDetector_halfOrder_reduction s node hn]
+  apply IsUnit.neg
+  change IsUnit (rankDetector s node (fun p q => triangleCoefficient s p q))
+  rw [rankDetector_triangle_factorization]
+  exact weightedGram_isUnit _ _
+    (triangleMatrix_isUnit s (extendOrderedNode s node) (extendOrderedNode_injOn s node hn))
+    (triangleDiagonalWeight_ne_zero s node hn)
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TriangleOrientations.lean

@@ -0,0 +1,90 @@
+import OAI.Combinatorics.Crossing.TriangleTransversality
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+open scoped BigOperators Classical
+
+theorem orient2_reverse_edge (a b c : Plane) : orient2 b a c = -orient2 a b c := by
+  dsimp [orient2,det2]
+  ring
+
+theorem det2_reverse_edge (a b c d : Plane) : det2 (a-b) (d-c) = -det2 (b-a) (d-c) := by
+  dsimp [det2]
+  ring
+
+theorem triangle_position_reverse (a b c d e : Plane)
+    (h : TriangleSegmentPosition a b c d e) : TriangleSegmentPosition a c b d e := by
+  refine ⟨?_,?_,?_⟩
+  · intro i
+    fin_cases i
+    · change det2 (c-a) (e-d) ≠ 0
+      rw [det2_reverse_edge c a d e]
+      exact neg_ne_zero.mpr (h.1 2)
+    · change det2 (b-c) (e-d) ≠ 0
+      rw [det2_reverse_edge b c d e]
+      exact neg_ne_zero.mpr (h.1 1)
+    · change det2 (a-b) (e-d) ≠ 0
+      rw [det2_reverse_edge a b d e]
+      exact neg_ne_zero.mpr (h.1 0)
+  · intro i
+    fin_cases i
+    · exact h.2.1 0
+    · exact h.2.1 2
+    · exact h.2.1 1
+  · intro i
+    fin_cases i
+    · change orient2 a c d ≠ 0 ∧ orient2 a c e ≠ 0
+      rw [orient2_reverse_edge c a d,orient2_reverse_edge c a e]
+      exact ⟨neg_ne_zero.mpr (h.2.2 2).1,neg_ne_zero.mpr (h.2.2 2).2⟩
+    · change orient2 c b d ≠ 0 ∧ orient2 c b e ≠ 0
+      rw [orient2_reverse_edge b c d,orient2_reverse_edge b c e]
+      exact ⟨neg_ne_zero.mpr (h.2.2 1).1,neg_ne_zero.mpr (h.2.2 1).2⟩
+    · change orient2 b a d ≠ 0 ∧ orient2 b a e ≠ 0
+      rw [orient2_reverse_edge a b d,orient2_reverse_edge a b e]
+      exact ⟨neg_ne_zero.mpr (h.2.2 0).1,neg_ne_zero.mpr (h.2.2 0).2⟩
+
+theorem triangle_intersection_reverse (a b c d e : Plane) :
+    triangleSegmentIntersection a c b d e = -triangleSegmentIntersection a b c d e := by
+  unfold triangleSegmentIntersection
+  rw [segmentCrossingSign_reverse_left c a d e,
+    segmentCrossingSign_reverse_left b c d e,segmentCrossingSign_reverse_left a b d e]
+  ring
+
+def orientedTriangleIndicator (a b c z : Plane) : ℝ :=
+  if 0 < orient2 a b c then triangleIndicator a b c z else -triangleIndicator a c b z
+
+theorem oriented_triangle_entry_exit (a b c d e : Plane) (ha : orient2 a b c ≠ 0)
+    (h : TriangleSegmentPosition a b c d e) :
+    triangleSegmentIntersection a b c d e =
+      orientedTriangleIndicator a b c e-orientedTriangleIndicator a b c d := by
+  rcases lt_or_gt_of_ne ha with ha | ha
+  · have hac : 0 < orient2 a c b := by
+      rw [triangle_area_cycle b a c,orient2_reverse_edge]
+      exact neg_pos.mpr ha
+    have hh := triangle_segment_entry_exit_of_position a c b d e hac (triangle_position_reverse a b c d e h)
+    rw [triangle_intersection_reverse] at hh
+    simp only [orientedTriangleIndicator,not_lt.mpr ha.le,ite_false]
+    linarith
+  · simpa only [orientedTriangleIndicator,ha,ite_true] using triangle_segment_entry_exit_of_position a b c d e ha h
+
+theorem triangle_closed_walk_intersection_zero (a b c : Plane) (ha : orient2 a b c ≠ 0)
+    (w : ℕ → Plane) (m : ℕ) (hw : w m = w 0)
+    (h : ∀ j ∈ Finset.range m, TriangleSegmentPosition a b c (w j) (w (j+1))) :
+    (∑ j ∈ Finset.range m, triangleSegmentIntersection a b c (w j) (w (j+1))) = 0 := by
+  have hs := telescoping_real_sum (fun j => orientedTriangleIndicator a b c (w j)) m
+  rw [hw,sub_self,Finset.sum_sub_distrib] at hs
+  calc
+    _ = ∑ j ∈ Finset.range m,
+        (orientedTriangleIndicator a b c (w (j+1))-orientedTriangleIndicator a b c (w j)) := by
+      apply Finset.sum_congr rfl
+      intro j hj
+      exact oriented_triangle_entry_exit a b c _ _ ha (h j hj)
+    _ = 0 := by rw [Finset.sum_sub_distrib]; linarith
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TriangleSideEvent.lean

@@ -0,0 +1,54 @@
+import OAI.Combinatorics.Crossing.SegmentSides
+import OAI.Combinatorics.Crossing.AffineSideEvents
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+open scoped Classical
+
+theorem triangle_side_at_first_edge (a b c : Plane) (t : ℝ) :
+    orient2 b c (segmentPoint a b t) = (1-t)*orient2 a b c := by
+  dsimp [orient2,det2,segmentPoint]
+  ring
+
+theorem triangle_other_side_at_first_edge (a b c : Plane) (t : ℝ) :
+    orient2 c a (segmentPoint a b t) = t*orient2 a b c := by
+  dsimp [orient2,det2,segmentPoint]
+  ring
+
+theorem triangle_edge_side_tests (a b c d e : Plane)
+    (harea : 0 < orient2 a b c) (hn : det2 (b-a) (e-d) ≠ 0) :
+    (0 < orient2 b c (segmentPoint d e (secondIntersectionParameter a b d e)) ↔
+      firstIntersectionParameter a b d e < 1) ∧
+    (0 < orient2 c a (segmentPoint d e (secondIntersectionParameter a b d e)) ↔
+      0 < firstIntersectionParameter a b d e) := by
+  rw [← intersection_parameters_eq a b d e hn,
+    triangle_side_at_first_edge, triangle_other_side_at_first_edge]
+  constructor
+  · rw [mul_pos_iff_of_pos_right harea]
+    constructor <;> intro h <;> linarith
+  · exact mul_pos_iff_of_pos_right harea
+
+theorem segmentCrossingSign_triangle_event (a b c d e : Plane)
+    (harea : 0 < orient2 a b c) (hn : det2 (b-a) (e-d) ≠ 0) :
+    segmentCrossingSign a b d e =
+      if 0 < secondIntersectionParameter a b d e ∧ secondIntersectionParameter a b d e < 1 then
+        slopeSign (det2 (b-a) (e-d)) *
+          (positiveIndicator (orient2 b c (segmentPoint d e (secondIntersectionParameter a b d e))) *
+           positiveIndicator (orient2 c a (segmentPoint d e (secondIntersectionParameter a b d e))))
+      else 0 := by
+  obtain ⟨hleft,hright⟩ := triangle_edge_side_tests a b c d e harea hn
+  rw [segmentCrossingSign, segmentsCrossProperly_iff_parameters a b d e hn]
+  simp only [Set.mem_Ioo,positiveIndicator,hleft,hright]
+  by_cases hu : 0 < secondIntersectionParameter a b d e ∧ secondIntersectionParameter a b d e < 1
+  · by_cases ht0 : 0 < firstIntersectionParameter a b d e <;>
+      by_cases ht1 : firstIntersectionParameter a b d e < 1 <;>
+      simp [hu,ht0,ht1,slopeSign]
+  · simp [hu]
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TriangleTransversality.lean

@@ -0,0 +1,73 @@
+import OAI.Combinatorics.Crossing.TriangleEntryExit
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+
+def TriangleSegmentPosition (a b c d e : Plane) : Prop :=
+  (∀ i : Fin 3, det2 (triangleEnd a b c i-triangleStart a b c i) (e-d) ≠ 0) ∧
+  (∀ i : Fin 3, orient2 d e (triangleStart a b c i) ≠ 0) ∧
+  (∀ i : Fin 3, orient2 (triangleStart a b c i) (triangleEnd a b c i) d ≠ 0 ∧
+    orient2 (triangleStart a b c i) (triangleEnd a b c i) e ≠ 0)
+
+theorem triangle_consecutive_roots_ne (a b c d e : Plane)
+    (ha : orient2 a b c ≠ 0) (h₀ : det2 (b-a) (e-d) ≠ 0)
+    (h₁ : det2 (c-b) (e-d) ≠ 0) (hb : orient2 d e b ≠ 0) :
+    secondIntersectionParameter a b d e ≠ secondIntersectionParameter b c d e := by
+  intro heq
+  have hz : orient2 b c (segmentPoint a b (firstIntersectionParameter a b d e)) = 0 := by
+    rw [intersection_parameters_eq a b d e h₀,heq,
+      ← intersection_parameters_eq b c d e h₁,orient2_self_segment]
+  rw [triangle_side_at_first_edge] at hz
+  have ht : firstIntersectionParameter a b d e = 1 := by
+    have := (mul_eq_zero.mp hz).resolve_right ha
+    linarith
+  have hp := intersection_parameters_eq a b d e h₀
+  rw [ht,segmentPoint_one] at hp
+  apply hb
+  rw [hp,orient2_self_segment]
+
+theorem second_parameter_ne_zero (a b c d : Plane)
+    (hn : det2 (b-a) (d-c) ≠ 0) (hc : orient2 a b c ≠ 0) :
+    secondIntersectionParameter a b c d ≠ 0 := by
+  intro h
+  have hh := affine_side_factor a b c d hn 0
+  rw [h,segmentPoint_zero] at hh
+  apply hc
+  simpa using hh
+
+theorem second_parameter_ne_one (a b c d : Plane)
+    (hn : det2 (b-a) (d-c) ≠ 0) (hd : orient2 a b d ≠ 0) :
+    secondIntersectionParameter a b c d ≠ 1 := by
+  intro h
+  have hh := affine_side_factor a b c d hn 1
+  rw [h,segmentPoint_one] at hh
+  apply hd
+  simpa using hh
+
+theorem triangle_roots_injective (a b c d e : Plane) (ha : orient2 a b c ≠ 0)
+    (h : TriangleSegmentPosition a b c d e) :
+    Function.Injective (fun i : Fin 3 =>
+      secondIntersectionParameter (triangleStart a b c i) (triangleEnd a b c i) d e) := by
+  have h₀ := triangle_consecutive_roots_ne a b c d e ha (h.1 0) (h.1 1) (h.2.1 1)
+  have ha₁ : orient2 b c a ≠ 0 := by rwa [triangle_area_cycle]
+  have ha₂ : orient2 c a b ≠ 0 := by rwa [triangle_area_cycle,triangle_area_cycle]
+  have h₁ := triangle_consecutive_roots_ne b c a d e ha₁ (h.1 1) (h.1 2) (h.2.1 2)
+  have h₂ := triangle_consecutive_roots_ne c a b d e ha₂ (h.1 2) (h.1 0) (h.2.1 0)
+  intro i j hij
+  fin_cases i <;> fin_cases j <;> simp_all [triangleStart,triangleEnd]
+
+theorem triangle_segment_entry_exit_of_position (a b c d e : Plane)
+    (ha : 0 < orient2 a b c) (h : TriangleSegmentPosition a b c d e) :
+    triangleSegmentIntersection a b c d e = triangleIndicator a b c e-triangleIndicator a b c d := by
+  exact triangle_segment_entry_exit a b c d e ha h.1
+    (triangle_roots_injective a b c d e (ne_of_gt ha) h)
+    (fun i => second_parameter_ne_zero _ _ _ _ (h.1 i) (h.2.2 i).1)
+    (fun i => second_parameter_ne_one _ _ _ _ (h.1 i) (h.2.2 i).2)
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TruncatedChainDirections.lean

@@ -0,0 +1,59 @@
+import OAI.Combinatorics.Crossing.TruncatedChainVertices
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.PolygonalChain
+variable {O : Set Plane} {a b : Plane}
+
+def truncatedScale (P : PolygonalChain O a b) (r : ℝ) (i : ℕ) : ℝ :=
+  1-(if i=0 then P.startFraction r else 0)-(if i+1=P.pieces then P.endFraction r else 0)
+
+theorem truncated_start_formula (P : PolygonalChain O a b) (r : ℝ) (i : ℕ) (hi : i < P.pieces) :
+    P.truncatedVertices r i=P.vertices i+(if i=0 then P.startFraction r else 0) • trackDirection P.vertices i := by
+  by_cases h : i=0
+  · subst i
+    rw [truncatedVertices_first,startPort_eq_fraction]
+    rfl
+  · simp only [truncatedVertices,ite_eq_right h,ite_eq_right (show i ≠ P.pieces by omega),zero_smul,add_zero]
+
+theorem truncated_end_formula (P : PolygonalChain O a b) (r : ℝ) (i : ℕ) (_hi : i < P.pieces) :
+    P.truncatedVertices r (i+1)=P.vertices (i+1)-(if i+1=P.pieces then P.endFraction r else 0) •
+      trackDirection P.vertices i := by
+  by_cases h : i+1=P.pieces
+  · have hh : i=P.pieces-1 := by omega
+    rw [h,truncatedVertices_last P (by omega) r,endPort_eq_fraction,ite_eq_left rfl]
+    simp only [trackDirection,hh,show P.pieces-1+1=P.pieces by omega]
+  · simp only [truncatedVertices,ite_eq_right (show i+1 ≠ 0 by omega),ite_eq_right h,zero_smul,sub_zero]
+
+theorem truncated_direction (P : PolygonalChain O a b) (r : ℝ) (i : ℕ) (hi : i < P.pieces) :
+    trackDirection (P.truncatedVertices r) i=P.truncatedScale r i • trackDirection P.vertices i := by
+  change P.truncatedVertices r (i+1)-P.truncatedVertices r i=_
+  rw [truncated_end_formula P r i hi,truncated_start_formula P r i hi]
+  apply Prod.ext <;> dsimp [trackDirection,truncatedScale] <;> ring
+
+theorem truncatedScale_pos (P : PolygonalChain O a b) (r : ℝ) (hr : 0 < r)
+    (hfirst : 4*r^2 < squaredLength (P.vertices 1-P.vertices 0))
+    (hlast : 4*r^2 < squaredLength (P.vertices P.pieces-P.vertices (P.pieces-1))) (i : ℕ) :
+    0 < P.truncatedScale r i := by
+  have hs := radialPort_parameter_half (P.vertices 0) (P.vertices 1) r hr hfirst
+  have he := radialPort_parameter_half (P.vertices (P.pieces-1)) (P.vertices P.pieces) r hr hlast
+  change 0 < P.startFraction r ∧ P.startFraction r < 1/2 at hs
+  change 0 < P.endFraction r ∧ P.endFraction r < 1/2 at he
+  unfold truncatedScale
+  split_ifs <;> linarith
+
+theorem truncated_direction_ne_zero (P : PolygonalChain O a b)
+    (hmin : ∀ Q : PolygonalChain O a b, P.pieces ≤ Q.pieces)
+    (r : ℝ) (hr : 0 < r)
+    (hfirst : 4*r^2 < squaredLength (P.vertices 1-P.vertices 0))
+    (hlast : 4*r^2 < squaredLength (P.vertices P.pieces-P.vertices (P.pieces-1)))
+    (i : ℕ) (hi : i < P.pieces) : trackDirection (P.truncatedVertices r) i ≠ 0 := by
+  rw [P.truncated_direction r i hi]
+  exact smul_ne_zero (ne_of_gt (P.truncatedScale_pos r hr hfirst hlast i)) (P.minimum_piece_ne_zero hmin i hi)
+
+end Zarankiewicz.PolygonalChain
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TruncatedChainPath.lean

@@ -0,0 +1,56 @@
+import OAI.Combinatorics.Crossing.TruncatedTrackAvoidance
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.PolygonalChain
+variable {O : Set Plane} {a b : Plane}
+
+def truncated (P : PolygonalChain O a b) (hp : 0 < P.pieces) (r : ℝ) (hr : 0 < r)
+    (hfirst : r^2 < squaredLength (P.vertices 1-P.vertices 0))
+    (hlast : r^2 < squaredLength (P.vertices P.pieces-P.vertices (P.pieces-1))) :
+    PolygonalChain O (P.startPort r) (P.endPort r) where
+  pieces := P.pieces
+  vertices := P.truncatedVertices r
+  first := P.truncatedVertices_first r
+  last := P.truncatedVertices_last hp r
+  start_mem := P.inside 0 hp (openSegmentTrace_subset_segment _ _ (radialPort_mem_openSegment _ _ r hr hfirst))
+  inside := fun i hi => (P.truncated_piece_subset r hr hfirst hlast i hi).trans (P.inside i hi)
+
+theorem truncated_segments_disjoint (P : PolygonalChain O a b)
+    (hmin : ∀ Q : PolygonalChain O a b, P.pieces ≤ Q.pieces)
+    (r : ℝ) (hr : 0 < r)
+    (hfirst : r^2 < squaredLength (P.vertices 1-P.vertices 0))
+    (hlast : r^2 < squaredLength (P.vertices P.pieces-P.vertices (P.pieces-1)))
+    (i j : ℕ) (hij : i+1 < j) (hj : j < P.pieces) :
+    Disjoint (segment ℝ (P.truncatedVertices r i) (P.truncatedVertices r (i+1)))
+      (segment ℝ (P.truncatedVertices r j) (P.truncatedVertices r (j+1))) :=
+  (P.minimum_nonadjacent_disjoint hmin i j hij hj).mono
+    (P.truncated_piece_subset r hr hfirst hlast i (by omega))
+    (P.truncated_piece_subset r hr hfirst hlast j hj)
+
+theorem truncated_path_injective (P : PolygonalChain O a b)
+    (hmin : ∀ Q : PolygonalChain O a b, P.pieces ≤ Q.pieces) (hp : 0 < P.pieces)
+    (r : ℝ) (hr : 0 < r)
+    (hfirst : 4*r^2 < squaredLength (P.vertices 1-P.vertices 0))
+    (hlast : 4*r^2 < squaredLength (P.vertices P.pieces-P.vertices (P.pieces-1))) :
+    Function.Injective (polygonalArcPath (P.truncatedVertices r) P.pieces) := by
+  have hs : r^2 < squaredLength (P.vertices 1-P.vertices 0) := by nlinarith [sq_nonneg r]
+  have ht : r^2 < squaredLength (P.vertices P.pieces-P.vertices (P.pieces-1)) := by nlinarith [sq_nonneg r]
+  apply polygonalArcPath_injective (P.truncatedVertices r) P.pieces hp
+  · intro i hi
+    exact Ne.symm (sub_ne_zero.mp (P.truncated_direction_ne_zero hmin r hr hfirst hlast i hi))
+  · intro i j hij hj x hx hy
+    by_cases he : j=i+1
+    · subst j
+      refine ⟨rfl,?_⟩
+      have hb := P.truncated_bend_ne_zero hmin r hr hfirst hlast (i+1) (by omega) hj
+      apply adjacent_segments_meet_only_at_bend _ _ _ ?_ hx hy
+      simpa only [trackDirection,Nat.add_sub_cancel] using hb
+    · exact False.elim (Set.disjoint_left.mp (P.truncated_segments_disjoint hmin r hr hs ht i j (by omega) hj) hx hy)
+
+end Zarankiewicz.PolygonalChain
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TruncatedChainVertices.lean

@@ -0,0 +1,72 @@
+import OAI.Combinatorics.Crossing.DrawingSpokePorts
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+
+theorem radialPort_parameter_half (a b : Plane) (r : ℝ) (hr : 0 < r)
+    (hshort : 4*r^2 < squaredLength (b-a)) :
+    0 < r/Real.sqrt (squaredLength (b-a)) ∧ r/Real.sqrt (squaredLength (b-a)) < 1/2 := by
+  have hL : 0 < squaredLength (b-a) := by nlinarith [sq_nonneg r]
+  have hs := Real.sqrt_pos.mpr hL
+  have hs2 := Real.sq_sqrt hL.le
+  exact ⟨div_pos hr hs,(div_lt_iff₀ hs).mpr (by nlinarith)⟩
+
+namespace PolygonalChain
+variable {O : Set Plane} {a b : Plane}
+
+def startFraction (P : PolygonalChain O a b) (r : ℝ) : ℝ :=
+  r/Real.sqrt (squaredLength (P.vertices 1-P.vertices 0))
+
+def endFraction (P : PolygonalChain O a b) (r : ℝ) : ℝ :=
+  r/Real.sqrt (squaredLength (P.vertices P.pieces-P.vertices (P.pieces-1)))
+
+def truncatedVertices (P : PolygonalChain O a b) (r : ℝ) (i : ℕ) : Plane :=
+  if i=0 then P.startPort r else if i=P.pieces then P.endPort r else P.vertices i
+
+theorem startPort_eq_fraction (P : PolygonalChain O a b) (r : ℝ) :
+    P.startPort r=P.vertices 0+P.startFraction r • (P.vertices 1-P.vertices 0) := rfl
+
+theorem endPort_eq_fraction (P : PolygonalChain O a b) (r : ℝ) :
+    P.endPort r=P.vertices P.pieces-P.endFraction r • (P.vertices P.pieces-P.vertices (P.pieces-1)) := by
+  unfold endPort radialPort endFraction
+  rw [squaredLength_sub_comm (P.vertices (P.pieces-1)) (P.vertices P.pieces)]
+  apply Prod.ext <;> dsimp <;> ring
+
+theorem truncatedVertices_first (P : PolygonalChain O a b) (r : ℝ) :
+    P.truncatedVertices r 0=P.startPort r := by simp [truncatedVertices]
+
+theorem truncatedVertices_last (P : PolygonalChain O a b) (hp : 0 < P.pieces) (r : ℝ) :
+    P.truncatedVertices r P.pieces=P.endPort r := by simp [truncatedVertices,ne_of_gt hp]
+
+theorem truncated_piece_subset (P : PolygonalChain O a b) (r : ℝ) (hr : 0 < r)
+    (hfirst : r^2 < squaredLength (P.vertices 1-P.vertices 0))
+    (hlast : r^2 < squaredLength (P.vertices P.pieces-P.vertices (P.pieces-1)))
+    (i : ℕ) (hi : i < P.pieces) :
+    segment ℝ (P.truncatedVertices r i) (P.truncatedVertices r (i+1)) ⊆
+      segment ℝ (P.vertices i) (P.vertices (i+1)) := by
+  apply (convex_segment (𝕜 := ℝ) _ _).segment_subset
+  · by_cases h0 : i=0
+    · subst i
+      rw [truncatedVertices_first]
+      exact openSegmentTrace_subset_segment _ _ (radialPort_mem_openSegment _ _ r hr hfirst)
+    · simp only [truncatedVertices,ite_eq_right h0,ite_eq_right (show i ≠ P.pieces by omega)]
+      exact left_mem_segment ℝ _ _
+  · by_cases hn : i+1=P.pieces
+    · rw [show P.truncatedVertices r (i+1)=P.endPort r by rw [hn]; exact P.truncatedVertices_last (by omega) r]
+      have hh : i=P.pieces-1 := by omega
+      have hs : r^2 < squaredLength (P.vertices (P.pieces-1)-P.vertices P.pieces) := by
+        rwa [squaredLength_sub_comm]
+      have hx := openSegmentTrace_reverse_mem _ _ _ (radialPort_mem_openSegment _ _ r hr hs)
+      have hseg := openSegmentTrace_subset_segment _ _ hx
+      simpa only [endPort,hh,show P.pieces-1+1=P.pieces by omega] using hseg
+    · simp only [truncatedVertices,ite_eq_right (show i+1 ≠ 0 by omega),ite_eq_right hn]
+      exact right_mem_segment ℝ _ _
+
+end PolygonalChain
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TruncatedCrossingCorners.lean

@@ -0,0 +1,41 @@
+import OAI.Combinatorics.Crossing.TruncatedDrawingInteriors
+import OAI.Combinatorics.Crossing.ReducedCrossingCorners
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+variable {m n : ℕ}
+
+theorem truncated_vertices_not_crossing (D : AdmissibleDrawing m n)
+    (hnorm : NoAdjacentCrossings D) (hstraight : LocallyStraightCrossings D)
+    (P : ∀ e : BipartiteEdge m n, PolygonalChain (Set.range (D.edge e))
+      (D.vertex (.inl e.1)) (D.vertex (.inr e.2)))
+    (hmin : ∀ e, ∀ Q : PolygonalChain (Set.range (D.edge e))
+      (D.vertex (.inl e.1)) (D.vertex (.inr e.2)), (P e).pieces ≤ Q.pieces)
+    (r : ℝ)
+    (hclear : ∀ j e (i : Fin (P e).pieces),
+      ¬ ((j=Sum.inl e.1 ∧ i.val=0) ∨ (j=Sum.inr e.2 ∧ i.val+1=(P e).pieces)) →
+      Disjoint (closedRoundDisk (D.vertex j) r) (segment ℝ ((P e).vertices i.val) ((P e).vertices (i.val+1))))
+    (e : BipartiteEdge m n) (i : ℕ) (hi : i ≤ (P e).pieces) :
+    (P e).truncatedVertices r i ∉ crossingPoints D.toContinuousDrawing := by
+  by_cases h0 : i=0
+  · subst i
+    rw [(P e).truncatedVertices_first]
+    intro hx
+    have hc := (drawing_chain_startPort_circle D.toContinuousDrawing e (P e) (hmin e) r).le
+    exact Set.disjoint_left.mp (vertex_disks_crossing_free D hnorm P r hclear (.inl e.1)) hc hx
+  by_cases hn : i=(P e).pieces
+  · subst i
+    rw [(P e).truncatedVertices_last (drawing_chain_pieces_pos D.toContinuousDrawing e (P e))]
+    intro hx
+    have hc := (drawing_chain_endPort_circle D.toContinuousDrawing e (P e) (hmin e) r).le
+    exact Set.disjoint_left.mp (vertex_disks_crossing_free D hnorm P r hclear (.inr e.2)) hc hx
+  · simp only [PolygonalChain.truncatedVertices,ite_eq_right h0,ite_eq_right hn]
+    exact minimum_vertices_not_crossing D hstraight e (P e) (hmin e) i hi
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TruncatedCrossingRetention.lean

@@ -0,0 +1,41 @@
+import OAI.Combinatorics.Crossing.VertexDisksCrossingFree
+import OAI.Combinatorics.Crossing.TruncatedTraceDecomposition
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+variable {m n : ℕ}
+
+theorem crossing_mem_truncated_edge (D : AdmissibleDrawing m n) (hnorm : NoAdjacentCrossings D)
+    (P : ∀ e : BipartiteEdge m n, PolygonalChain (Set.range (D.edge e))
+      (D.vertex (.inl e.1)) (D.vertex (.inr e.2)))
+    (hmin : ∀ e, ∀ Q : PolygonalChain (Set.range (D.edge e))
+      (D.vertex (.inl e.1)) (D.vertex (.inr e.2)), (P e).pieces ≤ Q.pieces)
+    (r : ℝ) (hr : 0 < r)
+    (hshort : ∀ e, r^2 < squaredLength ((P e).vertices 1-(P e).vertices 0) ∧
+      r^2 < squaredLength ((P e).vertices (P e).pieces-(P e).vertices ((P e).pieces-1)))
+    (hclear : ∀ j e (i : Fin (P e).pieces),
+      ¬ ((j=Sum.inl e.1 ∧ i.val=0) ∨ (j=Sum.inr e.2 ∧ i.val+1=(P e).pieces)) →
+      Disjoint (closedRoundDisk (D.vertex j) r) (segment ℝ ((P e).vertices i.val) ((P e).vertices (i.val+1))))
+    (e : BipartiteEdge m n) (x : Plane) (hx : x ∈ crossingPoints D.toContinuousDrawing)
+    (hxe : x ∈ edgeInterior D.toContinuousDrawing e) :
+    x ∈ Set.range (polygonalArcPath ((P e).truncatedVertices r) (P e).pieces) := by
+  have hh := edgeInterior_subset_range D.toContinuousDrawing e hxe
+  rw [drawing_edge_trace_decomposition D.toContinuousDrawing e (P e) r hr (hshort e).1 (hshort e).2] at hh
+  rcases hh with (hs | hm) | ht
+  · have hmem := center_segment_in_disk (D.vertex (.inl e.1)) ((P e).startPort r) r
+      (drawing_chain_startPort_circle D.toContinuousDrawing e (P e) (hmin e) r) hs
+    exact False.elim (Set.disjoint_left.mp (vertex_disks_crossing_free D hnorm P r hclear (.inl e.1)) hmem hx)
+  · exact hm
+  · have ht' : x ∈ segment ℝ (D.vertex (.inr e.2)) ((P e).endPort r) := by
+      simpa only [segment_symm ℝ ((P e).endPort r) (D.vertex (.inr e.2))] using ht
+    have hmem := center_segment_in_disk (D.vertex (.inr e.2)) ((P e).endPort r) r
+      (drawing_chain_endPort_circle D.toContinuousDrawing e (P e) (hmin e) r) ht'
+    exact False.elim (Set.disjoint_left.mp (vertex_disks_crossing_free D hnorm P r hclear (.inr e.2)) hmem hx)
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TruncatedDrawingDisks.lean

@@ -0,0 +1,71 @@
+import OAI.Combinatorics.Crossing.TruncatedRadialEnds
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+variable {m n : ℕ}
+
+theorem truncated_piece_vertex_disk_cases (D : ContinuousDrawing m n)
+    (P : ∀ e : BipartiteEdge m n, PolygonalChain (Set.range (D.edge e))
+      (D.vertex (.inl e.1)) (D.vertex (.inr e.2)))
+    (hmin : ∀ e, ∀ Q : PolygonalChain (Set.range (D.edge e))
+      (D.vertex (.inl e.1)) (D.vertex (.inr e.2)), (P e).pieces ≤ Q.pieces)
+    (r : ℝ) (hr : 0 < r)
+    (hshort : ∀ e, 4*r^2 < squaredLength ((P e).vertices 1-(P e).vertices 0) ∧
+      4*r^2 < squaredLength ((P e).vertices (P e).pieces-(P e).vertices ((P e).pieces-1)))
+    (hclear : ∀ j e (i : Fin (P e).pieces),
+      ¬ ((j=Sum.inl e.1 ∧ i.val=0) ∨ (j=Sum.inr e.2 ∧ i.val+1=(P e).pieces)) →
+      Disjoint (closedRoundDisk (D.vertex j) r) (segment ℝ ((P e).vertices i.val) ((P e).vertices (i.val+1))))
+    (j : BipartiteVertex m n) (e : BipartiteEdge m n) (i : Fin (P e).pieces) (x : Plane)
+    (hx : x ∈ segment ℝ ((P e).truncatedVertices r i.val) ((P e).truncatedVertices r (i.val+1))) :
+    (j=Sum.inl e.1 ∧ x=(P e).startPort r) ∨
+      (j=Sum.inr e.2 ∧ x=(P e).endPort r) ∨ r^2 < squaredLength (x-D.vertex j) := by
+  have hp := drawing_chain_pieces_pos D e (P e)
+  by_cases hfirst : j=Sum.inl e.1 ∧ i.val=0
+  · have hh := (P e).truncated_first_exterior (hmin e) hp r hr (hshort e).1 (hshort e).2
+      (by simpa only [hfirst.2] using hx)
+    rcases Set.mem_insert_iff.mp hh with he | he
+    · exact Or.inl ⟨hfirst.1,he⟩
+    · right; right
+      simpa only [Set.mem_ofPred_eq,(P e).first,hfirst.1] using he
+  by_cases hlast : j=Sum.inr e.2 ∧ i.val+1=(P e).pieces
+  · have hi : i.val=(P e).pieces-1 := by omega
+    have hh := (P e).truncated_last_exterior (hmin e) hp r hr (hshort e).1 (hshort e).2
+      (by simpa only [hi,show (P e).pieces-1+1=(P e).pieces by omega] using hx)
+    rcases Set.mem_insert_iff.mp hh with he | he
+    · exact Or.inr (Or.inl ⟨hlast.1,he⟩)
+    · right; right
+      simpa only [Set.mem_ofPred_eq,(P e).last,hlast.1] using he
+  · right; right
+    have hs : r^2 < squaredLength ((P e).vertices 1-(P e).vertices 0) := by nlinarith [(hshort e).1,sq_nonneg r]
+    have ht : r^2 < squaredLength ((P e).vertices (P e).pieces-(P e).vertices ((P e).pieces-1)) := by
+      nlinarith [(hshort e).2,sq_nonneg r]
+    have hxi := (P e).truncated_piece_subset r hr hs ht i.val i.isLt hx
+    by_contra h
+    exact Set.disjoint_left.mp (hclear j e i (fun h => h.elim hfirst hlast)) (le_of_not_gt h) hxi
+
+theorem truncated_path_vertex_disk_cases (D : ContinuousDrawing m n)
+    (P : ∀ e : BipartiteEdge m n, PolygonalChain (Set.range (D.edge e))
+      (D.vertex (.inl e.1)) (D.vertex (.inr e.2)))
+    (hmin : ∀ e, ∀ Q : PolygonalChain (Set.range (D.edge e))
+      (D.vertex (.inl e.1)) (D.vertex (.inr e.2)), (P e).pieces ≤ Q.pieces)
+    (r : ℝ) (hr : 0 < r)
+    (hshort : ∀ e, 4*r^2 < squaredLength ((P e).vertices 1-(P e).vertices 0) ∧
+      4*r^2 < squaredLength ((P e).vertices (P e).pieces-(P e).vertices ((P e).pieces-1)))
+    (hclear : ∀ j e (i : Fin (P e).pieces),
+      ¬ ((j=Sum.inl e.1 ∧ i.val=0) ∨ (j=Sum.inr e.2 ∧ i.val+1=(P e).pieces)) →
+      Disjoint (closedRoundDisk (D.vertex j) r) (segment ℝ ((P e).vertices i.val) ((P e).vertices (i.val+1))))
+    (j : BipartiteVertex m n) (e : BipartiteEdge m n) (x : Plane)
+    (hx : x ∈ Set.range (polygonalArcPath ((P e).truncatedVertices r) (P e).pieces)) :
+    (j=Sum.inl e.1 ∧ x=(P e).startPort r) ∨
+      (j=Sum.inr e.2 ∧ x=(P e).endPort r) ∨ r^2 < squaredLength (x-D.vertex j) := by
+  obtain ⟨i,hi,hxi⟩ := polygonalArcPath_range_piece ((P e).truncatedVertices r) (P e).pieces
+    (drawing_chain_pieces_pos D e (P e)) x hx
+  exact truncated_piece_vertex_disk_cases D P hmin r hr hshort hclear j e ⟨i,hi⟩ x hxi
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TruncatedDrawingInteriors.lean

@@ -0,0 +1,72 @@
+import OAI.Combinatorics.Crossing.TruncatedCrossingRetention
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+variable {m n : ℕ}
+
+theorem truncated_range_subset_edgeInterior (D : ContinuousDrawing m n)
+    (P : ∀ e : BipartiteEdge m n, PolygonalChain (Set.range (D.edge e))
+      (D.vertex (.inl e.1)) (D.vertex (.inr e.2)))
+    (hmin : ∀ e, ∀ Q : PolygonalChain (Set.range (D.edge e))
+      (D.vertex (.inl e.1)) (D.vertex (.inr e.2)), (P e).pieces ≤ Q.pieces)
+    (r : ℝ) (hr : 0 < r)
+    (hshort : ∀ e, 4*r^2 < squaredLength ((P e).vertices 1-(P e).vertices 0) ∧
+      4*r^2 < squaredLength ((P e).vertices (P e).pieces-(P e).vertices ((P e).pieces-1)))
+    (hclear : ∀ j e (i : Fin (P e).pieces),
+      ¬ ((j=Sum.inl e.1 ∧ i.val=0) ∨ (j=Sum.inr e.2 ∧ i.val+1=(P e).pieces)) →
+      Disjoint (closedRoundDisk (D.vertex j) r) (segment ℝ ((P e).vertices i.val) ((P e).vertices (i.val+1))))
+    (e : BipartiteEdge m n) :
+    Set.range (polygonalArcPath ((P e).truncatedVertices r) (P e).pieces) ⊆ edgeInterior D e := by
+  intro x hx
+  have hs : r^2 < squaredLength ((P e).vertices 1-(P e).vertices 0) := by nlinarith [(hshort e).1,sq_nonneg r]
+  have ht : r^2 < squaredLength ((P e).vertices (P e).pieces-(P e).vertices ((P e).pieces-1)) := by
+    nlinarith [(hshort e).2,sq_nonneg r]
+  apply edgeInterior_of_range_not_vertices D e x
+  · exact ((P e).truncated (drawing_chain_pieces_pos D e (P e)) r hr hs ht).path_range_subset hx
+  · intro j he
+    rcases truncated_path_vertex_disk_cases D P hmin r hr hshort hclear j e x hx with ⟨hj,hp⟩ | ⟨hj,hp⟩ | hout
+    · have hpi := drawing_chain_startPort_interior D e (P e) (hmin e) r hr hs
+      exact edgeInterior_not_vertex D e _ hpi j (hp.symm.trans he)
+    · have hpi := drawing_chain_endPort_interior D e (P e) (hmin e) r hr ht
+      exact edgeInterior_not_vertex D e _ hpi j (hp.symm.trans he)
+    · rw [he,sub_self] at hout
+      have hz : squaredLength (0 : Plane)=0 := by simp [squaredLength]
+      rw [hz] at hout
+      exact (sq_nonneg r).not_gt hout
+
+theorem truncated_edge_intersections_eq (D : AdmissibleDrawing m n) (hnorm : NoAdjacentCrossings D)
+    (P : ∀ e : BipartiteEdge m n, PolygonalChain (Set.range (D.edge e))
+      (D.vertex (.inl e.1)) (D.vertex (.inr e.2)))
+    (hmin : ∀ e, ∀ Q : PolygonalChain (Set.range (D.edge e))
+      (D.vertex (.inl e.1)) (D.vertex (.inr e.2)), (P e).pieces ≤ Q.pieces)
+    (r : ℝ) (hr : 0 < r)
+    (hshort : ∀ e, 4*r^2 < squaredLength ((P e).vertices 1-(P e).vertices 0) ∧
+      4*r^2 < squaredLength ((P e).vertices (P e).pieces-(P e).vertices ((P e).pieces-1)))
+    (hclear : ∀ j e (i : Fin (P e).pieces),
+      ¬ ((j=Sum.inl e.1 ∧ i.val=0) ∨ (j=Sum.inr e.2 ∧ i.val+1=(P e).pieces)) →
+      Disjoint (closedRoundDisk (D.vertex j) r) (segment ℝ ((P e).vertices i.val) ((P e).vertices (i.val+1))))
+    (e f : BipartiteEdge m n) (hef : e ≠ f) :
+    Set.range (polygonalArcPath ((P e).truncatedVertices r) (P e).pieces) ∩
+      Set.range (polygonalArcPath ((P f).truncatedVertices r) (P f).pieces) =
+      edgeInterior D.toContinuousDrawing e ∩ edgeInterior D.toContinuousDrawing f := by
+  have hweak (g : BipartiteEdge m n) :
+      r^2 < squaredLength ((P g).vertices 1-(P g).vertices 0) ∧
+      r^2 < squaredLength ((P g).vertices (P g).pieces-(P g).vertices ((P g).pieces-1)) := by
+    constructor <;> nlinarith [(hshort g).1,(hshort g).2,sq_nonneg r]
+  ext x
+  constructor
+  · rintro ⟨hx,hy⟩
+    exact ⟨truncated_range_subset_edgeInterior D.toContinuousDrawing P hmin r hr hshort hclear e hx,
+      truncated_range_subset_edgeInterior D.toContinuousDrawing P hmin r hr hshort hclear f hy⟩
+  · rintro ⟨hx,hy⟩
+    have hc : x ∈ crossingPoints D.toContinuousDrawing := ⟨e,f,hef,hx,hy⟩
+    exact ⟨crossing_mem_truncated_edge D hnorm P hmin r hr hweak hclear e x hc hx,
+      crossing_mem_truncated_edge D hnorm P hmin r hr hweak hclear f x hc hy⟩
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TruncatedRadialDots.lean

@@ -0,0 +1,73 @@
+import OAI.Combinatorics.Crossing.TrackEndpointConnections
+import OAI.Combinatorics.Crossing.NormalOffsetExterior
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+
+theorem dot2_scaled_self (v : Plane) (a b : ℝ) : dot2 (a • v) (b • v)=a*b*squaredLength v := by
+  dsimp [dot2,squaredLength]
+  ring
+
+namespace VertexTruncation
+variable {m n : ℕ} {D : ContinuousDrawing m n} (V : VertexTruncation D)
+
+theorem start_radial_dot_pos (e : BipartiteEdge m n) :
+    0 < dot2 (V.startPort e-D.vertex (Sum.inl e.1)) (trackDirection (V.vertices e) 0) := by
+  have hp := V.pieces_pos e
+  have hα := (radialPort_parameter_half ((V.chain e).vertices 0) ((V.chain e).vertices 1)
+    V.radius V.radius_pos (V.short e).1).1
+  have hβ := (V.chain e).truncatedScale_pos V.radius V.radius_pos (V.short e).1 (V.short e).2 0
+  have he : V.startPort e-D.vertex (Sum.inl e.1)=
+      (V.chain e).startFraction V.radius • trackDirection (V.chain e).vertices 0 := by
+    have hh := radialPort_sub ((V.chain e).vertices 0) ((V.chain e).vertices 1) V.radius
+    change (V.chain e).startPort V.radius-(V.chain e).vertices 0=
+      (V.chain e).startFraction V.radius • trackDirection (V.chain e).vertices 0 at hh
+    simpa only [startPort,(V.chain e).first] using hh
+  rw [he]
+  change 0 < dot2 _ (trackDirection ((V.chain e).truncatedVertices V.radius) 0)
+  rw [(V.chain e).truncated_direction V.radius 0 hp,dot2_scaled_self]
+  exact mul_pos (mul_pos hα hβ)
+    (squaredLength_pos _ ((V.chain e).minimum_piece_ne_zero (V.minimal e) 0 hp))
+
+theorem end_radial_dot_neg (e : BipartiteEdge m n) :
+    dot2 (V.endPort e-D.vertex (Sum.inr e.2))
+      (trackDirection (V.vertices e) (V.pieces e-1)) < 0 := by
+  have hp := V.pieces_pos e
+  have hp' : 0 < (V.chain e).pieces := hp
+  have hi : V.pieces e-1 < V.pieces e := by omega
+  have hα := (radialPort_parameter_half ((V.chain e).vertices ((V.chain e).pieces-1))
+    ((V.chain e).vertices (V.chain e).pieces) V.radius V.radius_pos (V.short e).2).1
+  have hβ := (V.chain e).truncatedScale_pos V.radius V.radius_pos (V.short e).1 (V.short e).2 (V.pieces e-1)
+  have he : V.endPort e-D.vertex (Sum.inr e.2)=
+      (-(V.chain e).endFraction V.radius) • trackDirection (V.chain e).vertices (V.pieces e-1) := by
+    have hh : (V.chain e).endPort V.radius-(V.chain e).vertices (V.chain e).pieces=
+        (-(V.chain e).endFraction V.radius) • trackDirection (V.chain e).vertices (V.pieces e-1) := by
+      rw [(V.chain e).endPort_eq_fraction]
+      simp only [trackDirection,pieces,show (V.chain e).pieces-1+1=(V.chain e).pieces by omega,neg_smul]
+      abel
+    simpa only [endPort,(V.chain e).last] using hh
+  rw [he]
+  change dot2 _ (trackDirection ((V.chain e).truncatedVertices V.radius) (V.pieces e-1)) < 0
+  rw [(V.chain e).truncated_direction V.radius _ hi,dot2_scaled_self]
+  exact mul_neg_of_neg_of_pos (mul_neg_of_neg_of_pos (neg_neg_of_pos hα) hβ)
+    (squaredLength_pos _ ((V.chain e).minimum_piece_ne_zero (V.minimal e) _ hi))
+
+theorem bend_ne_zero (e : BipartiteEdge m n) (i : ℕ) (hi0 : 0 < i) (hin : i < V.pieces e) :
+    det2 (trackDirection (V.vertices e) (i-1)) (trackDirection (V.vertices e) i) ≠ 0 := by
+  exact (V.chain e).truncated_bend_ne_zero (V.minimal e) V.radius V.radius_pos
+    (V.short e).1 (V.short e).2 i hi0 hin
+
+theorem exists_forward_radius (e : BipartiteEdge m n) :
+    ∃ δ : ℝ, 0<δ ∧ ∀ ε : ℝ, |ε|<δ → ∀ i : Fin (V.pieces e),
+      ∃ ℓ : ℝ, 0<ℓ ∧ shiftedTrack (V.vertices e) (V.pieces e) ε (i.val+1)-
+        shiftedTrack (V.vertices e) (V.pieces e) ε i.val=ℓ • trackDirection (V.vertices e) i.val :=
+  exists_forward_shiftedTrack_radius (V.vertices e) (V.pieces e) (V.direction_ne_zero e) (V.bend_ne_zero e)
+
+end VertexTruncation
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TruncatedRadialEnds.lean

@@ -0,0 +1,69 @@
+import OAI.Combinatorics.Crossing.TruncatedChainPath
+import OAI.Combinatorics.Crossing.RadialExterior
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+
+theorem radial_segment_of_coefficients (o p q v : Plane) (r α β : ℝ)
+    (hr : 0 < r) (hα : 0 < α) (hβ : 0 < β)
+    (hp : p-o=α • v) (hq : q-p=β • v) (hc : squaredLength (p-o)=r^2) :
+    segment ℝ p q ⊆ insert p {x | r^2 < squaredLength (x-o)} := by
+  have he : q=p+(β/α) • (p-o) := by
+    rw [hp,smul_smul,div_mul_cancel₀ _ (ne_of_gt hα)]
+    rw [← hq]
+    abel
+  rw [he]
+  exact radial_spur_exterior o p r (β/α) hc hr (div_pos hβ hα)
+
+namespace PolygonalChain
+variable {O : Set Plane} {a b : Plane}
+
+theorem truncated_first_exterior (P : PolygonalChain O a b)
+    (hmin : ∀ Q : PolygonalChain O a b, P.pieces ≤ Q.pieces) (hp : 0 < P.pieces)
+    (r : ℝ) (hr : 0 < r)
+    (hfirst : 4*r^2 < squaredLength (P.vertices 1-P.vertices 0))
+    (hlast : 4*r^2 < squaredLength (P.vertices P.pieces-P.vertices (P.pieces-1))) :
+    segment ℝ (P.truncatedVertices r 0) (P.truncatedVertices r 1) ⊆
+      insert (P.startPort r) {x | r^2 < squaredLength (x-P.vertices 0)} := by
+  have hα := (radialPort_parameter_half (P.vertices 0) (P.vertices 1) r hr hfirst).1
+  have hβ := P.truncatedScale_pos r hr hfirst hlast 0
+  rw [P.truncatedVertices_first]
+  apply radial_segment_of_coefficients (P.vertices 0) (P.startPort r) (P.truncatedVertices r 1)
+    (trackDirection P.vertices 0) r (P.startFraction r) (P.truncatedScale r 0) hr hα hβ
+  · exact radialPort_sub (P.vertices 0) (P.vertices 1) r
+  · simpa only [trackDirection,P.truncatedVertices_first] using P.truncated_direction r 0 hp
+  · exact radialPort_on_circle (P.vertices 0) (P.vertices 1)
+      (P.minimum_vertices_ne hmin 0 1 (by omega) hp) r
+
+theorem truncated_last_exterior (P : PolygonalChain O a b)
+    (hmin : ∀ Q : PolygonalChain O a b, P.pieces ≤ Q.pieces) (hp : 0 < P.pieces)
+    (r : ℝ) (hr : 0 < r)
+    (hfirst : 4*r^2 < squaredLength (P.vertices 1-P.vertices 0))
+    (hlast : 4*r^2 < squaredLength (P.vertices P.pieces-P.vertices (P.pieces-1))) :
+    segment ℝ (P.truncatedVertices r (P.pieces-1)) (P.truncatedVertices r P.pieces) ⊆
+      insert (P.endPort r) {x | r^2 < squaredLength (x-P.vertices P.pieces)} := by
+  have hi : P.pieces-1 < P.pieces := by omega
+  have hα := (radialPort_parameter_half (P.vertices (P.pieces-1)) (P.vertices P.pieces) r hr hlast).1
+  have hβ := P.truncatedScale_pos r hr hfirst hlast (P.pieces-1)
+  rw [P.truncatedVertices_last hp,segment_symm]
+  apply radial_segment_of_coefficients (P.vertices P.pieces) (P.endPort r)
+    (P.truncatedVertices r (P.pieces-1)) (-(trackDirection P.vertices (P.pieces-1)))
+    r (P.endFraction r) (P.truncatedScale r (P.pieces-1)) hr hα hβ
+  · rw [P.endPort_eq_fraction]
+    simp only [trackDirection,show P.pieces-1+1=P.pieces by omega,smul_neg]
+    abel
+  · have h := P.truncated_direction r (P.pieces-1) hi
+    simp only [trackDirection,show P.pieces-1+1=P.pieces by omega,P.truncatedVertices_last hp] at h ⊢
+    rw [smul_neg,← h]
+    abel
+  · have hn := Ne.symm (P.minimum_vertices_ne hmin (P.pieces-1) P.pieces hi (by omega))
+    exact radialPort_on_circle (P.vertices P.pieces) (P.vertices (P.pieces-1)) hn r
+
+end PolygonalChain
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TruncatedSegmentTransversality.lean

@@ -0,0 +1,76 @@
+import OAI.Combinatorics.Crossing.TruncatedCrossingCorners
+import OAI.Combinatorics.Crossing.ReducedCrossingTransversality
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+
+theorem segment_parameter_strict_of_avoids_endpoints (a b x : Plane) (S : Set Plane)
+    (hx : x ∈ S) (ha : a ∉ S) (hb : b ∉ S) (t : ℝ) (ht : t ∈ Set.Icc (0 : ℝ) 1)
+    (he : segmentPoint a b t=x) : t ∈ Set.Ioo (0 : ℝ) 1 := by
+  have ht0 : t ≠ 0 := by
+    intro h
+    rw [h,segmentPoint_zero] at he
+    exact ha (he.symm ▸ hx)
+  have ht1 : t ≠ 1 := by
+    intro h
+    rw [h,segmentPoint_one] at he
+    exact hb (he.symm ▸ hx)
+  exact ⟨lt_of_le_of_ne ht.1 ht0.symm,lt_of_le_of_ne ht.2 ht1⟩
+
+theorem truncated_segment_pair_transverse {m n : ℕ} (D : AdmissibleDrawing m n)
+    (hnorm : NoAdjacentCrossings D) (hstraight : LocallyStraightCrossings D)
+    (htrans : LocallyTransverseCrossings D)
+    (P : ∀ e : BipartiteEdge m n, PolygonalChain (Set.range (D.edge e))
+      (D.vertex (.inl e.1)) (D.vertex (.inr e.2)))
+    (hmin : ∀ e, ∀ Q : PolygonalChain (Set.range (D.edge e))
+      (D.vertex (.inl e.1)) (D.vertex (.inr e.2)), (P e).pieces ≤ Q.pieces)
+    (r : ℝ) (hr : 0 < r)
+    (hshort : ∀ e, 4*r^2 < squaredLength ((P e).vertices 1-(P e).vertices 0) ∧
+      4*r^2 < squaredLength ((P e).vertices (P e).pieces-(P e).vertices ((P e).pieces-1)))
+    (hclear : ∀ j e (i : Fin (P e).pieces),
+      ¬ ((j=Sum.inl e.1 ∧ i.val=0) ∨ (j=Sum.inr e.2 ∧ i.val+1=(P e).pieces)) →
+      Disjoint (closedRoundDisk (D.vertex j) r) (segment ℝ ((P e).vertices i.val) ((P e).vertices (i.val+1))))
+    (e f : BipartiteEdge m n) (hef : e ≠ f) (i : Fin (P e).pieces) (j : Fin (P f).pieces) :
+    SegmentPairTransverse ((P e).truncatedVertices r i.val) ((P e).truncatedVertices r (i.val+1))
+      ((P f).truncatedVertices r j.val) ((P f).truncatedVertices r (j.val+1)) := by
+  intro s hs t ht he
+  let x := segmentPoint ((P e).truncatedVertices r i.val) ((P e).truncatedVertices r (i.val+1)) s
+  have hxe : x ∈ segment ℝ ((P e).truncatedVertices r i.val) ((P e).truncatedVertices r (i.val+1)) := by
+    rw [← Path.range_segment]
+    exact ⟨⟨s,hs⟩,by simp only [Path.segment_apply,AffineMap.lineMap_apply_module,segmentPoint,x]⟩
+  have hxf : x ∈ segment ℝ ((P f).truncatedVertices r j.val) ((P f).truncatedVertices r (j.val+1)) := by
+    rw [← Path.range_segment]
+    refine ⟨⟨t,ht⟩,?_⟩
+    simpa only [Path.segment_apply,AffineMap.lineMap_apply_module,x,segmentPoint] using he.symm
+  have hie := truncated_range_subset_edgeInterior D.toContinuousDrawing P hmin r hr hshort hclear e
+    (polygonalArcPath_piece_subset_range _ _ i.val i.isLt hxe)
+  have hif := truncated_range_subset_edgeInterior D.toContinuousDrawing P hmin r hr hshort hclear f
+    (polygonalArcPath_piece_subset_range _ _ j.val j.isLt hxf)
+  have hcross : x ∈ crossingPoints D.toContinuousDrawing := ⟨e,f,hef,hie,hif⟩
+  have hcorner := truncated_vertices_not_crossing D hnorm hstraight P hmin r hclear
+  have hsi := segment_parameter_strict_of_avoids_endpoints _ _ x _ hcross
+    (hcorner e i.val (by omega)) (hcorner e (i.val+1) (by omega)) s hs rfl
+  have hti := segment_parameter_strict_of_avoids_endpoints _ _ x _ hcross
+    (hcorner f j.val (by omega)) (hcorner f (j.val+1) (by omega)) t ht he.symm
+  refine ⟨?_,hsi,hti⟩
+  have hweak (g : BipartiteEdge m n) :
+      r^2 < squaredLength ((P g).vertices 1-(P g).vertices 0) ∧
+      r^2 < squaredLength ((P g).vertices (P g).pieces-(P g).vertices ((P g).pieces-1)) := by
+    constructor <;> nlinarith [(hshort g).1,(hshort g).2,sq_nonneg r]
+  have hde := minimum_piece_det_at_crossing D hstraight htrans e f hef (P e) (P f) (hmin e) (hmin f)
+    i.val j.val i.isLt j.isLt x hie hif
+    ((P e).truncated_piece_subset r hr (hweak e).1 (hweak e).2 i.val i.isLt hxe)
+    ((P f).truncated_piece_subset r hr (hweak f).1 (hweak f).2 j.val j.isLt hxf)
+  change det2 (trackDirection ((P e).truncatedVertices r) i.val) (trackDirection ((P f).truncatedVertices r) j.val) ≠ 0
+  rw [(P e).truncated_direction r i.val i.isLt,(P f).truncated_direction r j.val j.isLt,
+    det2_smul_left,det2_smul_right]
+  exact mul_ne_zero (ne_of_gt ((P e).truncatedScale_pos r hr (hshort e).1 (hshort e).2 i.val))
+    (mul_ne_zero (ne_of_gt ((P f).truncatedScale_pos r hr (hshort f).1 (hshort f).2 j.val)) hde)
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TruncatedSignedIntersections.lean

@@ -0,0 +1,80 @@
+import OAI.Combinatorics.Crossing.UniformTrackPerturbation
+import OAI.Combinatorics.Crossing.RowCrossingCount
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.VertexTruncation
+open scoped BigOperators
+variable {m n : ℕ} {D : ContinuousDrawing m n} (V : VertexTruncation D)
+
+theorem piece_subset_range (e : BipartiteEdge m n) (i : ℕ) (hi : i<V.pieces e) :
+    segment ℝ (V.vertices e i) (V.vertices e (i+1)) ⊆ Set.range (V.path e) := by
+  exact ((V.chain e).truncated (V.pieces_pos e) V.radius V.radius_pos
+    (V.weak_short e).1 (V.weak_short e).2).piece_subset_path_range i hi
+
+def signedIntersection (e f : BipartiteEdge m n) : ℝ :=
+  if e=f then 0 else polygonIntersection (V.vertices e) (V.vertices f) (V.pieces e) (V.pieces f)
+
+theorem signedIntersection_self (e : BipartiteEdge m n) : V.signedIntersection e e=0 := by
+  simp [signedIntersection]
+
+theorem signedIntersection_swap (e f : BipartiteEdge m n) : V.signedIntersection f e = -V.signedIntersection e f := by
+  by_cases h : e=f
+  · subst f
+    simp [V.signedIntersection_self]
+  · simp only [signedIntersection,ite_eq_right h,ite_eq_right (Ne.symm h)]
+    exact polygonIntersection_swap _ _ _ _
+
+theorem signedIntersection_zero_of_pairCrossings_empty {A : AdmissibleDrawing m n}
+    (V : VertexTruncation A.toContinuousDrawing) (e f : BipartiteEdge m n)
+    (hempty : pairCrossings A e f=∅) : V.signedIntersection e f=0 := by
+  classical
+  by_cases hef : e=f
+  · subst f
+    exact V.signedIntersection_self e
+  · rw [signedIntersection,ite_eq_right hef]
+    unfold polygonIntersection
+    apply Finset.sum_eq_zero
+    intro i hi
+    apply Finset.sum_eq_zero
+    intro j hj
+    have hnot : ¬ SegmentsCrossProperly (V.vertices e i) (V.vertices e (i+1))
+        (V.vertices f j) (V.vertices f (j+1)) := by
+      rintro ⟨_,s,hs,t,ht,he⟩
+      let x := segmentPoint (V.vertices e i) (V.vertices e (i+1)) s
+      have hxe : x ∈ edgeInterior A.toContinuousDrawing e := by
+        apply V.range_subset_edgeInterior e
+        apply V.piece_subset_range e i (Finset.mem_range.mp hi)
+        rw [← Path.range_segment]
+        exact ⟨⟨s,⟨hs.1.le,hs.2.le⟩⟩,by simp only [Path.segment_apply,AffineMap.lineMap_apply_module,x,segmentPoint]⟩
+      have hxf : x ∈ edgeInterior A.toContinuousDrawing f := by
+        apply V.range_subset_edgeInterior f
+        apply V.piece_subset_range f j (Finset.mem_range.mp hj)
+        rw [← Path.range_segment]
+        refine ⟨⟨t,⟨ht.1.le,ht.2.le⟩⟩,?_⟩
+        simpa only [Path.segment_apply,AffineMap.lineMap_apply_module,x,segmentPoint] using he.symm
+      have hx : x ∈ pairCrossings A e f := by
+        apply Finset.mem_filter.mpr
+        exact ⟨by simpa using (show x ∈ crossingPoints A.toContinuousDrawing from ⟨e,f,hef,hxe,hxf⟩),hef,hxe,hxf⟩
+      rw [hempty] at hx
+      exact Finset.notMem_empty x hx
+    simp [segmentCrossingSign,hnot]
+
+theorem pairCrossings_pos_of_signedIntersection_ne_zero {A : AdmissibleDrawing m n}
+    (V : VertexTruncation A.toContinuousDrawing) (e f : BipartiteEdge m n)
+    (h : V.signedIntersection e f ≠ 0) : 0 < (pairCrossings A e f).card := by
+  by_contra hh
+  have hz : (pairCrossings A e f).card=0 := by omega
+  exact h (V.signedIntersection_zero_of_pairCrossings_empty e f (Finset.card_eq_zero.mp hz))
+
+theorem signedIntersection_adjacent_zero {A : AdmissibleDrawing m n}
+    (V : VertexTruncation A.toContinuousDrawing) (hnorm : NoAdjacentCrossings A)
+    (e f : BipartiteEdge m n) (hadj : e.1=f.1 ∨ e.2=f.2) : V.signedIntersection e f=0 :=
+  V.signedIntersection_zero_of_pairCrossings_empty e f (pairCrossings_eq_empty_of_adjacent A hnorm e f hadj)
+
+end Zarankiewicz.VertexTruncation
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TruncatedSpokeCoordinates.lean

@@ -0,0 +1,88 @@
+import OAI.Combinatorics.Crossing.TruncatedSpokeDirections
+import OAI.Combinatorics.Crossing.TangentTrackIdentity
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+variable {m n : ℕ} {D : ContinuousDrawing m n}
+
+structure TruncatedSpokeCoordinates (V : VertexTruncation D) where
+  frame : BipartiteVertex m n → Plane
+  frame_ne_zero : ∀ j, frame j ≠ 0
+  frame_length : ∀ j, squaredLength (frame j)=V.radius^2
+  node : ∀ j, IncidentEdges j → ℝ
+  node_injective : ∀ j, Function.Injective (node j)
+  point_eq : ∀ j e, similarityPoint (D.vertex j) (frame j) (circlePoint (node j e))=V.spokePort j e
+
+theorem nonempty_truncatedSpokeCoordinates {A : AdmissibleDrawing m n}
+    (V : VertexTruncation A.toContinuousDrawing) (hnorm : NoAdjacentCrossings A) :
+    Nonempty (TruncatedSpokeCoordinates V) := by
+  have hex (j : BipartiteVertex m n) := exists_finite_circle_coordinates
+    (A.vertex j) V.radius V.radius_pos (V.spokePort j)
+    (V.spokePort_injective hnorm j) (V.spokePort_circle j)
+  choose u hu hlen node hnode hpoint using hex
+  exact ⟨⟨u,hu,hlen,node,hnode,hpoint⟩⟩
+
+namespace TruncatedSpokeCoordinates
+variable {V : VertexTruncation D} (C : TruncatedSpokeCoordinates V)
+
+def shiftedPort (j : BipartiteVertex m n) (e : IncidentEdges j) (ε : ℝ) : Plane :=
+  similarityPoint (D.vertex j) (C.frame j)
+    (circleOffset (circlePoint (C.node j e)) (V.spokeScale j e*ε))
+
+def tangentPort (_C : TruncatedSpokeCoordinates V) (j : BipartiteVertex m n) (e : IncidentEdges j) (ε : ℝ) : Plane :=
+  V.spokePort j e+ε • normalShift (V.spokeDirection j e)
+
+theorem tangentPort_eq (j : BipartiteVertex m n) (e : IncidentEdges j) (ε : ℝ) :
+    C.tangentPort j e ε = similarityPoint (D.vertex j) (C.frame j)
+      (circleTangentOffset (circlePoint (C.node j e)) (V.spokeScale j e*ε)) := by
+  have hh := tangentOffset_eq_normalShift (D.vertex j) (C.frame j) (circlePoint (C.node j e))
+    (V.spokeDirection j e) (V.spokeDirection_ne_zero j e)
+    (by simpa only [C.point_eq] using V.spokePort_ne_center j e)
+    (by simpa only [C.point_eq] using V.spokeDirection_parallel j e) ε
+  simpa only [C.point_eq,VertexTruncation.spokeScale,tangentPort] using hh.symm
+
+theorem shiftedPort_level (j : BipartiteVertex m n) (e : IncidentEdges j) (ε : ℝ) :
+    det2 (V.spokeDirection j e) (C.shiftedPort j e ε-V.spokePort j e)=ε := by
+  have hh := circleOffset_track_level (D.vertex j) (C.frame j) (circlePoint (C.node j e))
+    (V.spokeDirection j e) (V.spokeDirection_ne_zero j e)
+    (by simpa only [C.point_eq] using V.spokePort_ne_center j e)
+    (by simpa only [C.point_eq] using V.spokeDirection_parallel j e) ε
+  simpa only [C.point_eq,VertexTruncation.spokeScale,shiftedPort] using hh
+
+theorem shiftedPort_circle (j : BipartiteVertex m n) (e : IncidentEdges j) (ε : ℝ)
+    (hε : |V.spokeScale j e*ε| ≤ 1) :
+    squaredLength (C.shiftedPort j e ε-D.vertex j)=V.radius^2 := by
+  unfold shiftedPort
+  rw [similarityPoint_squaredLength,circleOffset_on_circle _ (circlePoint_on_unit_circle _) _ hε,
+    mul_one,C.frame_length]
+
+theorem connector_strictly_outside (j : BipartiteVertex m n) (e : IncidentEdges j) (ε : ℝ)
+    (hε : |V.spokeScale j e*ε| < 1) (hne : ε ≠ 0) (t : ℝ) (ht : 0<t) :
+    V.radius^2 < squaredLength (segmentPoint (C.shiftedPort j e ε) (C.tangentPort j e ε) t-D.vertex j) := by
+  rw [C.tangentPort_eq]
+  have hh := physical_circleConnector_strictly_outside (D.vertex j) (C.frame j)
+    (circlePoint (C.node j e)) (C.frame_ne_zero j) (circlePoint_on_unit_circle _)
+    (V.spokeScale j e*ε) hε (mul_ne_zero (V.spokeScale_ne_zero j e) hne) t ht
+  simpa only [C.frame_length,shiftedPort] using hh
+
+theorem exists_vertex_average_radius (j : BipartiteVertex m n) :
+    ∃ δ : ℝ, 0 < δ ∧ ∀ t : ℝ, 0 < t → t < δ → ∀ a b c d : IncidentEdges j,
+      a ≠ b → c ≠ d →
+      (segmentCrossingSign (V.spokePort j a) (V.spokePort j b) (C.shiftedPort j c t) (C.shiftedPort j d t)+
+        segmentCrossingSign (V.spokePort j a) (V.spokePort j b) (C.shiftedPort j c (-t)) (C.shiftedPort j d (-t)))/2 =
+      chordEndpointPairing (C.node j a) (C.node j b) (C.node j c) (C.node j d) := by
+  classical
+  obtain ⟨δ,hδ,hh⟩ := physical_spoke_average_in_similarity (D.vertex j) (C.frame j) (C.frame_ne_zero j)
+    (C.node j) (V.spokeScale j) (C.node_injective j) (V.spokeScale_ne_zero j)
+  refine ⟨δ,hδ,?_⟩
+  intro t ht hsmall a b c d hab hcd
+  simpa only [C.point_eq,shiftedPort] using hh t ht hsmall a b c d hab hcd
+
+end TruncatedSpokeCoordinates
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TruncatedSpokeDirections.lean

@@ -0,0 +1,75 @@
+import OAI.Combinatorics.Crossing.VertexTruncationGeometry
+import OAI.Combinatorics.Crossing.SpokeTrackDirections
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.VertexTruncation
+variable {m n : ℕ} {D : ContinuousDrawing m n} (V : VertexTruncation D)
+
+def spokePort (j : BipartiteVertex m n) (e : IncidentEdges j) : Plane :=
+  drawingSpokePort D V.chain V.radius j e
+
+def spokeIndex (j : BipartiteVertex m n) (e : IncidentEdges j) : ℕ :=
+  if j=Sum.inl e.val.1 then 0 else V.pieces e.val-1
+
+def spokeDirection (j : BipartiteVertex m n) (e : IncidentEdges j) : Plane :=
+  trackDirection (V.vertices e.val) (V.spokeIndex j e)
+
+theorem spokeIndex_lt (j : BipartiteVertex m n) (e : IncidentEdges j) :
+    V.spokeIndex j e < V.pieces e.val := by
+  have hp := V.pieces_pos e.val
+  unfold spokeIndex
+  split_ifs <;> omega
+
+theorem spokeDirection_ne_zero (j : BipartiteVertex m n) (e : IncidentEdges j) :
+    V.spokeDirection j e ≠ 0 := V.direction_ne_zero e.val _ (V.spokeIndex_lt j e)
+
+theorem spokeDirection_eq_scale (j : BipartiteVertex m n) (e : IncidentEdges j) :
+    V.spokeDirection j e =
+      (V.chain e.val).truncatedScale V.radius (V.spokeIndex j e) •
+        drawingSpokeDirection D V.chain j e := by
+  change trackDirection ((V.chain e.val).truncatedVertices V.radius) (V.spokeIndex j e)=_
+  rw [(V.chain e.val).truncated_direction V.radius _ (V.spokeIndex_lt j e)]
+  congr 1
+  unfold spokeIndex drawingSpokeDirection
+  split_ifs <;> rfl
+
+theorem spokePort_circle (j : BipartiteVertex m n) (e : IncidentEdges j) :
+    squaredLength (V.spokePort j e-D.vertex j)=V.radius^2 :=
+  drawingSpokePort_circle D V.chain V.minimal V.radius j e
+
+theorem spokePort_ne_center (j : BipartiteVertex m n) (e : IncidentEdges j) :
+    V.spokePort j e-D.vertex j ≠ 0 := by
+  intro h
+  have hc := V.spokePort_circle j e
+  rw [h] at hc
+  have hz : squaredLength (0 : Plane)=0 := by simp [squaredLength]
+  rw [hz] at hc
+  nlinarith [V.radius_pos]
+
+theorem spokeDirection_parallel (j : BipartiteVertex m n) (e : IncidentEdges j) :
+    det2 (V.spokeDirection j e) (V.spokePort j e-D.vertex j)=0 := by
+  rw [V.spokeDirection_eq_scale,det2_smul_left]
+  have hp := drawingSpokeDirection_port_parallel D V.chain V.radius j e (V.pieces_pos e.val)
+  change det2 (drawingSpokeDirection D V.chain j e) (V.spokePort j e-D.vertex j)=0 at hp
+  rw [hp,mul_zero]
+
+def spokeScale (j : BipartiteVertex m n) (e : IncidentEdges j) : ℝ :=
+  circleTrackScale (V.spokeDirection j e) (V.spokePort j e-D.vertex j)
+
+theorem spokeScale_ne_zero (j : BipartiteVertex m n) (e : IncidentEdges j) :
+    V.spokeScale j e ≠ 0 :=
+  circleTrackScale_ne_zero _ _ (V.spokeDirection_ne_zero j e)
+    (V.spokePort_ne_center j e) (V.spokeDirection_parallel j e)
+
+theorem spokePort_injective {A : AdmissibleDrawing m n}
+    (V : VertexTruncation A.toContinuousDrawing) (hnorm : NoAdjacentCrossings A)
+    (j : BipartiteVertex m n) : Function.Injective (V.spokePort j) :=
+  drawingSpokePort_injective A hnorm V.chain V.minimal V.radius V.radius_pos V.weak_short j
+
+end Zarankiewicz.VertexTruncation
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TruncatedTraceDecomposition.lean

@@ -0,0 +1,67 @@
+import OAI.Combinatorics.Crossing.TruncatedChainPath
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+
+theorem center_segment_in_disk (o p : Plane) (r : ℝ) (hp : squaredLength (p-o)=r^2) :
+    segment ℝ o p ⊆ closedRoundDisk o r := by
+  intro x hx
+  rw [← Path.range_segment] at hx
+  obtain ⟨t,ht⟩ := hx
+  have he : squaredLength (segmentPoint o p t.val-o)=t.val^2*squaredLength (p-o) := by
+    dsimp [segmentPoint,squaredLength]
+    ring
+  have ht2 : t.val^2 ≤ 1 := by nlinarith [t.property.1,t.property.2]
+  have hh := mul_le_mul_of_nonneg_right ht2 (sq_nonneg r)
+  change squaredLength (x-o) ≤ r^2
+  have ht' : segmentPoint o p t.val=x := by
+    simpa only [Path.segment_apply,AffineMap.lineMap_apply_module,segmentPoint] using ht
+  rw [← ht',he,hp]
+  simpa only [one_mul] using hh
+
+theorem drawing_edge_trace_decomposition {m n : ℕ} (D : ContinuousDrawing m n)
+    (e : BipartiteEdge m n)
+    (P : PolygonalChain (Set.range (D.edge e)) (D.vertex (.inl e.1)) (D.vertex (.inr e.2)))
+    (r : ℝ) (hr : 0 < r)
+    (hfirst : r^2 < squaredLength (P.vertices 1-P.vertices 0))
+    (hlast : r^2 < squaredLength (P.vertices P.pieces-P.vertices (P.pieces-1))) :
+    Set.range (D.edge e)=
+      segment ℝ (D.vertex (.inl e.1)) (P.startPort r) ∪
+        Set.range (polygonalArcPath (P.truncatedVertices r) P.pieces) ∪
+        segment ℝ (P.endPort r) (D.vertex (.inr e.2)) := by
+  have hp := drawing_chain_pieces_pos D e P
+  have hs : segment ℝ (D.vertex (.inl e.1)) (P.startPort r) ⊆ Set.range (D.edge e) := by
+    have hx := openSegmentTrace_subset_segment _ _ (radialPort_mem_openSegment (P.vertices 0) (P.vertices 1) r hr hfirst)
+    have hh := ((convex_segment (𝕜 := ℝ) _ _).segment_subset (left_mem_segment ℝ _ _) hx).trans (P.inside 0 hp)
+    simpa only [PolygonalChain.startPort,P.first] using hh
+  have ht : segment ℝ (P.endPort r) (D.vertex (.inr e.2)) ⊆ Set.range (D.edge e) := by
+    have hlen : r^2 < squaredLength (P.vertices (P.pieces-1)-P.vertices P.pieces) := by
+      rwa [squaredLength_sub_comm]
+    have hx := openSegmentTrace_subset_segment _ _
+      (openSegmentTrace_reverse_mem _ _ _ (radialPort_mem_openSegment _ _ r hr hlen))
+    have hinside := P.inside (P.pieces-1) (by omega)
+    rw [show P.pieces-1+1=P.pieces by omega] at hinside
+    have hh := ((convex_segment (𝕜 := ℝ) _ _).segment_subset hx (right_mem_segment ℝ _ _)).trans hinside
+    simpa only [PolygonalChain.endPort,P.last] using hh
+  let T := P.truncated hp r hr hfirst hlast
+  let G := ((Path.segment (D.vertex (.inl e.1)) (P.startPort r)).trans T.path).trans
+    (Path.segment (P.endPort r) (D.vertex (.inr e.2)))
+  have hG : Set.range G ⊆ Set.range (D.edge e) := by
+    dsimp [G]
+    rw [Path.trans_range,Path.trans_range,Path.range_segment,Path.range_segment]
+    exact Set.union_subset (Set.union_subset hs T.path_range_subset) ht
+  have he := path_range_eq_of_subset (D.edge e) G (D.edge_injective e) hG
+  calc
+    Set.range (D.edge e) = Set.range G := he.symm
+    _ = _ := by
+      dsimp [G]
+      rw [Path.trans_range,Path.trans_range,Path.range_segment,Path.range_segment]
+      rfl
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TruncatedTrackAvoidance.lean

@@ -0,0 +1,52 @@
+import OAI.Combinatorics.Crossing.TruncatedChainDirections
+import OAI.Combinatorics.Crossing.SegmentClosedIncidence
+import OAI.Combinatorics.Crossing.SharedTrackAvoidance
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.PolygonalChain
+variable {O : Set Plane} {a b : Plane}
+
+theorem truncated_bend_ne_zero (P : PolygonalChain O a b)
+    (hmin : ∀ Q : PolygonalChain O a b, P.pieces ≤ Q.pieces)
+    (r : ℝ) (hr : 0 < r)
+    (hfirst : 4*r^2 < squaredLength (P.vertices 1-P.vertices 0))
+    (hlast : 4*r^2 < squaredLength (P.vertices P.pieces-P.vertices (P.pieces-1)))
+    (i : ℕ) (hi : 0 < i) (hi' : i < P.pieces) :
+    det2 (trackDirection (P.truncatedVertices r) (i-1)) (trackDirection (P.truncatedVertices r) i) ≠ 0 := by
+  rw [P.truncated_direction r (i-1) (by omega),P.truncated_direction r i hi',det2_smul_left,det2_smul_right]
+  apply mul_ne_zero (ne_of_gt (P.truncatedScale_pos r hr hfirst hlast (i-1)))
+  apply mul_ne_zero (ne_of_gt (P.truncatedScale_pos r hr hfirst hlast i))
+  have h := P.minimum_bend_det_ne_zero hmin (i-1) (by omega)
+  simpa only [trackDirection,show i-1+1=i by omega,show i-1+2=i+1 by omega] using h
+
+theorem truncated_offset_avoidance (P : PolygonalChain O a b)
+    (hmin : ∀ Q : PolygonalChain O a b, P.pieces ≤ Q.pieces)
+    (r : ℝ) (hr : 0 < r)
+    (hfirst : 4*r^2 < squaredLength (P.vertices 1-P.vertices 0))
+    (hlast : 4*r^2 < squaredLength (P.vertices P.pieces-P.vertices (P.pieces-1))) :
+    ∃ δ : ℝ, 0 < δ ∧ ∀ t : ℝ, t ≠ 0 → |t| < δ → ∀ i j : Fin P.pieces,
+      ¬ ClosedSegmentsMeet (P.truncatedVertices r i.val) (P.truncatedVertices r (i.val+1))
+        (shiftedTrack (P.truncatedVertices r) P.pieces t j.val)
+        (shiftedTrack (P.truncatedVertices r) P.pieces t (j.val+1)) := by
+  apply exists_shared_track_avoidance_radius (P.truncatedVertices r) P.pieces
+    (P.truncated_direction_ne_zero hmin r hr hfirst hlast)
+    (P.truncated_bend_ne_zero hmin r hr hfirst hlast)
+  intro i j hij
+  have hdis : Disjoint (segment ℝ (P.vertices i.val) (P.vertices (i.val+1)))
+      (segment ℝ (P.vertices j.val) (P.vertices (j.val+1))) := by
+    rcases hij with h | h
+    · exact P.minimum_nonadjacent_disjoint hmin i.val j.val h j.isLt
+    · exact (P.minimum_nonadjacent_disjoint hmin j.val i.val h i.isLt).symm
+  have hfst : r^2 < squaredLength (P.vertices 1-P.vertices 0) := by nlinarith [sq_nonneg r]
+  have hlst : r^2 < squaredLength (P.vertices P.pieces-P.vertices (P.pieces-1)) := by nlinarith [sq_nonneg r]
+  exact not_closedSegmentsMeet_of_disjoint _ _ _ _ (hdis.mono
+    (P.truncated_piece_subset r hr hfst hlst i.val i.isLt)
+    (P.truncated_piece_subset r hr hfst hlst j.val j.isLt))
+
+end Zarankiewicz.PolygonalChain
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TruncatedTrackStability.lean

@@ -0,0 +1,41 @@
+import OAI.Combinatorics.Crossing.VertexTruncationGeometry
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.VertexTruncation
+variable {m n : ℕ} {D : AdmissibleDrawing m n}
+
+theorem exists_distinct_edge_shift_radius (V : VertexTruncation D.toContinuousDrawing)
+    (hnorm : NoAdjacentCrossings D) (hstraight : LocallyStraightCrossings D) (htrans : LocallyTransverseCrossings D) :
+    ∃ δ : ℝ, 0 < δ ∧ ∀ t : ℝ, |t| < δ → ∀ e f : BipartiteEdge m n, e ≠ f →
+      ∀ i : Fin (V.pieces e), ∀ j : Fin (V.pieces f),
+        SegmentPairTransverse (V.vertices e i.val) (V.vertices e (i.val+1))
+          (shiftedTrack (V.vertices f) (V.pieces f) t j.val)
+          (shiftedTrack (V.vertices f) (V.pieces f) t (j.val+1)) ∧
+        segmentCrossingSign (V.vertices e i.val) (V.vertices e (i.val+1))
+          (shiftedTrack (V.vertices f) (V.pieces f) t j.val)
+          (shiftedTrack (V.vertices f) (V.pieces f) t (j.val+1)) =
+          segmentCrossingSign (V.vertices e i.val) (V.vertices e (i.val+1))
+            (V.vertices f j.val) (V.vertices f (j.val+1)) := by
+  classical
+  let Pair := Σ e : BipartiteEdge m n, Σ f : {f : BipartiteEdge m n // e ≠ f},
+    Fin (V.pieces e) × Fin (V.pieces f.val)
+  let a : Pair → Plane := fun k => V.vertices k.1 k.2.2.1.val
+  let b : Pair → Plane := fun k => V.vertices k.1 (k.2.2.1.val+1)
+  let c : Pair → Plane := fun k => V.vertices k.2.1.val k.2.2.2.val
+  let d : Pair → Plane := fun k => V.vertices k.2.1.val (k.2.2.2.val+1)
+  let qc : Pair → Plane := fun k => trackOffset (V.vertices k.2.1.val) (V.pieces k.2.1.val) k.2.2.2.val
+  let qd : Pair → Plane := fun k => trackOffset (V.vertices k.2.1.val) (V.pieces k.2.1.val) (k.2.2.2.val+1)
+  have hh (k : Pair) : SegmentPairTransverse (a k) (b k) (c k) (d k) :=
+    V.pair_transverse hnorm hstraight htrans k.1 k.2.1.val k.2.1.property k.2.2.1 k.2.2.2
+  obtain ⟨δ,hδ,hstable⟩ := exists_shifted_segment_pairs_radius a b c d qc qd hh
+  refine ⟨δ,hδ,?_⟩
+  intro t ht e f hef i j
+  exact hstable t ht ⟨e,⟨f,hef⟩,i,j⟩
+
+end Zarankiewicz.VertexTruncation
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TwoTriangleBasis.lean

@@ -0,0 +1,65 @@
+import OAI.Combinatorics.Crossing.BivariateCoefficients
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+open Module
+open scoped BigOperators
+
+abbrev TriangleIndex (s : ℕ) := ↥(twoTriangle s)
+
+def triangleCoordEquiv (s : ℕ) : BiExponent s ≃ TriangleIndex s :=
+  Fintype.equivOfCardEq (by simp [BiExponent, TriangleIndex, card_twoTriangle])
+
+def monomialVector (s : ℕ) (node : ℕ → ℝ) (p q : ℕ) : BiExponent s → ℝ :=
+  fun ab => node p ^ ab.1.val * node q ^ ab.2.val
+
+def triangleMatrix (s : ℕ) (node : ℕ → ℝ) : Matrix (BiExponent s) (BiExponent s) ℝ :=
+  fun ab j => monomialVector s node (triangleCoordEquiv s j).val.1
+    (triangleCoordEquiv s j).val.2 ab
+
+theorem triangleMatrix_eval (s : ℕ) (node : ℕ → ℝ) (c : BiExponent s → ℝ)
+    (j : BiExponent s) :
+    (triangleMatrix s node).transpose.mulVec c j =
+      biEval (node (triangleCoordEquiv s j).val.1) (node (triangleCoordEquiv s j).val.2)
+        (biOfCoeffs s c) := by
+  rw [biEval_biOfCoeffs]
+  simp only [Matrix.mulVec, dotProduct, Matrix.transpose_apply, triangleMatrix,
+    monomialVector, Fintype.sum_prod_type]
+
+theorem triangleMatrix_isUnit (s : ℕ) (node : ℕ → ℝ)
+    (hn : Set.InjOn node (Set.Icc 1 (2*s+1))) : IsUnit (triangleMatrix s node) := by
+  rw [← Matrix.isUnit_transpose, ← Matrix.mulVec_injective_iff_isUnit]
+  intro c d hcd
+  apply biOfCoeffs_injective s
+  apply twoTriangle_evaluation_injective s node hn (biOfCoeffs s c) (biOfCoeffs s d)
+    (biOfCoeffs_bounded s c) (biOfCoeffs_bounded s d)
+  intro p q hpq
+  let j := (triangleCoordEquiv s).symm ⟨(p,q), hpq⟩
+  have hh := congrFun hcd j
+  rw [triangleMatrix_eval, triangleMatrix_eval] at hh
+  simpa only [j, Equiv.apply_symm_apply] using hh
+
+def twoTriangleBasis (s : ℕ) (node : ℕ → ℝ)
+    (hn : Set.InjOn node (Set.Icc 1 (2*s+1))) :
+    Basis (BiExponent s) ℝ (BiExponent s → ℝ) :=
+  (Pi.basisFun ℝ (BiExponent s)).map
+    (LinearEquiv.ofBijective (triangleMatrix s node).mulVecLin
+      ⟨Matrix.mulVec_injective_of_isUnit (triangleMatrix_isUnit s node hn),
+        Matrix.mulVec_surjective_iff_isUnit.mpr (triangleMatrix_isUnit s node hn)⟩)
+
+theorem twoTriangleBasis_apply (s : ℕ) (node : ℕ → ℝ)
+    (hn : Set.InjOn node (Set.Icc 1 (2*s+1))) (j : BiExponent s) :
+    twoTriangleBasis s node hn j =
+      monomialVector s node (triangleCoordEquiv s j).val.1 (triangleCoordEquiv s j).val.2 := by
+  simp only [twoTriangleBasis, Basis.map_apply, Pi.basisFun_apply]
+  change (triangleMatrix s node).mulVec (Pi.single j 1) = _
+  funext i
+  simp [Matrix.mulVec_single, triangleMatrix]
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/TwoTriangleIndices.lean

@@ -0,0 +1,101 @@
+import Mathlib.Data.Finset.Prod
+import Mathlib.Order.Interval.Finset.Nat
+import Mathlib.Data.Nat.Choose.Basic
+import Mathlib.Tactic.Linarith
+import Lean.Elab.Tactic.Omega
+
+namespace OAI
+
+namespace Zarankiewicz
+open Finset
+
+def lowerTriangle (s : ℕ) : Finset (ℕ × ℕ) :=
+  ((Icc 1 (s+1)) ×ˢ (Icc 1 (s+1))).filter (fun z => z.2 < z.1)
+
+def upperTriangle (s : ℕ) : Finset (ℕ × ℕ) :=
+  ((Icc (s+2) (2*s+1)) ×ˢ (Icc (s+2) (2*s+1))).filter (fun z => z.1 < z.2)
+
+def twoTriangle (s : ℕ) : Finset (ℕ × ℕ) := lowerTriangle s ∪ upperTriangle s
+
+theorem mem_lowerTriangle (s p q : ℕ) :
+    (p,q) ∈ lowerTriangle s ↔ 1 ≤ q ∧ q < p ∧ p ≤ s+1 := by
+  simp only [lowerTriangle, mem_filter, mem_product, mem_Icc]
+  omega
+
+theorem mem_upperTriangle (s p q : ℕ) :
+    (p,q) ∈ upperTriangle s ↔ s+1 < p ∧ p < q ∧ q ≤ 2*s+1 := by
+  simp only [upperTriangle, mem_filter, mem_product, mem_Icc]
+  omega
+
+theorem mem_twoTriangle (s p q : ℕ) :
+    (p,q) ∈ twoTriangle s ↔
+      (1 ≤ q ∧ q < p ∧ p ≤ s+1) ∨ (s+1 < p ∧ p < q ∧ q ≤ 2*s+1) := by
+  rw [twoTriangle, mem_union, mem_lowerTriangle, mem_upperTriangle]
+
+theorem disjoint_triangles (s : ℕ) : Disjoint (lowerTriangle s) (upperTriangle s) := by
+  apply Finset.disjoint_left.mpr
+  rintro ⟨p,q⟩ hp hq
+  rw [mem_lowerTriangle] at hp
+  rw [mem_upperTriangle] at hq
+  omega
+
+theorem card_lowerTriangle (s : ℕ) : (lowerTriangle s).card = (s+1).choose 2 := by
+  have hswap : (lowerTriangle s).card =
+      (((Icc 1 (s+1)) ×ˢ (Icc 1 (s+1))).filter (fun z => z.1 < z.2)).card :=
+    Finset.card_equiv (Equiv.prodComm ℕ ℕ) (by
+      intro z
+      simp [lowerTriangle, and_comm, and_left_comm, and_assoc])
+  rw [hswap, Finset.card_product_filter_lt]
+  simp
+
+theorem card_upperTriangle (s : ℕ) : (upperTriangle s).card = s.choose 2 := by
+  have h := Finset.card_product_filter_lt (s := Icc (s+2) (2*s+1))
+  have hc : (Icc (s+2) (2*s+1)).card = s := by simp; omega
+  simpa [upperTriangle, hc] using h
+
+theorem adjacent_choose_two (s : ℕ) : (s+1).choose 2 + s.choose 2 = s*s := by
+  induction s with
+  | zero => simp
+  | succ s ih =>
+    have ha : (s+2).choose 2 = (s+1).choose 2 + (s+1) := by
+      calc
+        (s+2).choose 2 = (s+1).choose 1 + (s+1).choose 2 := Nat.choose_succ_succ (s+1) 1
+        _ = (s+1).choose 2 + (s+1) := by rw [Nat.choose_one_right]; omega
+    have hb : (s+1).choose 2 = s.choose 2 + s := by
+      simpa [Nat.choose_one_right, Nat.succ_eq_add_one, Nat.add_comm] using
+        (Nat.choose_succ_succ s 1)
+    have : s+1+1 = s+2 := by omega
+    rw [this, ha]
+    nlinarith
+
+theorem card_twoTriangle (s : ℕ) : (twoTriangle s).card = s*s := by
+  rw [twoTriangle, card_union_of_disjoint (disjoint_triangles s), card_lowerTriangle,
+    card_upperTriangle, adjacent_choose_two]
+
+def triangleRelabel (s k : ℕ) : ℕ := if k ≤ s then s+1+k else k-s+1
+
+theorem triangleRelabel_injective_on (s : ℕ) :
+    Set.InjOn (triangleRelabel s) (Set.Icc 1 (2*s-1)) := by
+  intro p hp q hq he
+  simp only [Set.mem_Icc] at hp hq
+  unfold triangleRelabel at he
+  split_ifs at he <;> omega
+
+theorem triangleRelabel_range (s k : ℕ) (hk : k ∈ Icc 1 (2*s-1)) :
+    triangleRelabel s k ∈ Icc 1 (2*s+1) ∧
+      triangleRelabel s k ≠ s+1 ∧ triangleRelabel s k ≠ 1 := by
+  simp only [mem_Icc] at hk ⊢
+  unfold triangleRelabel
+  split_ifs <;> omega
+
+theorem relabel_twoTriangle (s : ℕ) (hs : 1 ≤ s) (p q : ℕ)
+    (hpq : (p,q) ∈ twoTriangle (s-1)) :
+    (triangleRelabel s q, triangleRelabel s p) ∈ twoTriangle s ∧
+      triangleRelabel s q ≠ s+1 ∧ triangleRelabel s p ≠ 1 := by
+  rw [mem_twoTriangle] at hpq ⊢
+  unfold triangleRelabel
+  split_ifs <;> omega
+
+end Zarankiewicz
+
+end OAI

lean/OAI/Combinatorics/Crossing/TwoTriangleUnisolvence.lean

@@ -0,0 +1,133 @@
+import OAI.Combinatorics.Crossing.Bivariate
+import OAI.Combinatorics.Crossing.TwoTriangleIndices
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+open PolynomialModule
+open Finset
+
+theorem eq_zero_of_roots_injOn {W : Type*} [AddCommGroup W] [Module ℝ W]
+    (node : ℕ → ℝ) (S : Finset ℕ) (hn : Set.InjOn node (S : Set ℕ))
+    (p : PolynomialModule ℝ W) (hp : Bounded S.card p)
+    (he : ∀ i ∈ S, eval (node i) p = 0) : p = 0 := by
+  let x : S → ℝ := fun i => node i.val
+  have hx : Function.Injective x := by
+    intro i j hij
+    exact Subtype.ext (hn i.property j.property hij)
+  apply eq_zero_of_node_roots x hx Finset.univ p
+  · simpa using hp
+  · intro i hi
+    exact he i.val i.property
+
+theorem twoTriangle_unisolvent (s : ℕ) (node : ℕ → ℝ)
+    (hn : Set.InjOn node (Set.Icc 1 (2*s+1))) (p : BiPoly)
+    (hp : BiBounded s s p)
+    (hv : ∀ a b, (a,b) ∈ twoTriangle s → biEval (node a) (node b) p = 0) : p = 0 := by
+  induction s generalizing node p with
+  | zero => exact (bounded_zero_iff p).mp hp.1
+  | succ k ih =>
+    have node_ne : ∀ a b, a ∈ Icc 1 (2*(k+1)+1) → b ∈ Icc 1 (2*(k+1)+1) →
+        a ≠ b → node a ≠ node b := by
+      intro a b ha hb hab he
+      exact hab (hn (by simpa only [mem_Icc, Set.mem_Icc] using ha)
+        (by simpa only [mem_Icc, Set.mem_Icc] using hb) he)
+
+    have hrow : eval (node (k+2)) p = 0 := by
+      apply eq_zero_of_roots_injOn node (Icc 1 (k+1))
+      · intro a ha b hb he
+        apply hn _ _ he <;> simp only [mem_coe, mem_Icc, Set.mem_Icc] at * <;> omega
+      · simpa using bounded_eval_outer hp (node (k+2))
+      · intro q hq
+        apply hv (k+2) q
+        rw [mem_twoTriangle]
+        simp only [mem_Icc] at hq
+        left
+        omega
+    obtain ⟨p₁, hp₁, he₁⟩ := bi_factor_row k (k+1) p hp (node (k+2)) hrow
+
+    have hcol : eval (node 1) (swapBi p₁) = 0 := by
+      apply eq_zero_of_roots_injOn node (Icc 2 (k+1))
+      · intro a ha b hb he
+        apply hn _ _ he <;> simp only [mem_coe, mem_Icc, Set.mem_Icc] at * <;> omega
+      · simpa using bounded_eval_outer (biBounded_swap hp₁) (node 1)
+      · intro a ha
+        change biEval (node 1) (node a) (swapBi p₁) = 0
+        rw [biEval_swap]
+        have hpa : biEval (node a) (node 1) p = 0 := by
+          apply hv
+          rw [mem_twoTriangle]
+          simp only [mem_Icc] at ha
+          left
+          omega
+        rw [← he₁, biEval_mulRoot] at hpa
+        apply (mul_eq_zero.mp hpa).resolve_left
+        apply sub_ne_zero.mpr
+        apply node_ne a (k+2) <;> simp only [mem_Icc] at * <;> omega
+    obtain ⟨r, hr, her⟩ := bi_factor_row k k (swapBi p₁) (biBounded_swap hp₁) (node 1) hcol
+
+    let y : ℕ → ℝ := fun i => node (triangleRelabel (k+1) i)
+    have hyrange : ∀ a, a ∈ Icc 1 (2*k+1) →
+        triangleRelabel (k+1) a ∈ Icc 1 (2*(k+1)+1) ∧
+          triangleRelabel (k+1) a ≠ k+2 ∧ triangleRelabel (k+1) a ≠ 1 := by
+      intro a ha
+      simpa only [show k+1+1 = k+2 from rfl] using
+        triangleRelabel_range (k+1) a (by simp only [mem_Icc] at *; omega)
+    have hyn : Set.InjOn y (Set.Icc 1 (2*k+1)) := by
+      intro a ha b hb he
+      have ha' : a ∈ Icc 1 (2*k+1) := by simpa only [mem_Icc, Set.mem_Icc] using ha
+      have hb' : b ∈ Icc 1 (2*k+1) := by simpa only [mem_Icc, Set.mem_Icc] using hb
+      apply triangleRelabel_injective_on (k+1)
+      · simp only [Set.mem_Icc] at *
+        omega
+      · simp only [Set.mem_Icc] at *
+        omega
+      · exact hn (by simpa only [Set.mem_Icc, mem_Icc] using (hyrange a ha').1)
+          (by simpa only [Set.mem_Icc, mem_Icc] using (hyrange b hb').1) he
+    have hrv : ∀ a b, (a,b) ∈ twoTriangle k → biEval (y a) (y b) r = 0 := by
+      intro a b hab
+      have ha : a ∈ Icc 1 (2*k+1) := by
+        rw [mem_twoTriangle] at hab
+        simp only [mem_Icc]
+        omega
+      have hb : b ∈ Icc 1 (2*k+1) := by
+        rw [mem_twoTriangle] at hab
+        simp only [mem_Icc]
+        omega
+      have hpattern := relabel_twoTriangle (k+1) (by omega) a b (by simpa using hab)
+      have hval := hv (triangleRelabel (k+1) b) (triangleRelabel (k+1) a) hpattern.1
+      rw [← he₁, biEval_mulRoot] at hval
+      have hfirst : node (triangleRelabel (k+1) b) - node (k+2) ≠ 0 :=
+        sub_ne_zero.mpr (node_ne _ _ (hyrange b hb).1 (by simp) (hyrange b hb).2.1)
+      have hp₁val := (mul_eq_zero.mp hval).resolve_left hfirst
+      have hswap : p₁ = swapBi (mulRoot (node 1) r) := by rw [her, swapBi_swapBi]
+      rw [hswap, biEval_swap, biEval_mulRoot] at hp₁val
+      apply (mul_eq_zero.mp hp₁val).resolve_left
+      exact sub_ne_zero.mpr (node_ne _ _ (hyrange a ha).1 (by simp) (hyrange a ha).2.2)
+    have hr0 := ih y hyn r hr hrv
+    have hp₁0 : p₁ = 0 := by
+      apply swapBi.injective
+      rw [← her, hr0]
+      simp [mulRoot]
+    rw [← he₁, hp₁0]
+    simp [mulRoot]
+
+theorem twoTriangle_evaluation_injective (s : ℕ) (node : ℕ → ℝ)
+    (hn : Set.InjOn node (Set.Icc 1 (2*s+1))) (p q : BiPoly)
+    (hp : BiBounded s s p) (hq : BiBounded s s q)
+    (he : ∀ a b, (a,b) ∈ twoTriangle s → biEval (node a) (node b) p = biEval (node a) (node b) q) :
+    p = q := by
+  apply sub_eq_zero.mp
+  apply twoTriangle_unisolvent s node hn (p-q)
+  · refine ⟨bounded_sub hp.1 hq.1, ?_⟩
+    intro a
+    exact bounded_sub (hp.2 a) (hq.2 a)
+  · intro a b hab
+    rw [map_sub, he a b hab, sub_self]
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/UniformCrossTypeGeometry.lean

@@ -0,0 +1,73 @@
+import OAI.Combinatorics.Crossing.ChordExteriorSeparation
+import OAI.Combinatorics.Crossing.ConnectorTrackAvoidance
+import OAI.Combinatorics.Crossing.SegmentTraversalReversal
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.TruncatedSpokeCoordinates
+variable {m n : ℕ} {D : AdmissibleDrawing m n} {V : VertexTruncation D.toContinuousDrawing}
+  (C : TruncatedSpokeCoordinates V)
+
+theorem exists_cross_type_radius (hnorm : NoAdjacentCrossings D) :
+    ∃ δ : ℝ, 0<δ ∧ ∀ ε : ℝ, ε ≠ 0 → |ε|<δ →
+      (∀ j (f : IncidentEdges j) e (i : Fin (V.pieces e)),
+        ¬ ClosedSegmentsMeet (V.vertices e i.val) (V.vertices e (i.val+1))
+          (C.shiftedPort j f ε) (C.tangentPort j f ε)) ∧
+      (∀ j (c d : IncidentEdges j) e (i : Fin (V.pieces e)),
+        ¬ ClosedSegmentsMeet (V.vertices e i.val) (V.vertices e (i.val+1))
+          (C.shiftedPort j c ε) (C.shiftedPort j d ε)) ∧
+      (∀ j (a b : IncidentEdges j) e (i : Fin (V.pieces e)),
+        ¬ ClosedSegmentsMeet (V.spokePort j a) (V.spokePort j b)
+          (shiftedTrack (V.vertices e) (V.pieces e) ε i.val)
+          (shiftedTrack (V.vertices e) (V.pieces e) ε (i.val+1))) ∧
+      (∀ j k (a b : IncidentEdges j) (f : IncidentEdges k),
+        ¬ ClosedSegmentsMeet (V.spokePort j a) (V.spokePort j b)
+          (C.shiftedPort k f ε) (C.tangentPort k f ε)) ∧
+      (∀ j k (a b : IncidentEdges j) (c d : IncidentEdges k), a ≠ b → c ≠ d →
+        SegmentPairTransverse (V.spokePort j a) (V.spokePort j b) (C.shiftedPort k c ε) (C.shiftedPort k d ε)) ∧
+      (∀ j k, j ≠ k → ∀ (a b : IncidentEdges j) (c d : IncidentEdges k),
+        ¬ ClosedSegmentsMeet (V.spokePort j a) (V.spokePort j b) (C.shiftedPort k c ε) (C.shiftedPort k d ε)) := by
+  obtain ⟨δ₀,hδ₀,htracks⟩ := V.exists_all_vertex_disk_radius
+  obtain ⟨δ₁,hδ₁,hconnectors⟩ := C.exists_all_connector_track_radius hnorm
+  obtain ⟨δ₂,hδ₂,hother⟩ := C.exists_connector_other_disks_radius
+  obtain ⟨δ₃,hδ₃,hseparate⟩ := C.exists_uniform_endpoint_radius
+  obtain ⟨δ₄,hδ₄,hscale⟩ := C.exists_uniform_scale_radius
+  let δ := min δ₀ (min δ₁ (min δ₂ (min δ₃ δ₄)))
+  have hδ : 0<δ := lt_min hδ₀ (lt_min hδ₁ (lt_min hδ₂ (lt_min hδ₃ hδ₄)))
+  have hb₀ : δ≤δ₀ := min_le_left _ _
+  have hb₁ : δ≤δ₁ := (min_le_right _ _).trans (min_le_left _ _)
+  have hb₂ : δ≤δ₂ := (min_le_right _ _).trans ((min_le_right _ _).trans (min_le_left _ _))
+  have hb₃ : δ≤δ₃ := (min_le_right _ _).trans ((min_le_right _ _).trans ((min_le_right _ _).trans (min_le_left _ _)))
+  have hb₄ : δ≤δ₄ := (min_le_right _ _).trans ((min_le_right _ _).trans ((min_le_right _ _).trans (min_le_right _ _)))
+  refine ⟨δ,hδ,?_⟩
+  intro ε hε hsmall
+  have hs := hscale ε (hsmall.trans_le hb₄)
+  have hsep := hseparate ε hε (hsmall.trans_le hb₃)
+  refine ⟨hconnectors ε hε (hsmall.trans_le hb₁),?_,?_,?_,?_,?_⟩
+  · intro j c d e i
+    exact C.track_shifted_chord_disjoint j c d ε (hs j c).le (hs j d).le (hsep j).1 e i
+  · intro j a b e i
+    exact round_chord_exterior_disjoint (D.vertex j) _ _ _ _ V.radius
+      (V.spokePort_circle j a) (V.spokePort_circle j b) (htracks ε hε (hsmall.trans_le hb₀) j e i)
+  · intro j k a b f
+    by_cases hjk : j=k
+    · subst k
+      exact C.chord_connector_disjoint_all_passages j a b f ε hε (hs j f) ((hsep j).1 a f) ((hsep j).1 b f)
+    · exact round_chord_exterior_disjoint (D.vertex j) _ _ _ _ V.radius
+        (V.spokePort_circle j a) (V.spokePort_circle j b)
+        (hother ε (hsmall.trans_le hb₂) k j (Ne.symm hjk) f)
+  · intro j k a b c d hab hcd
+    by_cases hjk : j=k
+    · subst k
+      exact C.shifted_chords_transverse j a b c d ε (fun e => (hs j e).le) (hsep j).1 (hsep j).2 hab hcd
+    · exact segmentPairTransverse_of_not_meet _ _ _ _
+        (C.different_vertex_chords_disjoint j k hjk a b c d ε (hs k c).le (hs k d).le)
+  · intro j k hjk a b c d
+    exact C.different_vertex_chords_disjoint j k hjk a b c d ε (hs k c).le (hs k d).le
+
+end Zarankiewicz.TruncatedSpokeCoordinates
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/UniformSpokeRadii.lean

@@ -0,0 +1,49 @@
+import OAI.Combinatorics.Crossing.SpokeEndpointSeparation
+import OAI.Combinatorics.Crossing.FiniteScaledRadius
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.TruncatedSpokeCoordinates
+variable {m n : ℕ} {D : ContinuousDrawing m n} {V : VertexTruncation D}
+  (C : TruncatedSpokeCoordinates V)
+
+theorem port_injective (C : TruncatedSpokeCoordinates V) (j : BipartiteVertex m n) : Function.Injective (V.spokePort j) := by
+  intro e f he
+  apply C.node_injective j
+  apply circlePoint_injective
+  apply similarityPoint_injective (D.vertex j) (C.frame j) (C.frame_ne_zero j)
+  simpa only [C.point_eq] using he
+
+theorem exists_uniform_endpoint_radius :
+    ∃ δ : ℝ, 0<δ ∧ ∀ ε : ℝ, ε ≠ 0 → |ε|<δ → ∀ j : BipartiteVertex m n,
+      (∀ e f : IncidentEdges j, V.spokePort j e ≠ C.shiftedPort j f ε) ∧
+      Function.Injective (fun e : IncidentEdges j => C.shiftedPort j e ε) := by
+  classical
+  choose radius hpos hprop using C.exists_endpoint_separation_radius
+  obtain ⟨δ,hδ,hbound⟩ := finite_positive_lower_bound Finset.univ radius (fun j _ => hpos j)
+  exact ⟨δ,hδ,fun ε hε hsmall j => hprop j ε hε (hsmall.trans (hbound j (Finset.mem_univ _)))⟩
+
+theorem exists_uniform_scale_radius (_C : TruncatedSpokeCoordinates V) :
+    ∃ δ : ℝ, 0<δ ∧ ∀ ε : ℝ, |ε|<δ → ∀ j (e : IncidentEdges j), |V.spokeScale j e*ε|<1 := by
+  let Spoke := Σ j : BipartiteVertex m n, IncidentEdges j
+  obtain ⟨δ,hδ,hbound⟩ := finite_scaled_radius
+    (fun s : Spoke => V.spokeScale s.1 s.2) (fun _ => (1 : ℝ)) (by intro s; norm_num)
+  exact ⟨δ,hδ,fun ε hε j e => hbound ε hε ⟨j,e⟩⟩
+
+theorem exists_uniform_average_radius :
+    ∃ δ : ℝ, 0<δ ∧ ∀ t : ℝ, 0<t → t<δ → ∀ j (a b c d : IncidentEdges j),
+      a ≠ b → c ≠ d →
+      (segmentCrossingSign (V.spokePort j a) (V.spokePort j b) (C.shiftedPort j c t) (C.shiftedPort j d t)+
+        segmentCrossingSign (V.spokePort j a) (V.spokePort j b) (C.shiftedPort j c (-t)) (C.shiftedPort j d (-t)))/2 =
+      chordEndpointPairing (C.node j a) (C.node j b) (C.node j c) (C.node j d) := by
+  classical
+  choose radius hpos hprop using C.exists_vertex_average_radius
+  obtain ⟨δ,hδ,hbound⟩ := finite_positive_lower_bound Finset.univ radius (fun j _ => hpos j)
+  exact ⟨δ,hδ,fun t ht hsmall j => hprop j t ht (hsmall.trans (hbound j (Finset.mem_univ _)))⟩
+
+end Zarankiewicz.TruncatedSpokeCoordinates
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/UniformTrackPerturbation.lean

@@ -0,0 +1,74 @@
+import OAI.Combinatorics.Crossing.TruncatedTrackStability
+import OAI.Combinatorics.Crossing.PolygonalWalks
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.VertexTruncation
+open scoped BigOperators
+variable {m n : ℕ} {D : AdmissibleDrawing m n}
+
+theorem exists_all_edge_shift_radius (V : VertexTruncation D.toContinuousDrawing)
+    (hnorm : NoAdjacentCrossings D) (hstraight : LocallyStraightCrossings D) (htrans : LocallyTransverseCrossings D) :
+    ∃ δ : ℝ, 0 < δ ∧ ∀ t : ℝ, t ≠ 0 → |t| < δ → ∀ e f : BipartiteEdge m n,
+      ∀ i : Fin (V.pieces e), ∀ j : Fin (V.pieces f),
+        SegmentPairTransverse (V.vertices e i.val) (V.vertices e (i.val+1))
+          (shiftedTrack (V.vertices f) (V.pieces f) t j.val)
+          (shiftedTrack (V.vertices f) (V.pieces f) t (j.val+1)) ∧
+        segmentCrossingSign (V.vertices e i.val) (V.vertices e (i.val+1))
+          (shiftedTrack (V.vertices f) (V.pieces f) t j.val)
+          (shiftedTrack (V.vertices f) (V.pieces f) t (j.val+1)) =
+          if e=f then 0 else segmentCrossingSign (V.vertices e i.val) (V.vertices e (i.val+1))
+            (V.vertices f j.val) (V.vertices f (j.val+1)) := by
+  classical
+  obtain ⟨δ₀,hδ₀,hother⟩ := V.exists_distinct_edge_shift_radius hnorm hstraight htrans
+  choose radius hpos hself using V.offset_avoidance
+  obtain ⟨δ₁,hδ₁,hbound⟩ := finite_positive_lower_bound Finset.univ radius (fun e _ => hpos e)
+  refine ⟨min δ₀ δ₁,lt_min hδ₀ hδ₁,?_⟩
+  intro t ht hsmall e f i j
+  by_cases hef : e=f
+  · subst f
+    have hno := hself e t ht ((hsmall.trans_le (min_le_right _ _)).trans (hbound e (Finset.mem_univ _))) i j
+    refine ⟨?_,?_⟩
+    · intro s hs u hu he
+      exact False.elim (hno ⟨s,hs,u,hu,he⟩)
+    · have hp : ¬ SegmentsCrossProperly (V.vertices e i.val) (V.vertices e (i.val+1))
+          (shiftedTrack (V.vertices e) (V.pieces e) t j.val)
+          (shiftedTrack (V.vertices e) (V.pieces e) t (j.val+1)) :=
+        fun h => hno (closedSegmentsMeet_of_proper _ _ _ _ h)
+      simp [segmentCrossingSign,hp]
+  · obtain ⟨hT,hS⟩ := hother t (hsmall.trans_le (min_le_left _ _)) e f hef i j
+    exact ⟨hT,by simpa only [ite_eq_right hef] using hS⟩
+
+theorem exists_uniform_track_intersections (V : VertexTruncation D.toContinuousDrawing)
+    (hnorm : NoAdjacentCrossings D) (hstraight : LocallyStraightCrossings D) (htrans : LocallyTransverseCrossings D) :
+    ∃ δ : ℝ, 0 < δ ∧ ∀ t : ℝ, t ≠ 0 → |t| < δ → ∀ e f : BipartiteEdge m n,
+      polygonIntersection (V.vertices e) (shiftedTrack (V.vertices f) (V.pieces f) t) (V.pieces e) (V.pieces f) =
+        if e=f then 0 else polygonIntersection (V.vertices e) (V.vertices f) (V.pieces e) (V.pieces f) := by
+  classical
+  obtain ⟨δ,hδ,hh⟩ := V.exists_all_edge_shift_radius hnorm hstraight htrans
+  refine ⟨δ,hδ,?_⟩
+  intro t ht hsmall e f
+  by_cases hef : e=f
+  · rw [ite_eq_left hef]
+    unfold polygonIntersection
+    apply Finset.sum_eq_zero
+    intro i hi
+    apply Finset.sum_eq_zero
+    intro j hj
+    simpa only [ite_eq_left hef] using
+      (hh t ht hsmall e f ⟨i,Finset.mem_range.mp hi⟩ ⟨j,Finset.mem_range.mp hj⟩).2
+  · rw [ite_eq_right hef]
+    unfold polygonIntersection
+    apply Finset.sum_congr rfl
+    intro i hi
+    apply Finset.sum_congr rfl
+    intro j hj
+    simpa only [ite_eq_right hef] using
+      (hh t ht hsmall e f ⟨i,Finset.mem_range.mp hi⟩ ⟨j,Finset.mem_range.mp hj⟩).2
+
+end Zarankiewicz.VertexTruncation
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/UniqueWalkPassage.lean

@@ -0,0 +1,41 @@
+import Mathlib.Combinatorics.SimpleGraph.Paths
+
+namespace OAI
+
+namespace Zarankiewicz
+
+def UniqueWalkVisit {V : Type*} {G : SimpleGraph V} {a b : V} (p : G.Walk a b) (x : V) : Prop :=
+  ∀ i j : ℕ, i ≤ p.length → j ≤ p.length → p.getVert i=x → p.getVert j=x → i=j
+
+theorem walk_dart_parameters {V : Type*} {G : SimpleGraph V} {a b : V}
+    (p : G.Walk a b) (d : G.Dart) (hd : d ∈ p.darts) :
+    ∃ i : ℕ, i < p.length ∧ d.fst=p.getVert i ∧ d.snd=p.getVert (i+1) := by
+  obtain ⟨i,hi⟩ := List.mem_iff_get.mp hd
+  have he := SimpleGraph.Walk.darts_getElem_eq_getVert (p:=p) i.val i.isLt
+  have hd' := hi.symm.trans he
+  refine ⟨i.val,by simpa only [p.length_darts] using i.isLt,?_,?_⟩
+  · exact congrArg (fun r : G.Dart => r.fst) hd'
+  · exact congrArg (fun r : G.Dart => r.snd) hd'
+
+theorem unique_walk_visit_passage {V : Type*} {G : SimpleGraph V} {a b : V}
+    (p : G.Walk a b) (x : V) (hunique : UniqueWalkVisit p x)
+    (d e : G.Dart) (hd : d ∈ p.darts) (he : e ∈ p.darts) (hdx : d.snd=x) (hex : e.fst=x) :
+    ∃ i : ℕ, i+1 < p.length ∧ d.fst=p.getVert i ∧
+      x=p.getVert (i+1) ∧ e.snd=p.getVert (i+2) := by
+  obtain ⟨i,hi,hdi,hdi'⟩ := walk_dart_parameters p d hd
+  obtain ⟨j,hj,hej,hej'⟩ := walk_dart_parameters p e he
+  have hij : i+1=j := hunique (i+1) j (by omega) (by omega) (hdi'.symm.trans hdx) (hej.symm.trans hex)
+  refine ⟨i,by omega,hdi,hdx.symm.trans hdi',?_⟩
+  simpa only [← hij,Nat.add_assoc] using hej'
+
+theorem bypass_unique_walk_visit_passage {V : Type*} [DecidableEq V] {G : SimpleGraph V} {a b : V}
+    (p : G.Walk a b) (x : V) (hunique : UniqueWalkVisit p x)
+    (d e : G.Dart) (hd : d ∈ p.bypass.darts) (he : e ∈ p.bypass.darts) (hdx : d.snd=x) (hex : e.fst=x) :
+    ∃ i : ℕ, i+1 < p.length ∧ d.fst=p.getVert i ∧
+      x=p.getVert (i+1) ∧ e.snd=p.getVert (i+2) :=
+  unique_walk_visit_passage p x hunique d e (p.darts_bypass_subset_darts hd)
+    (p.darts_bypass_subset_darts he) hdx hex
+
+end Zarankiewicz
+
+end OAI

lean/OAI/Combinatorics/Crossing/VertexChordIntersections.lean

@@ -0,0 +1,45 @@
+import OAI.Combinatorics.Crossing.StraightChainTransversality
+import OAI.Combinatorics.Crossing.UniformCrossTypeGeometry
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz.TruncatedSpokeCoordinates
+variable {m n : ℕ} {D : AdmissibleDrawing m n} {V : VertexTruncation D.toContinuousDrawing}
+  (C : TruncatedSpokeCoordinates V)
+
+theorem chordChain_intersection (j k : BipartiteVertex m n) (a b : IncidentEdges j)
+    (c d : IncidentEdges k) (ε : ℝ) :
+    polygonIntersection (V.chordChain j a b).vertices (C.shiftedChordChain k c d ε).vertices 1 1=
+      segmentCrossingSign (V.spokePort j a) (V.spokePort j b) (C.shiftedPort k c ε) (C.shiftedPort k d ε) := by
+  rw [VertexTruncation.chordChain,shiftedChordChain,PolygonalChain.intersection_single_single]
+
+theorem exists_vertex_chord_chain_radius (hnorm : NoAdjacentCrossings D) :
+    ∃ δ : ℝ, 0<δ ∧
+      (∀ ε : ℝ, ε ≠ 0 → |ε|<δ → ∀ j k (a b : IncidentEdges j) (c d : IncidentEdges k),
+        a ≠ b → c ≠ d → (V.chordChain j a b).Transverse (C.shiftedChordChain k c d ε)) ∧
+      (∀ ε : ℝ, ε ≠ 0 → |ε|<δ → ∀ j k, j ≠ k → ∀ (a b : IncidentEdges j) (c d : IncidentEdges k),
+        polygonIntersection (V.chordChain j a b).vertices (C.shiftedChordChain k c d ε).vertices 1 1=0) ∧
+      (∀ t : ℝ, 0<t → t<δ → ∀ j (a b c d : IncidentEdges j), a ≠ b → c ≠ d →
+        (polygonIntersection (V.chordChain j a b).vertices (C.shiftedChordChain j c d t).vertices 1 1+
+          polygonIntersection (V.chordChain j a b).vertices (C.shiftedChordChain j c d (-t)).vertices 1 1)/2=
+            chordEndpointPairing (C.node j a) (C.node j b) (C.node j c) (C.node j d)) := by
+  obtain ⟨δ₀,hδ₀,hgeo⟩ := C.exists_cross_type_radius hnorm
+  obtain ⟨δ₁,hδ₁,havg⟩ := C.exists_uniform_average_radius
+  refine ⟨min δ₀ δ₁,lt_min hδ₀ hδ₁,?_,?_,?_⟩
+  · intro ε hε hsmall j k a b c d hab hcd
+    have hh := (hgeo ε hε (hsmall.trans_le (min_le_left _ _))).2.2.2.2.1 j k a b c d hab hcd
+    exact PolygonalChain.transverse_single_single _ _ _ _ hh
+  · intro ε hε hsmall j k hjk a b c d
+    rw [C.chordChain_intersection]
+    exact segmentCrossingSign_eq_zero_of_not_meet _ _ _ _
+      ((hgeo ε hε (hsmall.trans_le (min_le_left _ _))).2.2.2.2.2 j k hjk a b c d)
+  · intro t ht hsmall j a b c d hab hcd
+    rw [C.chordChain_intersection,C.chordChain_intersection]
+    exact havg t ht (hsmall.trans_le (min_le_right _ _)) j a b c d hab hcd
+
+end Zarankiewicz.TruncatedSpokeCoordinates
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/VertexDiskSpokes.lean

@@ -0,0 +1,66 @@
+import OAI.Combinatorics.Crossing.RoundCircleChords
+import OAI.Combinatorics.Crossing.FiniteLineAvoidance
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+
+theorem spokes_meet_only_at_center (v a b : Plane) (hd : det2 (a-v) (b-v) ≠ 0)
+    {x : Plane} (ha : x ∈ segment ℝ v a) (hb : x ∈ segment ℝ v b) : x=v := by
+  rw [← Path.range_segment] at ha hb
+  obtain ⟨s,hs⟩ := ha
+  obtain ⟨t,ht⟩ := hb
+  have hs' : segmentPoint v a s.val=x := by simpa [Path.segment_apply,AffineMap.lineMap_apply_module,segmentPoint] using hs
+  have ht' : segmentPoint v b t.val=x := by simpa [Path.segment_apply,AffineMap.lineMap_apply_module,segmentPoint] using ht
+  have hp := segment_intersection_parameters_unique v a v b hd s.val t.val 0 0
+    (hs'.trans ht'.symm) (by simp)
+  rw [hp.1,segmentPoint_zero] at hs'
+  exact hs'.symm
+
+theorem spoke_in_open_disk (z v a : Plane) (r : ℝ)
+    (hv : squaredLength (v-z) < r^2) (ha : squaredLength (a-z)=r^2)
+    (t : ℝ) (ht : t ∈ Set.Ico (0 : ℝ) 1) :
+    squaredLength (segmentPoint v a t-z) < r^2 := by
+  have he : squaredLength (segmentPoint v a t-z)=
+      (1-t)*squaredLength (v-z)+t*squaredLength (a-z)-t*(1-t)*squaredLength (a-v) := by
+    dsimp [squaredLength,segmentPoint]
+    ring
+  have hpos := mul_pos (sub_pos.mpr ht.2) (sub_pos.mpr hv)
+  have hnon : 0 ≤ t*(1-t)*squaredLength (a-v) := by
+    apply mul_nonneg (mul_nonneg ht.1 (sub_nonneg.mpr ht.2.le))
+    dsimp [squaredLength]
+    positivity
+  rw [he,ha]
+  nlinarith
+
+theorem exists_vertex_disk_point {ι : Type*} [Fintype ι] [DecidableEq ι]
+    (z : Plane) (r : ℝ) (hr : 0 < r) (p : ι → Plane) (hp : Function.Injective p)
+    (hcircle : ∀ i, squaredLength (p i-z)=r^2) :
+    ∃ v : Plane, squaredLength (v-z) < r^2 ∧
+      (∀ i, v ≠ p i) ∧ (∀ i j, i ≠ j → det2 (p i-v) (p j-v) ≠ 0) := by
+  classical
+  let S := {ij : ι × ι // ij.1 ≠ ij.2}
+  obtain ⟨v,hv,havoid⟩ := exists_near_avoiding_lines
+    (fun ij : S => p ij.val.1) (fun ij : S => p ij.val.2-p ij.val.1)
+    (fun ij => sub_ne_zero.mpr (hp.ne (Ne.symm ij.property))) z (r/3) (by positivity)
+  have hinside : squaredLength (v-z) < r^2 := by
+    rw [Prod.dist_eq,Real.dist_eq,Real.dist_eq,max_lt_iff,abs_lt,abs_lt] at hv
+    have h₁ := mul_pos (sub_pos.mpr hv.1.2) (show 0 < r/3+(v.1-z.1) by linarith [hv.1.1])
+    have h₂ := mul_pos (sub_pos.mpr hv.2.2) (show 0 < r/3+(v.2-z.2) by linarith [hv.2.1])
+    change (v.1-z.1)^2+(v.2-z.2)^2 < r^2
+    nlinarith [sq_pos_of_pos hr]
+  refine ⟨v,hinside,?_,?_⟩
+  · intro i he
+    rw [he,hcircle i] at hinside
+    exact lt_irrefl _ hinside
+  · intro i j hij
+    have he : det2 (p i-v) (p j-v) = -det2 (v-p i) (p j-p i) := by dsimp [det2]; ring
+    rw [he]
+    exact neg_ne_zero.mpr (havoid ⟨(i,j),hij⟩)
+
+end Zarankiewicz
+
+end
+
+end OAI

lean/OAI/Combinatorics/Crossing/VertexDisksCrossingFree.lean

@@ -0,0 +1,40 @@
+import OAI.Combinatorics.Crossing.TruncatedDrawingDisks
+import OAI.Combinatorics.Crossing.IncidentSpokePorts
+
+namespace OAI
+
+noncomputable section
+namespace Zarankiewicz
+variable {m n : ℕ}
+
+theorem vertex_disks_crossing_free (D : AdmissibleDrawing m n) (hnorm : NoAdjacentCrossings D)
+    (P : ∀ e : BipartiteEdge m n, PolygonalChain (Set.range (D.edge e))
+      (D.vertex (.inl e.1)) (D.vertex (.inr e.2)))
+    (r : ℝ)
+    (hclear : ∀ j e (i : Fin (P e).pieces),
+      ¬ ((j=Sum.inl e.1 ∧ i.val=0) ∨ (j=Sum.inr e.2 ∧ i.val+1=(P e).pieces)) →
+      Disjoint (closedRoundDisk (D.vertex j) r) (segment ℝ ((P e).vertices i.val) ((P e).vertices (i.val+1))))
+    (j : BipartiteVertex m n) :
+    Disjoint (closedRoundDisk (D.vertex j) r) (crossingPoints D.toContinuousDrawing) := by
+  apply Set.disjoint_left.mpr
+  rintro x hxd ⟨e,f,hef,hxe,hxf⟩
+  have hincident (g : BipartiteEdge m n) (hxg : x ∈ edgeInterior D.toContinuousDrawing g) :
+      j=Sum.inl g.1 ∨ j=Sum.inr g.2 := by
+    have hx := edgeInterior_subset_range D.toContinuousDrawing g hxg
+    rw [← drawing_chain_range_eq D.toContinuousDrawing g (P g)] at hx
+    obtain ⟨i,hi,hxi⟩ := polygonalArcPath_range_piece (P g).vertices (P g).pieces
+      (drawing_chain_pieces_pos D.toContinuousDrawing g (P g)) x hx
+    by_contra h
+    have hbad : ¬ ((j=Sum.inl g.1 ∧ i=0) ∨ (j=Sum.inr g.2 ∧ i+1=(P g).pieces)) :=
+      fun hh => h (hh.elim (fun hh => Or.inl hh.1) (fun hh => Or.inr hh.1))
+    exact Set.disjoint_left.mp (hclear j g ⟨i,hi⟩ hbad) hxd hxi
+  have hadj := incident_edges_adjacent j ⟨e,hincident e hxe⟩ ⟨f,hincident f hxf⟩
+  have hh : x ∈ edgeInterior D.toContinuousDrawing e ∩ edgeInterior D.toContinuousDrawing f := ⟨hxe,hxf⟩
+  rw [hnorm e f hef hadj] at hh
+  exact hh
+
+end Zarankiewicz
+
+end
+
+end OAI