import Mathlib
import OAI.Probability.SKGap.Matrix.FockTensor

namespace OAI

section

noncomputable section
open scoped BigOperators
namespace SKGap.Noncrossing.Primary.Tensor.Loop
open Diagram InverseDiagram WordSeries
variable {ι : Type*} [Fintype ι]

lemma blockDegree_reverse (bs : List Bool) : blockDegree bs.reverse=blockDegree bs := by
  simp [blockDegree,List.map_reverse]
def blockReverse (n : ℕ) : Blocks n ≃ Blocks n where
  toFun bs := ⟨bs.val.reverse,by rw [blockDegree_reverse]; exact bs.property⟩
  invFun bs := ⟨bs.val.reverse,by rw [blockDegree_reverse]; exact bs.property⟩
  left_inv bs := Subtype.ext (List.reverse_reverse bs.val)
  right_inv bs := Subtype.ext (List.reverse_reverse bs.val)

def blockPrepend (n : ℕ) : Blocks (n+1) ⊕ Blocks n → Blocks (n+2)
  | .inl bs => ⟨true::bs.val,by rw [blockDegree_true,bs.property]⟩
  | .inr bs => ⟨false::bs.val,by rw [blockDegree_false,bs.property]⟩
lemma blockPrepend_bijective (n : ℕ) : Function.Bijective (blockPrepend n) := by
  constructor
  · intro x y h
    have hv := congrArg (fun q : Blocks (n+2) => q.val) h
    cases x <;> cases y <;> simp only [blockPrepend] at hv
    · exact congrArg Sum.inl (Subtype.ext (List.cons.inj hv).2)
    · exact False.elim (Bool.noConfusion (List.cons.inj hv).1)
    · exact False.elim (Bool.noConfusion (List.cons.inj hv).1)
    · exact congrArg Sum.inr (Subtype.ext (List.cons.inj hv).2)
  · rintro ⟨bs,hbs⟩
    cases bs with
    | nil => simp only [blockDegree_nil] at hbs; omega
    | cons b bs =>
      cases b with
      | true => exact ⟨.inl ⟨bs,by rw [blockDegree_true] at hbs; omega⟩,rfl⟩
      | false => exact ⟨.inr ⟨bs,by rw [blockDegree_false] at hbs; omega⟩,rfl⟩

def blockSnocEquiv (n : ℕ) : Blocks (n+1) ⊕ Blocks n ≃ Blocks (n+2) :=
  ((blockReverse (n+1)).sumCongr (blockReverse n)).trans
    ((Equiv.ofBijective (blockPrepend n) (blockPrepend_bijective n)).trans (blockReverse (n+2)))
@[simp] lemma blockSnocEquiv_inl (n : ℕ) (bs : Blocks (n+1)) :
    (blockSnocEquiv n (.inl bs)).val=bs.val++[true] := by
  change (true::bs.val.reverse).reverse=bs.val++[true]
  simp
@[simp] lemma blockSnocEquiv_inr (n : ℕ) (bs : Blocks n) :
    (blockSnocEquiv n (.inr bs)).val=bs.val++[false] := by
  change (false::bs.val.reverse).reverse=bs.val++[false]
  simp

lemma sum_blocks_snoc {M : Type*} [AddCommMonoid M] (n : ℕ) (f : List Bool→M) :
    (∑ bs : Blocks (n+2),f bs.val)=
      (∑ bs : Blocks (n+1),f (bs.val++[true]))+(∑ bs : Blocks n,f (bs.val++[false])) := by
  have h := Fintype.sum_equiv (blockSnocEquiv n)
    (fun s => match s with | .inl bs => f (bs.val++[true]) | .inr bs => f (bs.val++[false]))
    (fun bs => f bs.val) (by intro s; cases s <;> simp)
  exact h.symm.trans (Fintype.sum_sum_type _)

