import OAI.Combinatorics.Crossing.FloorArithmetic
import Mathlib.Data.Finset.Prod
import Mathlib.Order.Interval.Finset.Fin

namespace OAI

namespace Zarankiewicz
open scoped Finset

def positiveRayIndices (r : ℕ) : Finset (Fin r) := Finset.univ.filter (fun i => i.val < r/2)
def negativeRayIndices (r : ℕ) : Finset (Fin r) := Finset.univ.filter (fun i => ¬ i.val < r/2)

def balancedRayPairs (r : ℕ) : Finset (Fin r × Fin r) :=
  ((positiveRayIndices r ×ˢ positiveRayIndices r).filter (fun p => p.1 < p.2)) ∪
    ((negativeRayIndices r ×ˢ negativeRayIndices r).filter (fun p => p.1 < p.2))

theorem mem_balancedRayPairs (r : ℕ) (i k : Fin r) :
    (i,k) ∈ balancedRayPairs r ↔ i < k ∧ (i.val < r/2 ↔ k.val < r/2) := by
  simp only [balancedRayPairs,positiveRayIndices,negativeRayIndices,Finset.mem_union,
    Finset.mem_filter,Finset.mem_product,Finset.mem_univ,true_and]
  tauto

theorem positiveRayIndices_card (r : ℕ) : (positiveRayIndices r).card=r/2 := by
  cases r with
  | zero => simp [positiveRayIndices]
  | succ r =>
    let c : Fin (r+1) := ⟨(r+1)/2,by omega⟩
    have he : positiveRayIndices (r+1)=Finset.Iio c := by
      ext i
      simp only [positiveRayIndices,Finset.mem_filter,Finset.mem_univ,true_and,Finset.mem_Iio]
      rfl
    rw [he,Fin.card_Iio]

theorem negativeRayIndices_card (r : ℕ) : (negativeRayIndices r).card=r-r/2 := by
  have hh := Finset.card_filter_add_card_filter_not (s := Finset.univ) (fun i : Fin r => i.val < r/2)
  change (positiveRayIndices r).card+(negativeRayIndices r).card=Finset.univ.card at hh
  rw [positiveRayIndices_card,Finset.card_univ,Fintype.card_fin] at hh
  omega

theorem twice_choose_two (s : ℕ) : 2*s.choose 2=s*(s-1) := by
  induction s with
  | zero => simp
  | succ s ih =>
    rw [Nat.choose_succ_succ,Nat.choose_one_right,Nat.add_sub_cancel]
    have hh : s*(s-1)+2*s=(s+1)*s := by
      cases s with
      | zero => simp
      | succ s => simp only [Nat.add_sub_cancel]; ring
    nlinarith

theorem balanced_choose_two (r : ℕ) : (r/2).choose 2+(r-r/2).choose 2=axisPairs r := by
  have hr : r=2*(r/2) ∨ r=2*(r/2)+1 := by omega
  rcases hr with hr | hr
  · generalize r/2=s at hr
    subst r
    rw [show 2*s-s=s by omega,axisPairs_even]
    have hh := twice_choose_two s
    omega
  · generalize r/2=s at hr
    subst r
    rw [show 2*s+1-s=s+1 by omega,axisPairs_odd,
      Nat.choose_succ_succ,Nat.choose_one_right]
    have hh := twice_choose_two s
    cases s with
    | zero => simp
    | succ s => simp only [Nat.add_sub_cancel] at hh; nlinarith

theorem balancedRayPairs_card (r : ℕ) : (balancedRayPairs r).card=axisPairs r := by
  have hd : Disjoint
      ((positiveRayIndices r ×ˢ positiveRayIndices r).filter (fun p => p.1 < p.2))
      ((negativeRayIndices r ×ˢ negativeRayIndices r).filter (fun p => p.1 < p.2)) := by
    apply Finset.disjoint_left.mpr
    rintro ⟨i,k⟩ hp hn
    simp only [Finset.mem_filter,Finset.mem_product,positiveRayIndices,negativeRayIndices,
      Finset.mem_univ,true_and] at hp hn
    exact hn.1.1 hp.1.1
  rw [balancedRayPairs,Finset.card_union_of_disjoint hd,Finset.card_product_filter_lt,
    Finset.card_product_filter_lt,positiveRayIndices_card,negativeRayIndices_card,balanced_choose_two]

end Zarankiewicz

end OAI