import OAI.Combinatorics.HadwigerCounterexample.PrimalSpaceCompression

namespace OAI

/-! # Bilinear Compression -/

noncomputable section
namespace HadwigerCounterexample
open Matrix LinearMap Submodule Module Finset
open scoped BigOperators

variable {p : Shape} {n : ℕ} {I J : Type} [Fintype I] [Fintype J]

def dqBound (p : Shape) (T H R : ℕ) := 2*(drow p T R+H)

private theorem pullM_fix (A : Mat I I) (P : Mat I I)
    (h : ∀ x ∈ colSp P,Aᵀ *ᵥ x=x) (h' : ∀ x∈colSp Pᵀ,Aᵀ *ᵥ x=x) :
    pullM A A P=P := by
  rw [pullM_def,mat_mul_fix h]
  have he := congrArg Matrix.transpose (mat_mul_fix h')
  simpa only [Matrix.transpose_mul,Matrix.transpose_transpose] using he

private def dualSpace (M : Profile p n) (z : Place p) :=
  colSp (if z.2 then M z.1 else (M z.1)ᵀ)
private theorem dualSpace_dim (M : Profile p n) (z : Place p) :
    dim (dualSpace M z)=(M z.1).rank := by
  cases z with
  | mk i b =>
    cases b; exact Matrix.rank_transpose _; rfl

private def jointShrink (A : Bool → Nendo p n) (B : Place p → Bool → Mat (Chan p) (Chan p))
    (z : Place p) :=
  ∑ i : Bool,(liftM (IP p n i) (IP p n i) (rowShrink p (A i))+
    liftM (IH p n i) (IH p n i) (B z i))

private theorem joint_ip (A : Bool → Nendo p n) (B : Place p → Bool → Mat (Chan p) (Chan p))
    (z : Place p) (i : Bool) :
    jointShrink A B z * IP p n i = IP p n i * rowShrink p (A i) := by
  classical
  simp only [jointShrink,Fintype.sum_bool,liftM_def,Matrix.add_mul,Matrix.mul_assoc,
    IH_IP,Matrix.mul_zero,add_zero]
  cases i <;> simp only [IP_self,IP_cross (show true≠false by decide),
    IP_cross (show false≠true by decide),Matrix.mul_zero,Matrix.mul_one,add_zero,zero_add]

set_option maxHeartbeats 800000 in
theorem shrink_pure {f : Plan p n} {M : Individual p n} {P : PureForms p n}
    (T H R : ℕ) (ht : ∀ z i,dim (sPin f z i)≤T) (hh : ∀ z i,dim (hPin f z i)≤H)
    (hr : ∀ i e,(M i e).rank≤R)
    (hp : P∈pureSpace p f) (he : obsPair p P=obsI p M) :
    ∃ Q∈pureSpace p f,obsPair p Q=obsPair p P ∧ ∀ e,(Q e).rank≤dqBound p T H R := by
  classical
  choose A hA hL hT using fun i => shrink_both (fun z => sPin f z i) (dualSpace (M i)) T R
    (fun z => ht z i) (fun z => by rw [dualSpace_dim]; exact hr i z.1)
  choose B hB using fun z i => proj_exists (hPin f z i) ⊥ disjoint_bot_right
  let D := jointShrink A B
  have hf (z : Place p) (x : Dir p n) (hx : x∈f z) : D z *ᵥ x=x := by
    have h1 (i : Bool) : rowShrink p (A i) *ᵥ ((IP p n i)ᵀ *ᵥ x)=(IP p n i)ᵀ *ᵥ x :=
      hA i z _ ⟨_,hx,rfl⟩
    have h2 (i : Bool) : B z i *ᵥ ((IH p n i)ᵀ *ᵥ x)=(IH p n i)ᵀ *ᵥ x :=
      (hB z i).fixes _ ⟨_,hx,rfl⟩
    unfold D jointShrink
    simp only [Matrix.sum_mulVec,Matrix.add_mulVec,liftM_def,← Matrix.mulVec_mulVec,h1,h2]
    exact ip_decomp x
  have hR (z : Place p) : (D z).rank ≤ dqBound p T H R := by
    apply le_trans (mrk_sum_le ..)
    have hx i :
        (liftM (IP p n i) (IP p n i) (rowShrink p (A i))+
          liftM (IH p n i) (IH p n i) (B z i)).rank ≤ drow p T R+H :=
      (mrk_add_le ..).trans (add_le_add
        ((rank_lift_le ..).trans (hT i)) ((rank_lift_le ..).trans
        ((rank_maps (hPin f z i) (hB z i).onto).trans (hh z i))))
    rw [Fintype.sum_bool,dqBound,two_mul]; exact add_le_add (hx _) (hx _)
  let Q (e : Comp p.g) := pullM (D (e,true)) (D (e,false)) (P e)
  have hG (i : Bool) (e : Comp p.g) : pullM (rowShrink p (A i)) (rowShrink p (A i)) (M i e)=
      M i e := pullM_fix _ _ (hL i (e,true)) (hL i (e,false))
  have hY (i : Bool) (e : Comp p.g) : eachF p Q i e=
      pullM (rowShrink p (A i)) (rowShrink p (A i)) (eachF p P i e) := by
    change pullM _ _ (Q e)=pullM _ _ (pullM _ _ _)
    let G := IP p n i
    have hw {I J K U V W : Type} [Fintype U] [Fintype V] [Fintype W] [Fintype I]
        [Fintype J] [Fintype K] (L : Mat U I) (R : Mat V J)
        (L' : Mat I K) (R' : Mat J W) (P : Mat U V) :
        pullM L' R' (pullM L R P) = pullM (L*L') (R*R') P := by
      unfold pullM
      rw [liftM_comp,Matrix.transpose_mul,Matrix.transpose_mul]
    unfold Q
    rw [hw,hw]
    have h (b) := joint_ip A B (e,b) i
    rw [show D (e,true)*IP p n i=_ from h true, show D (e,false)*IP p n i=_ from h false]

  refine ⟨Q,?_,?_,fun e => ?_⟩
  · refine (pureSpace_mem _).mpr fun e => ?_
    obtain ⟨h1,h2⟩ := box_kill.mp ((pureSpace_mem _).mp hp e)
    unfold Q; rw [box_kill,pullM_def]; constructor
    · intro x hx
      simp only [transpose_mul,transpose_transpose,←Matrix.mulVec_mulVec,hf (e,true) x hx,h1 x hx,
        mulVec_zero]
    intro x hx
    rw [← mulVec_mulVec,hf (e,false) x hx]
    rw [← mulVec_mulVec,h2 x hx,mulVec_zero]
  · rw [he,obsPair_each]
    rw [obsPair_each] at he
    change combineF p _=combineF p _
    change combineF p _=combineF p _ at he
    have he := (combineF_same ..).mp he
    apply (combineF_same ..).mpr
    intro i x hx
    let y : Profile p n := fun e => liftM (rowShrink p (A i)) (rowShrink p (A i)) (x e)
    rw [repF_rep,repF_rep]
    have hv := he i y (shrink_X (A i) x hx)
    rw [repF_rep,repF_rep] at hv
    have hu (F : Individual p n) : (∑ e,mpair (F i e) (y e))=
        ∑ e,mpair (pullM (rowShrink p (A i)) (rowShrink p (A i)) (F i e)) (x e) :=
      Finset.sum_congr rfl fun e _ => mpair_liftM ..
    rw [hu,hu] at hv
    simp_rw [← hY,hG] at hv
    exact hv
  unfold Q; rw [pullM_def]
  exact ((Matrix.rank_mul_le_left ..).trans (Matrix.rank_mul_le_left ..)).trans
    (by rw [Matrix.rank_transpose]; exact hR _)

end HadwigerCounterexample

end

end OAI