import OAI.Combinatorics.HadwigerCounterexample.BaselineExtension

namespace OAI

/-! # Baseline Forms -/

noncomputable section
namespace HadwigerCounterexample

open scoped BigOperators
open Matrix
variable {p : Shape} {n N : ℕ}

def lowCross (K : ℕ) (B : Cross p n) :=
  ∀ z i,( (B z)ᵀ * IP p n i).rank ≤ K

def fitsTable (a b : Plan p n) (B T : Cross p n) :=
  ∀ z, ∀ x∈tabSpace a z,∀ y∈tabSpace b (flipZ p z), evmat (B z) x y=evmat (T z) x y

theorem fits_recip {B T : Cross p n} {a b : Plan p n} (h : fitsTable a b B T) :
    fitsTable b a (reciprocal p B) (reciprocal p T) := by
  intro z x hx y hy
  have hx' : x∈tabSpace b (flipZ p (flipZ p z)) := by rwa [flipZ_flip]
  change evmat _ _ _=evmat _ _ _
  unfold reciprocal
  rw [evmat_transpose,evmat_transpose,h _ y hy x hx']

def blin (K : ℕ) := 4*K+56

set_option maxHeartbeats 800000 in
theorem start_form (a b : Pin p n N) (x y : UnitType p n N) (T : Cross p n)
    (ka kb : Plan p n)
    (hA : ∀ z,ka z≤primal p n) (hB : ∀ z,kb z≤primal p n)
    (hd : ∀ z, Disjoint (tabSpace a.sp z) (ka z))
    (hd' : ∀ z, Disjoint (tabSpace b.sp z) (kb z))
    (ha : a.agree x) (hb : b.agree y) (h1 : tableFlag a b T x)
    (h2 : tableFlag b a (reciprocal p T) y)
    (K : ℕ) (hk : planRank a.sp ≤ K) (hk' : planRank b.sp ≤ K)
    (hv : ∀ z, dim (ka z) ≤ 28) (hv' : ∀ z, dim (kb z) ≤ 28) :
    ∃ M : Cross p n, fitsTable a.sp b.sp M T ∧
      rowAgree (a.sp ⊔ ka) M (actual p x y) ∧
      rowAgree (b.sp ⊔ kb) (reciprocal p M) (actual p y x) ∧
      lowCross (blin K) M ∧ lowCross (blin K) (reciprocal p M) := by
  let A := actual p x y
  have hh (z : Place p) (u v) (hu : u∈tabSpace a.sp z) (hv : v∈tabSpace b.sp (flipZ p z))
      (h : u∈a.sp z ∨ v∈b.sp (flipZ p z)) : evmat (A z) u v=evmat (T z) u v := by
    rcases h with h|h
    · have h' : u ∈ a.sp (flipZ p (flipZ p z)) := by rwa [flipZ_flip]
      have he := h2 _ v hv u h'
      have hf := flag_actual (a:=b) y x ha (flipZ p z) v hv u h'
      have hg := hf.trans he.symm
      rw [← reciprocal_actual x y] at hg
      simp only [reciprocal,flipZ_flip,evmat_transpose] at hg
      exact hg
    exact (flag_actual (a:=a) x y hb _ u hu v h).trans (h1 _ u hu v h).symm
  choose M hC hD hE hF using fun z =>
    base_pair a.sp b.sp z (flipZ p z) (ka z) (kb (flipZ p z)) (hA _) (hB _) (hd _) (hd' _)
      (A z) (T z) (fun u hu v hv g => hh z u v hu hv g)
  have hr (z) {a s : Plan p n} (h : planRank a≤K) (hg : ∀ z,dim (s z)≤28) :
      dim (a z ⊔ s z : Submodule _ _) ≤ K+28 :=
    (Submodule.finrank_add_le_finrank_add_finrank ..).trans
      (Nat.add_le_add ((dim_le_plan a _).trans h) (hg _))
  have hm z {L} (hl : L≤K) : dim (a.sp z ⊔ ka z : Submodule _ _)+
      dim (b.sp (flipZ p z) ⊔ kb (flipZ p z):Submodule _ _)+2*L ≤ blin K := by
    apply le_trans (Nat.add_le_add (Nat.add_le_add (hr z hk hv) (hr _ hk' hv'))
      (Nat.mul_le_mul_left 2 hl))
    unfold blin; omega
  refine ⟨M,hC,(fun z u hu v => hD z u v (Or.inl hu)),?_,
    fun z i => (hE z i).trans (hm z hk),?_⟩
  · rw [← reciprocal_actual x y]
    intro z v hv u
    unfold reciprocal; rw [evmat_transpose,evmat_transpose]
    apply hD
    right
    rw [flipZ_flip]; exact hv
  intro z i
  unfold reciprocal; rw [transpose_transpose]
  exact (hF (flipZ p z) i).trans (hm _ hk')

theorem channel_eval (p : Shape) {n} (M : Cross p n) (j : Bool) (z : Place p)
    (x : Dir p n) (y : Vec (Chan p)) :
    dotProduct y (channelOut p M j z *ᵥ x)=evmat (M z) x (IH p n j *ᵥ y) := by
  unfold channelOut evmat
  rw [dotProduct_transpose_mulVec, Matrix.mulVec_mulVec]

theorem channel_same {M T : Cross p n} (i z u)
    (h : ∀ v : Vec (Chan p), evmat (M z) u (IH p n i *ᵥ v)=evmat (T z) u (IH p n i *ᵥ v)) :
    channelOut p M i z *ᵥ u = channelOut p T i z *ᵥ u := by
  classical
  funext j
  have he v : dotProduct v (channelOut p M i z *ᵥ u)=dotProduct v (channelOut p T i z*ᵥ u) := by
    rw [channel_eval, channel_eval, h]
  simpa using he (Pi.single j 1)

theorem fits_channel {M T : Cross p n} {a b : Plan p n} (h : fitsTable a b M T)
    (z : Place p) (x : Dir p n) (hx : x∈tabSpace a z) (j : Bool) :
    channelOut p M j z *ᵥ x = channelOut p T j z *ᵥ x := by
  apply channel_same j
  intro v
  exact h z x hx _ (channel_le_table b _ j ⟨_,rfl⟩)

theorem fits_inj {M T : Cross p n} {a b : Plan p n} (h : fitsTable a b M T)
    (ht : tableInj a b T) : tableInj a b M := by
  intro z i j v hv hh
  apply ht z i j v hv
  rwa [fits_channel h z _ (pin_le_table a z hv) j] at hh

private theorem cout_ev (A B : Mat (Chan p) (JointIdx p n)) (x y) :
    evmat (Aᵀ*B) x y=dotProduct (A *ᵥ x) (B *ᵥ y) := by
  rw [evmat,← mulVec_mulVec,dotProduct_transpose_mulVec,dotProduct_comm]

theorem fits_contract {M T : Cross p n} {a b : Plan p n} (h : fitsTable a b M T)
    (i j : Bool) (x : Profile p n) (hx : x ∈ effective a i) :
    contract p M i j x=contract p T i j x := by
  change ∑ e : Comp p.g, _ = _
  refine Finset.sum_congr rfl fun e _ => ?_
  apply (box_eval_iff (tabSpace a (e,true)) (tabSpace a (e,false)) _ _).mp ?_ _
  · have hp := lift_mem_box (IP p n i) (IP p n i) ((effective_mem.mp hx).2 e)
    exact box_le (le_trans le_sup_left (half_le_table a _ i))
      (le_trans le_sup_left (half_le_table a _ i)) hp
  intro x hx y hy; rw [cout_ev, cout_ev,fits_channel h _ _ hx,fits_channel h _ _ hy]

variable {I : Type} [Fintype I]

theorem frozen_contract_key {M T : Cross p n} {a} (v : Volley p n I) (t : Tagging p I)
    (h : rowAgree (a⊔v.keyPlan t) M T) (i : I) (j : Bool) :
    contract p M (v.obj i) j (v.atomAt t i)=contract p T (v.obj i) j (v.atomAt t i) := by
  classical
  change ∑ e : Comp p.g, _ = _
  refine Finset.sum_congr rfl fun e _ => ?_
  by_cases he : inc e (t i)
  · have hx b :
        v.rayLoc i ∈ (v.keyPlan t (e,b)) := colSp_mem (P:=v.keyM t e)
          (⟨i,he⟩ : Volley.visits p t e)
    have hE (b : Bool) : channelOut p M j (e,b) *ᵥ v.rayLoc i =
        channelOut p T j (e,b) *ᵥ v.rayLoc i :=
      channel_same j _ _ (fun y => h _ _ (Submodule.mem_sup_right (hx b)) _)
    simp only [Volley.atomAt,atom_def,he, ite_true,mom,liftM_outer,mpair_outer]
    rw [cout_ev,cout_ev]
    exact congrArg₂ dotProduct (hE true) (hE false)
  simp only [Volley.atomAt,atom_def,he,ite_false,map_zero]

end HadwigerCounterexample

end

end OAI