lemma blocks_one (bs : Blocks 1) : bs.val=[true] := by
  have h := (mem_blockEnumerate bs.val 1).mpr bs.property
  simpa [blockEnumerate] using h
instance blocksOneUnique : Unique (Blocks 1) where
  default := ⟨[true],rfl⟩
  uniq bs := Subtype.ext (blocks_one bs)

def kernel (j : ℝ) (a : ι→ℝ) (n : ℕ) : Space (ι:=ι)→ₗ[ℝ] Space (ι:=ι) :=
  ∑ bs : Blocks n,word j (chain j a bs.val)
lemma kernel_zero (j : ℝ) (a : ι→ℝ) : kernel j a 0=LinearMap.id := by
  simp [kernel,blocks_zero,word]
lemma kernel_one (j : ℝ) (a : ι→ℝ) : kernel j a 1=(diagonal a).comp (noise j) := by
  simp [kernel,blocks_one,word,letter]
lemma kernel_add_two (j : ℝ) (a : ι→ℝ) (n : ℕ) :
    kernel j a (n+2)=(kernel j a (n+1)).comp ((diagonal a).comp (noise j))-
      (j*Diagram.mean a) • (kernel j a n).comp (diagonal a) := by
  refine (sum_blocks_snoc n (fun bs => word j (chain j a bs))).trans ?_
  simp only [chain_append,chain_true,chain_false,chain_nil,word_append,word,letter,
    LinearMap.comp_id,diagonal_scale,LinearMap.comp_smul]
  ext v i I
  simp [kernel,LinearMap.sum_apply,LinearMap.comp_apply,Finset.sum_neg_distrib,
    ←Finset.mul_sum,sub_eq_add_neg]

lemma project_kernel_zero_creation (j : ℝ) (a p : ι→ℝ) (v : Space (ι:=ι)) :
    project (kernel j a 0 (diagonal p (creation v)))=0 := by
  rw [kernel_zero]; exact project_diagonal_creation p v

lemma project_kernel_creation (j : ℝ) (a : ι→ℝ) (n : ℕ) (v : Space (ι:=ι)) :
    project (kernel j a (n+1) (diagonal a (creation v)))=
      (j*Diagram.mean a) • project (kernel j a n (diagonal a v)) := by
  induction n generalizing v with
  | zero =>
    simp only [kernel_one,kernel_zero,LinearMap.comp_apply,LinearMap.id_apply,noise,
      LinearMap.add_apply,LinearMap.smul_apply,map_add,map_smul,
      annihilation_diagonal_creation,project_diagonal_creation,zero_add,smul_smul]
  | succ n ih =>
    rw [show n+1+1=n+2 by omega,kernel_add_two]
    simp only [LinearMap.sub_apply,LinearMap.comp_apply,LinearMap.smul_apply,noise,
      LinearMap.add_apply,annihilation_diagonal_creation,map_add,map_sub,map_smul,
      smul_smul]
    rw [ih]
    abel

lemma project_kernel_incoming (j : ℝ) (a p : ι→ℝ) (n : ℕ) (v : Space (ι:=ι)) :
    project (kernel j a (n+1) (diagonal p (creation v)))=
      (j*Diagram.mean p) • project (kernel j a n (diagonal a v)) := by
  cases n with
  | zero =>
    simp only [kernel_one,kernel_zero,LinearMap.comp_apply,LinearMap.id_apply,noise,
      LinearMap.add_apply,LinearMap.smul_apply,map_add,map_smul,
      annihilation_diagonal_creation,project_diagonal_creation,zero_add,smul_smul]
  | succ n =>
    rw [show n+1+1=n+2 by omega,kernel_add_two]
    simp only [LinearMap.sub_apply,LinearMap.comp_apply,LinearMap.smul_apply,noise,
      LinearMap.add_apply,annihilation_diagonal_creation,map_add,map_sub,map_smul,
      smul_smul]
    rw [project_kernel_creation]
    abel
end SKGap.Noncrossing.Primary.Tensor.Loop

end
end

end OAI