import Mathlib
import OAI.Probability.BinarySweep.MatrixBounds.TraceHolder

namespace OAI

noncomputable section
open scoped BigOperators Matrix.Norms.L2Operator

namespace BinaryCoordinateSweeps.TraceHolder

section Expansion
variable {P R : Type*} [Fintype P] [DecidableEq P] [Semiring R]

def pathProduct {n : ℕ} (A : Fin n → Matrix P P R) (x : Fin n → P) (b : P) : R :=
  (List.ofFn fun j => A j (x j) (Fin.snoc (α := fun _ => P) x b j.succ)).prod

omit [Fintype P] [DecidableEq P] in
lemma snoc_cons_succ {n : ℕ} (a : P) (x : Fin n → P) (b : P) (j : Fin (n+1)) :
    Fin.snoc (α := fun _ => P) (Fin.cons a x) b j.succ =
      Fin.snoc (α := fun _ => P) x b j := by
  refine Fin.lastCases ?_ (fun i => ?_) j
  · simp
  · rw [Fin.succ_castSucc]
    simp only [Fin.snoc_castSucc, Fin.cons_succ]

omit [Fintype P] [DecidableEq P] in
lemma pathProduct_cons {n : ℕ} (A : Fin (n+1) → Matrix P P R)
    (a : P) (x : Fin n → P) (b : P) :
    pathProduct A (Fin.cons a x) b =
      A 0 a (Fin.snoc (α := fun _ => P) x b 0) * pathProduct (fun j => A j.succ) x b := by
  simp only [pathProduct, List.ofFn_succ, List.prod_cons, Fin.cons_zero, Fin.cons_succ,
    snoc_cons_succ]

lemma prod_apply_sum_path {n : ℕ} (A : Fin (n+1) → Matrix P P R) (a b : P) :
    (List.ofFn A).prod a b = ∑ x : Fin n → P, pathProduct A (Fin.cons a x) b := by
  induction n generalizing a with
  | zero => simp [pathProduct, Fin.snoc]
  | succ n ih =>
      rw [List.ofFn_succ, List.prod_cons, Matrix.mul_apply]
      simp_rw [ih]
      rw [← (Fin.consEquiv (fun _ : Fin (n+1) => P)).sum_comp, Fintype.sum_prod_type]
      apply Finset.sum_congr rfl
      intro c _
      rw [Finset.mul_sum]
      apply Finset.sum_congr rfl
      intro x _
      change A 0 a c * pathProduct (fun j => A j.succ) (Fin.cons c x) b =
        pathProduct A (Fin.cons a (Fin.cons c x)) b
      rw [pathProduct_cons A]
      congr 2

omit [Fintype P] [DecidableEq P] in
lemma snoc_cycle {n : ℕ} (x : Fin (n+1) → P) (j : Fin (n+1)) :
    Fin.snoc (α := fun _ => P) x (x 0) j.succ = x (finRotate (n+1) j) := by
  refine Fin.lastCases ?_ (fun i => ?_) j
  · simp
  · rw [Fin.succ_castSucc, Fin.snoc_castSucc]
    simp [finRotate_apply, Fin.coeSucc_eq_succ]

lemma trace_prod_eq_sum_cycles {n : ℕ} (A : Fin (n+1) → Matrix P P R) :
    Matrix.trace (List.ofFn A).prod =
      ∑ x : Fin (n+1) → P,
        (List.ofFn fun j => A j (x j) (x (finRotate (n+1) j))).prod := by
  change (∑ i : P, (List.ofFn A).prod i i) = _
  simp_rw [prod_apply_sum_path]
  calc
    _ = ∑ y : P × (Fin n → P), pathProduct A (Fin.cons y.1 y.2) y.1 := by
      exact (Fintype.sum_prod_type (fun y : P × (Fin n → P) =>
        pathProduct A (Fin.cons y.1 y.2) y.1)).symm
    _ = ∑ x : Fin (n+1) → P, pathProduct A x (x 0) := by
      simpa only [Fin.consEquiv, Equiv.coe_fn_mk, Fin.cons_zero] using
        (Fin.consEquiv (fun _ : Fin (n+1) => P)).sum_comp (fun x => pathProduct A x (x 0))
    _ = _ := by
      apply Finset.sum_congr rfl
      intro x _
      simp only [pathProduct, snoc_cycle]
end Expansion

variable {P ι : Type*} [Fintype P] [DecidableEq P] [Fintype ι] [DecidableEq ι]

def flattenBlocks (A : Matrix P P (M ι)) : M (P × ι) :=
  fun x y => A x.1 y.1 x.2 y.2

omit [DecidableEq P] [DecidableEq ι] in
lemma flattenBlocks_mul (A B : Matrix P P (M ι)) :
    flattenBlocks (A * B) = flattenBlocks A * flattenBlocks B := by
  ext x y
  simp only [flattenBlocks, Matrix.mul_apply, Fintype.sum_prod_type, Matrix.sum_apply]

