lean/OAI/Algebra/FormulaHitting/Representation.lean

import OAI.Algebra.FormulaHitting.Formula
import Mathlib.Data.Matrix.Block
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Tactic.FinCases

namespace OAI

namespace NCHitting

open Matrix

def automatonValue {F I : Type*} {n : ℕ} [Semiring F] [Fintype I]
    (B : Fin n → Matrix I I F) (u v : I → F) : Word n → F
  | [] => u ⬝ᵥ v
  | i :: w => automatonValue B (u ᵥ* B i) v w

theorem automatonValue_add {F I : Type*} {n : ℕ} [Semiring F] [Fintype I]
    (B : Fin n → Matrix I I F) (u u' v : I → F) (w : Word n) :
    automatonValue B (u + u') v w =
      automatonValue B u v w + automatonValue B u' v w := by
  induction w generalizing u u' with
  | nil => simp [automatonValue, add_dotProduct]
  | cons i w ih => simp [automatonValue, add_vecMul, ih]

theorem automatonValue_smul {F I : Type*} {n : ℕ} [CommSemiring F] [Fintype I]
    (B : Fin n → Matrix I I F) (a : F) (u v : I → F) (w : Word n) :
    automatonValue B (a • u) v w = a * automatonValue B u v w := by
  induction w generalizing u with
  | nil => simp [automatonValue, smul_dotProduct]
  | cons i w ih => simp [automatonValue, smul_vecMul, ih]

theorem automatonValue_zero {F I : Type*} {n : ℕ} [Semiring F] [Fintype I]
    (B : Fin n → Matrix I I F) (v : I → F) (w : Word n) :
    automatonValue B 0 v w = 0 := by
  induction w with
  | nil => simp [automatonValue]
  | cons i w ih => simp [automatonValue, ih]

def wordMatrix {F I : Type*} {n : ℕ} [Semiring F] [Fintype I] [DecidableEq I]
    (B : Fin n → Matrix I I F) (w : Word n) : Matrix I I F :=
  (w.map B).prod

theorem automatonValue_eq_matrix {F I : Type*} {n : ℕ}
    [Semiring F] [Fintype I] [DecidableEq I]
    (B : Fin n → Matrix I I F) (u v : I → F) (w : Word n) :
    automatonValue B u v w = u ⬝ᵥ (wordMatrix B w *ᵥ v) := by
  induction w generalizing u with
  | nil => simp [automatonValue, wordMatrix]
  | cons i w ih =>
    simp only [automatonValue, ih, wordMatrix, List.map_cons, List.prod_cons]
    rw [← dotProduct_mulVec, mulVec_mulVec]

theorem automatonValue_sumBlocks {F I J : Type*} {n : ℕ}
    [Semiring F] [Fintype I] [Fintype J]
    (A : Fin n → Matrix I I F) (B : Fin n → Matrix J J F)
    (u v : I → F) (u' v' : J → F) (w : Word n) :
    automatonValue (fun i => fromBlocks (A i) 0 0 (B i))
        (Sum.elim u u') (Sum.elim v v') w =
      automatonValue A u v w + automatonValue B u' v' w := by
  induction w generalizing u u' with
  | nil => simp [automatonValue, sumElim_dotProduct_sumElim]
  | cons i w ih =>
    simpa [automatonValue, vecMul_fromBlocks, Function.comp_def] using
      ih (u ᵥ* A i) (u' ᵥ* B i)

def productTransition {F I J : Type*} {n : ℕ}
    [Semiring F] [Fintype J]
    (A : Fin n → Matrix I I F) (B : Fin n → Matrix J J F)
    (v : I → F) (u' : J → F) (i : Fin n) : Matrix (I ⊕ J) (I ⊕ J) F :=
  fromBlocks (A i) (vecMulVec v (u' ᵥ* B i)) 0 (B i)

theorem automatonValue_productBlocks_general {F I J : Type*} {n : ℕ}
    [CommSemiring F] [Fintype I] [Fintype J]
    (A : Fin n → Matrix I I F) (B : Fin n → Matrix J J F)
    (u v : I → F) (u' b v' : J → F) (w : Word n) :
    automatonValue (productTransition A B v u') (Sum.elim u b)
        (Sum.elim ((u' ⬝ᵥ v') • v) v') w =
      convolution (automatonValue A u v) (automatonValue B u' v') w +
        automatonValue B b v' w := by
  induction w generalizing u b with
  | nil =>
    simp [automatonValue, convolution, sumElim_dotProduct_sumElim,
      dotProduct_smul, mul_comm]
  | cons i w ih =>
    rw [automatonValue]
    simp only [productTransition, vecMul_fromBlocks, Function.comp_def,
      Sum.elim_inl, Sum.elim_inr, vecMul_zero, add_zero, vecMul_vecMulVec]
    rw [ih, automatonValue_add, automatonValue_smul]
    simp only [convolution, automatonValue]
    ac_rfl

theorem automatonValue_productBlocks {F I J : Type*} {n : ℕ}
    [CommSemiring F] [Fintype I] [Fintype J]
    (A : Fin n → Matrix I I F) (B : Fin n → Matrix J J F)
    (u v : I → F) (u' v' : J → F) (w : Word n) :
    automatonValue (productTransition A B v u') (Sum.elim u 0)
        (Sum.elim ((u' ⬝ᵥ v') • v) v') w =
      convolution (automatonValue A u v) (automatonValue B u' v') w := by
  rw [automatonValue_productBlocks_general, automatonValue_zero, add_zero]

structure AcyclicRepresentation (F : Type*) (n : ℕ) [CommSemiring F] where
  State : Type
  [fintype : Fintype State]
  [decidableEq : DecidableEq State]
  u : State → F
  v : State → F
  B : Fin n → Matrix State State F
  rank : State → ℕ
  rank_lt : ∀ a, rank a < Fintype.card State
  upper : ∀ i a b, rank b ≤ rank a → B i a b = 0

attribute [instance] AcyclicRepresentation.fintype AcyclicRepresentation.decidableEq

namespace AcyclicRepresentation

variable {F : Type*} {n : ℕ} [CommSemiring F]

def value (R : AcyclicRepresentation F n) : WordSeries F n :=
  automatonValue R.B R.u R.v

theorem wordMatrix_entry_zero (R : AcyclicRepresentation F n)
    (w : Word n) (a b : R.State) (h : R.rank b < R.rank a + w.length) :
    wordMatrix R.B w a b = 0 := by
  induction w generalizing a with
  | nil =>
    have hne : a ≠ b := by intro he; subst b; simp at h
    simp [wordMatrix, hne]
  | cons i w ih =>
    simp only [wordMatrix, List.map_cons, List.prod_cons, Matrix.mul_apply]
    apply Finset.sum_eq_zero
    intro c _
    by_cases hc : R.rank c ≤ R.rank a
    · rw [R.upper i a c hc, zero_mul]
    · have hbc : R.rank b < R.rank c + w.length := by
        simp only [List.length_cons] at h
        omega
      rw [show (List.map R.B w).prod c b = 0 from ih c hbc, mul_zero]

theorem wordMatrix_eq_zero (R : AcyclicRepresentation F n)
    (w : Word n) (h : Fintype.card R.State ≤ w.length) : wordMatrix R.B w = 0 := by
  ext a b
  apply R.wordMatrix_entry_zero w a b
  have hb := R.rank_lt b
  omega

theorem value_eq_matrix (R : AcyclicRepresentation F n) (w : Word n) :
    R.value w = R.u ⬝ᵥ (wordMatrix R.B w *ᵥ R.v) :=
  automatonValue_eq_matrix R.B R.u R.v w

def sumRank (R S : AcyclicRepresentation F n) : R.State ⊕ S.State → ℕ :=
  Sum.elim R.rank (fun a => Fintype.card R.State + S.rank a)

theorem sumRank_lt (R S : AcyclicRepresentation F n) (a : R.State ⊕ S.State) :
    sumRank R S a < Fintype.card (R.State ⊕ S.State) := by
  cases a with
  | inl a =>
    have h := R.rank_lt a
    simp only [sumRank, Sum.elim_inl, Fintype.card_sum]
    omega
  | inr a =>
    have h := S.rank_lt a
    simp only [sumRank, Sum.elim_inr, Fintype.card_sum]
    omega

theorem block_upper (R S : AcyclicRepresentation F n)
    (C : Fin n → Matrix R.State S.State F) (i : Fin n)
    (a b : R.State ⊕ S.State) (h : sumRank R S b ≤ sumRank R S a) :
    fromBlocks (R.B i) (C i) 0 (S.B i) a b = 0 := by
  cases a with
  | inl a =>
    cases b with
    | inl b => exact R.upper i a b h
    | inr b =>
      have ha := R.rank_lt a
      simp only [sumRank, Sum.elim_inl, Sum.elim_inr] at h
      omega
  | inr a =>
    cases b with
    | inl b => rfl
    | inr b =>
      apply S.upper i a b
      simp only [sumRank, Sum.elim_inr] at h
      omega

def add (R S : AcyclicRepresentation F n) : AcyclicRepresentation F n where
  State := R.State ⊕ S.State
  fintype := inferInstance
  decidableEq := inferInstance
  u := Sum.elim R.u S.u
  v := Sum.elim R.v S.v
  B i := fromBlocks (R.B i) 0 0 (S.B i)
  rank := sumRank R S
  rank_lt := sumRank_lt R S
  upper := block_upper R S (fun _ => 0)

theorem add_value (R S : AcyclicRepresentation F n) (w : Word n) :
    (R.add S).value w = R.value w + S.value w :=
  automatonValue_sumBlocks R.B S.B R.u R.v S.u S.v w

def mul (R S : AcyclicRepresentation F n) : AcyclicRepresentation F n where
  State := R.State ⊕ S.State
  fintype := inferInstance
  decidableEq := inferInstance
  u := Sum.elim R.u 0
  v := Sum.elim ((S.u ⬝ᵥ S.v) • R.v) S.v
  B := productTransition R.B S.B R.v S.u
  rank := sumRank R S
  rank_lt := sumRank_lt R S
  upper := block_upper R S (fun i => vecMulVec R.v (S.u ᵥ* S.B i))

theorem mul_value (R S : AcyclicRepresentation F n) (w : Word n) :
    (R.mul S).value w = convolution R.value S.value w :=
  automatonValue_productBlocks R.B S.B R.u R.v S.u S.v w

def scalar (a : F) : AcyclicRepresentation F n where
  State := Unit
  fintype := inferInstance
  decidableEq := inferInstance
  u _ := a
  v _ := 1
  B _ := 0
  rank _ := 0
  rank_lt _ := by simp
  upper _ _ _ _ := rfl

theorem scalar_value (a : F) (w : Word n) :
    (scalar (n := n) a).value w = if w = [] then a else 0 := by
  cases w with
  | nil =>
    change (∑ _ : Unit, a * 1) = a
    simp
  | cons i w =>
    change automatonValue (fun _ : Fin n => (0 : Matrix Unit Unit F))
      ((fun _ : Unit => a) ᵥ* 0) (fun _ => 1) w = 0
    rw [vecMul_zero, automatonValue_zero]

def ofVariable (i : Fin n) : AcyclicRepresentation F n where
  State := Fin 2
  fintype := inferInstance
  decidableEq := inferInstance
  u a := if a = 0 then 1 else 0
  v a := if a = 1 then 1 else 0
  B j a b := if a = 0 ∧ b = 1 ∧ j = i then 1 else 0
  rank a := a.val
  rank_lt a := by simp
  upper j a b h := by
    by_cases hab : a = 0 ∧ b = 1 ∧ j = i
    · rcases hab with ⟨rfl, rfl, _⟩
      simp at h
    · simp [hab]

theorem variable_value (i : Fin n) (w : Word n) :
    (ofVariable (F := F) i).value w = if w = [i] then 1 else 0 := by
  change automatonValue
    (fun j (a b : Fin 2) => if a = 0 ∧ b = 1 ∧ j = i then (1 : F) else 0)
    (fun a : Fin 2 => if a = 0 then 1 else 0)
    (fun a : Fin 2 => if a = 1 then 1 else 0) w = _
  cases w with
  | nil => simp [automatonValue, dotProduct]
  | cons j w =>
    cases w with
    | nil =>
      simp [automatonValue, vecMul, dotProduct, Fin.sum_univ_two]
    | cons k w =>
      have hz : ((ofVariable (F := F) i).u ᵥ* (ofVariable i).B j) ᵥ*
          (ofVariable i).B k = 0 := by
        change ((fun a : Fin 2 => if a = 0 then (1 : F) else 0) ᵥ*
          (fun a b : Fin 2 => if a = 0 ∧ b = 1 ∧ j = i then 1 else 0)) ᵥ*
          (fun a b : Fin 2 => if a = 0 ∧ b = 1 ∧ k = i then 1 else 0) = 0
        ext a
        change _ = (0 : F)
        fin_cases a <;>
          simp [vecMul, dotProduct, Fin.sum_univ_two]
      rw [ite_eq_right (show (j :: k :: w : Word n) ≠ [i] by simp)]
      change automatonValue (ofVariable (F := F) i).B
        (((ofVariable i).u ᵥ* (ofVariable i).B j) ᵥ* (ofVariable i).B k)
        (ofVariable i).v w = 0
      rw [hz, automatonValue_zero]

@[simp] theorem scalar_card (a : F) : Fintype.card (scalar (n := n) a).State = 1 := rfl

@[simp] theorem variable_card (i : Fin n) :
    Fintype.card (ofVariable (F := F) i).State = 2 := rfl

@[simp] theorem add_card (R S : AcyclicRepresentation F n) :
    Fintype.card (R.add S).State = Fintype.card R.State + Fintype.card S.State :=
  Fintype.card_sum

@[simp] theorem mul_card (R S : AcyclicRepresentation F n) :
    Fintype.card (R.mul S).State = Fintype.card R.State + Fintype.card S.State :=
  Fintype.card_sum

end AcyclicRepresentation

noncomputable def Formula.representation {F : Type*} {n : ℕ} [CommSemiring F] :
    Formula F n → AcyclicRepresentation F n
  | .scalar a => .scalar a
  | .var i => .ofVariable i
  | .add f g => f.representation.add g.representation
  | .mul f g => f.representation.mul g.representation

theorem Formula.representation_card_le {F : Type*} {n : ℕ} [CommSemiring F]
    (f : Formula F n) : Fintype.card f.representation.State ≤ 2 * f.size := by
  induction f with
  | scalar a => change 1 ≤ 2 * 1; decide
  | var i => change 2 ≤ 2 * 1; decide
  | add f g ihf ihg =>
    change Fintype.card (f.representation.State ⊕ g.representation.State) ≤
      2 * (f.size + g.size + 1)
    rw [Fintype.card_sum]
    omega
  | mul f g ihf ihg =>
    change Fintype.card (f.representation.State ⊕ g.representation.State) ≤
      2 * (f.size + g.size + 1)
    rw [Fintype.card_sum]
    omega

theorem Formula.representation_card_pos {F : Type*} {n : ℕ} [CommSemiring F]
    (f : Formula F n) : 0 < Fintype.card f.representation.State := by
  induction f with
  | scalar a => change 0 < 1; decide
  | var i => change 0 < 2; decide
  | add f g ihf ihg =>
    change 0 < Fintype.card (f.representation.State ⊕ g.representation.State)
    rw [Fintype.card_sum]
    omega
  | mul f g ihf ihg =>
    change 0 < Fintype.card (f.representation.State ⊕ g.representation.State)
    rw [Fintype.card_sum]
    omega

theorem Formula.representation_correct {F : Type*} {n : ℕ} [CommSemiring F]
    (f : Formula F n) (w : Word n) : f.representation.value w = f.coeff w := by
  induction f generalizing w with
  | scalar a => exact AcyclicRepresentation.scalar_value a w
  | var i => exact AcyclicRepresentation.variable_value i w
  | add f g ihf ihg =>
    simp only [Formula.representation, AcyclicRepresentation.add_value,
      Formula.coeff, ihf, ihg]
  | mul f g ihf ihg =>
    simp only [Formula.representation, AcyclicRepresentation.mul_value, Formula.coeff]
    congr 1 <;> funext w <;> first | exact ihf w | exact ihg w

theorem Formula.coeff_zero_of_representation_dimension_le
    {F : Type*} {n : ℕ} [CommSemiring F] (f : Formula F n) (w : Word n)
    (h : Fintype.card f.representation.State ≤ w.length) : f.coeff w = 0 := by
  rw [← f.representation_correct w, f.representation.value_eq_matrix,
    f.representation.wordMatrix_eq_zero w h]
  simp

end NCHitting

end OAI