import OAI.Computability.WLIdentification.LocalPresentation

namespace OAI

namespace WLIdentification
namespace FinitePresentation
open WordExpressions
variable {A : Word → Type} {P : Presented A} {G : ∀ w, SimpleGraph (A w)}

namespace PresentedGraph
variable (Q : PresentedGraph P G)

theorem adjacent_poly_of {n} {w : (Fin n → Word) → Word} {i j : (Fin n → Word) → ℕ}
    (hw : Poly w) (hi : NatPoly i) (hj : NatPoly j) :
    BoolPoly (fun S => Q.adjacent (w S) (i S) (j S)) := by
  have h := Q.adjacent_poly.subst (g := ![w, fun S => unary (i S), fun S => unary (j S)])
    (by intro k; fin_cases k; exacts [hw,hi,hj])
  simpa [unary] using h

def leafAdj (w : Word) (i j : ℕ) : Bool := if i%2=0 then
  if j%2=0 then Q.adjacent w (i/2) (j/2) else decide (i/2=(Nat.unpair (j/2)).1)
  else if j%2=0 then decide ((Nat.unpair (i/2)).1=j/2) else false

def leaves {ell : ∀ w, A w → ℕ} (E : Number P ell) :
    PresentedGraph (P.sum (P.finSigma E)) (fun w => withLeaves (G w) (ell w)) where
  adjacent := Q.leafAdj
  adjacent_iff w x y := by
    cases x with
    | inl x => cases y with
      | inl y =>
        change Q.leafAdj w (2*P.code w x) (2*P.code w y)=true ↔ (G w).Adj x y
        simpa [leafAdj] using Q.adjacent_iff w x y
      | inr y =>
        change Q.leafAdj w (2*P.code w x) (2*Nat.pair (P.code w y.1) y.2.val+1)=true ↔ x=y.1
        simp [leafAdj, show (2*Nat.pair (P.code w y.1) y.2.val+1)/2=Nat.pair (P.code w y.1) y.2.val by omega,
          (P.code w).injective.eq_iff]
    | inr x => cases y with
      | inl y =>
        change Q.leafAdj w (2*Nat.pair (P.code w x.1) x.2.val+1) (2*P.code w y)=true ↔ x.1=y
        simp [leafAdj, show (2*Nat.pair (P.code w x.1) x.2.val+1)/2=Nat.pair (P.code w x.1) x.2.val by omega,
          (P.code w).injective.eq_iff]
      | inr y =>
        change Q.leafAdj w (2*Nat.pair (P.code w x.1) x.2.val+1) (2*Nat.pair (P.code w y.1) y.2.val+1)=true ↔ False
        simp [leafAdj]
  adjacent_poly := by
    unfold leafAdj
    apply BoolPoly.iteProp (by word_poly)
    · apply BoolPoly.iteProp (by word_poly)
      · apply Q.adjacent_poly_of <;> word_poly
      · word_poly
    · apply BoolPoly.iteProp <;> word_poly

variable [∀ w, Fintype (A w)]

noncomputable def tags {color : ∀ w, A w → ℕ} (F : Number P color) :
    Number P (fun w => tagSize (color w)) :=
  (F.mul (Number.param P (fun w => P.card w+1) (NatPoly.succ P.card_poly))).congr (by
    intro w x
    simp only [tagSize, Presented.card_eq])

noncomputable def tagged {color : ∀ w, A w → ℕ} (F : Number P color) := Q.leaves (tags F)

end PresentedGraph
end FinitePresentation
namespace FinitePresentation
open WordExpressions

theorem rows_get (n m : ℕ) (f : Fin n → Fin m → Bool) (i : Fin n) (j : Fin m) :
    (((List.ofFn fun a => List.ofFn (f a)).flatten)[i.val*m+j.val]?).getD false = f i j := by
  induction n with
  | zero => exact i.elim0
  | succ n ih =>
    simp only [List.ofFn_succ, List.flatten_cons]
    refine Fin.cases ?_ (fun a => ?_) i
    · rw [List.getElem?_append_left (by simp)]
      simp
    · rw [List.getElem?_append_right (by simp only [List.length_ofFn, Fin.val_succ]; nlinarith)]
      simp only [List.length_ofFn, Fin.val_succ]
      rw [show (a.val+1)*m+j.val-m=a.val*m+j.val by simp only [Nat.add_mul, one_mul]; omega]
      exact ih (fun x => f x.succ) a