omit [Fintype P] [Fintype ι] in
lemma flattenBlocks_one : flattenBlocks (1 : Matrix P P (M ι)) = 1 := by
  ext ⟨x,i⟩ ⟨y,j⟩
  by_cases hxy : x = y <;> by_cases hij : i = j <;>
    simp [flattenBlocks, Matrix.one_apply, hxy, hij, Prod.mk.injEq]

def flattenBlocksHom : Matrix P P (M ι) →* M (P × ι) where
  toFun := flattenBlocks
  map_one' := flattenBlocks_one
  map_mul' := flattenBlocks_mul

omit [DecidableEq P] [DecidableEq ι] in
lemma trace_flattenBlocks (A : Matrix P P (M ι)) :
    Matrix.trace (flattenBlocks A) = Matrix.trace (Matrix.trace A) := by
  change (∑ x : P × ι, A x.1 x.1 x.2 x.2) = ∑ i : ι, (∑ p : P, A p p) i i
  simp only [Fintype.sum_prod_type, Matrix.sum_apply]
  exact Finset.sum_comm

lemma trace_flatten_prod {n : ℕ} (A : Fin (n+1) → Matrix P P (M ι)) :
    Matrix.trace (List.ofFn (fun j => flattenBlocks (A j))).prod =
      ∑ x : Fin (n+1) → P,
        Matrix.trace (List.ofFn fun j => A j (x j) (x (finRotate (n+1) j))).prod := by
  have hp : (List.ofFn (fun j => flattenBlocks (A j))).prod =
      flattenBlocks (List.ofFn A).prod := by
    simpa only [List.map_ofFn, flattenBlocksHom, MonoidHom.coe_mk, OneHom.coe_mk, Function.comp_def] using
      (map_list_prod (flattenBlocksHom (P := P) (ι := ι)) (List.ofFn A)).symm
  rw [hp, trace_flattenBlocks, trace_prod_eq_sum_cycles, Matrix.trace_sum]

theorem block_trace_holder {q : ℕ} (hq : 0 < q)
    (A : Fin (2*q) → Matrix P P (M ι)) :
    ‖Matrix.trace (List.ofFn (fun j => flattenBlocks (A j))).prod‖ ≤
      ∑ x : Fin (2*q) → P,
        ∏ j, matrixMoment q (A j (x j) (x (finRotate (2*q) j))) ^ (((2*q : ℕ) : ℝ)⁻¹) := by
  have ht : Matrix.trace (List.ofFn (fun j => flattenBlocks (A j))).prod =
      ∑ x : Fin (2*q) → P,
        Matrix.trace (List.ofFn fun j => A j (x j) (x (finRotate (2*q) j))).prod := by
    generalize hm : 2*q = m at A ⊢
    cases m with
    | zero => omega
    | succ n => exact trace_flatten_prod A
  rw [ht]
  exact (norm_sum_le _ _).trans (Finset.sum_le_sum fun x _ => matrix_trace_holder hq _)

theorem weighted_block_trace_holder {q : ℕ} (hq : 0 < q)
    (p : Fin (2*q) → P → P → ℝ) (hp : ∀ j x y, 0 ≤ p j x y)
    (F : Fin (2*q) → P → P → M ι) :
    ‖Matrix.trace (List.ofFn fun j => flattenBlocks
      (fun x y => p j x y • F j x y)).prod‖ ≤
      ∑ x : Fin (2*q) → P,
        (∏ j, p j (x j) (x (finRotate (2*q) j))) *
        ∏ j, matrixMoment q (F j (x j) (x (finRotate (2*q) j))) ^ (((2*q : ℕ) : ℝ)⁻¹) := by
  have ht : Matrix.trace (List.ofFn fun j => flattenBlocks
      (fun x y => p j x y • F j x y)).prod =
      ∑ x : Fin (2*q) → P,
        Matrix.trace (List.ofFn fun j => p j (x j) (x (finRotate (2*q) j)) •
          F j (x j) (x (finRotate (2*q) j))).prod := by
    generalize hm : 2*q = m at p F ⊢
    cases m with
    | zero => omega
    | succ n => exact trace_flatten_prod _
  rw [ht]
  apply (norm_sum_le _ _).trans
  apply Finset.sum_le_sum
  intro x _
  rw [prod_ofFn_smul, Matrix.trace_smul, norm_smul, Real.norm_eq_abs,
    abs_of_nonneg (Finset.prod_nonneg (fun j _ => hp j _ _))]
  exact mul_le_mul_of_nonneg_left (matrix_trace_holder hq _)
    (Finset.prod_nonneg (fun j _ => hp j _ _))

end BinaryCoordinateSweeps.TraceHolder

end

end OAI