namespace PresentedGraph
variable {A : Word → Type} {P : Presented A} {G : ∀ w, SimpleGraph (A w)} (Q : PresentedGraph P G)

def matrix (w : Word) : Word := (List.range (P.card w * P.card w)).map
  (fun i => Q.adjacent w (P.select w (i/P.card w)) (P.select w (i%P.card w)))

theorem matrix_eq (w : Word) : Q.matrix w=matrixWord (Q.graph w) := by
  apply List.ext_getElem (by simp [matrix, matrixWord_length, graph])
  intro i hi hj
  have hi' : i<P.card w*P.card w := by simpa [matrix] using hi
  have hn : 0<P.card w := by nlinarith
  have hdiv := Nat.div_lt_of_lt_mul hi'
  have hmod := Nat.mod_lt i hn
  have hentry := rows_get (P.card w) (P.card w) (Q.graph w).edge ⟨i/P.card w,hdiv⟩ ⟨i%P.card w,hmod⟩
  rw [show i/P.card w*P.card w+i%P.card w=i by simpa only [Nat.mul_comm] using Nat.div_add_mod i (P.card w)] at hentry
  change (matrixWord (Q.graph w))[i]?.getD false = _ at hentry
  rw [List.getElem?_eq_getElem hj, Option.getD_some] at hentry
  simpa only [matrix, List.getElem_map, List.getElem_range, graph] using hentry.symm

theorem matrix_poly : Poly (fun S : Fin 1 → Word => Q.matrix (S 0)) := by
  apply Poly.tabulateRange (NatPoly.mul P.card_poly P.card_poly)
  apply Q.adjacent_poly_of (Poly.var 0)
  · apply P.select_poly_of (Poly.var 0)
    exact NatPoly.div (NatPoly.var 1) (P.card_poly_of (Poly.var 0))
  · apply P.select_poly_of (Poly.var 0)
    exact NatPoly.mod (NatPoly.var 1) (P.card_poly_of (Poly.var 0))

def output (k : Word → ℕ) (w : Word) : Word :=
  List.replicate (P.card w) true ++ [false] ++ Q.matrix w ++ binaryWord (k w)

theorem output_eq (k : Word → ℕ) (w : Word) : Q.output k w=inputWord (Q.graph w) (binaryWord (k w)) := by
  simp only [output, Q.matrix_eq, inputWord, graph]

theorem output_poly {k : Word → ℕ} (hk : NatPoly (fun S : Fin 1 → Word => k (S 0))) :
    Poly (fun S : Fin 1 → Word => Q.output k (S 0)) :=
  Poly.append (Poly.append (Poly.append (Poly.replicate P.card_poly true) (WordExpressions.Poly.const [false])) Q.matrix_poly)
    (Poly.binary hk)

end PresentedGraph
end FinitePresentation

theorem identifies_isomorphic {G H : Graph} (e : Isomorphic G H) (k : ℕ) : Identifies k G ↔ Identifies k H := by
  constructor
  · intro h I hI
    exact isomorphic_trans (isomorphic_symm e) (h I (equivalent_trans (isomorphic_equivalent e k) hI))
  · intro h I hI
    exact isomorphic_trans e (h I (equivalent_trans (isomorphic_equivalent (isomorphic_symm e) k) hI))

theorem WLdim_isomorphic {G H : Graph} (e : Isomorphic G H) : WLdim G=WLdim H := by
  apply Nat.le_antisymm
  · rw [WLdim_le_iff ((WLdim_spec H).1), identifies_isomorphic e]
    exact (WLdim_le_iff ((WLdim_spec H).1)).mp (le_refl _)
  · rw [WLdim_le_iff ((WLdim_spec G).1), identifies_isomorphic (isomorphic_symm e)]
    exact (WLdim_le_iff ((WLdim_spec G).1)).mp (le_refl _)

end WLIdentification

end OAI