import OAI.Computability.DegreeRigidity.Effective.TableIndices

namespace OAI

namespace TuringRigidity.IndexMatrix
open Encodable UniformOracle CommonIdeal TableIndices

def machine (e : ℕ) : Nat.Partrec.Code := (decode e).getD .zero

theorem machine_primrec : Primrec machine :=
  Primrec.option_getD.comp Primrec.decode (Primrec.const Nat.Partrec.Code.zero)

@[simp] theorem machine_encode (d : Nat.Partrec.Code) : machine (encode d) = d := by
  simp [machine]

theorem run_uniform_recursive (Y : Oracle) :
    Nat.RecursiveIn {oracleFunction Y} (fun v => Part.some
      (encode (run Y (machine (Nat.unpair v).1)
        (Nat.unpair (Nat.unpair v).2).1 (Nat.unpair (Nat.unpair v).2).2))) := by
  let O : Set (ℕ →. ℕ) := {oracleFunction Y}
  let e := Primrec.fst.comp Primrec.unpair
  let rest := Primrec.snd.comp Primrec.unpair
  let n := Primrec.fst.comp (Primrec.unpair.comp rest)
  let z := Primrec.snd.comp (Primrec.unpair.comp rest)
  have he := total_primrec (O := O) e
  have hn := total_primrec (O := O) n
  have hm := total_primrec (O := O) (Primrec.fst.comp (Primrec.unpair.comp z))
  have ht := total_primrec (O := O) (Primrec.snd.comp (Primrec.unpair.comp z))
  have hL := total_comp (prefix_recursive (fun k => bit (Y k))) hm
  let r := Primrec.snd.comp Primrec.unpair
  have hdecode := total_primrec (O := O) (Primrec.encode.comp (Nat.Partrec.Code.primrec_evaln.comp
    (((Primrec.fst.comp Primrec.unpair).pair
      (machine_primrec.comp (Primrec.fst.comp (Primrec.unpair.comp r)))).pair
      (Primrec.snd.comp (Primrec.unpair.comp r)))))
  exact (total_comp hdecode (total_pair ht (total_pair he (total_pair hL hn)))).of_eq
    (fun v => by simp [TableIndices.run, trial])

def validMatrix (Y : Oracle) (e q r : ℕ) : Prop :=
  run Y (machine e) (Nat.unpair q).1 (Nat.unpair r).1 =
      some (bit (Nat.unpair r).2.bodd) ∧
    let a := run Y (machine e) (Nat.unpair q).1 (Nat.unpair (Nat.unpair q).2).1
    let b := run Y (machine e) (Nat.unpair q).1 (Nat.unpair (Nat.unpair q).2).2
    a = none ∨ b = none ∨ a = b

instance (Y : Oracle) (e q r : ℕ) : Decidable (validMatrix Y e q r) := by
  unfold validMatrix
  infer_instance

theorem valid_normal_form (Y : Oracle) (e : ℕ) :
    Valid Y (machine e) ↔ ∀ q, ∃ r, validMatrix Y e q r := by
  constructor
  · rintro ⟨ht, hc⟩ q
    obtain ⟨z, b, hb⟩ := ht (Nat.unpair q).1
    refine ⟨Nat.pair z (if b then 1 else 0), ?_, ?_⟩
    · cases b <;> simpa [Nat.unpair_pair] using hb
    · dsimp only
      cases ha : run Y (machine e) (Nat.unpair q).1 (Nat.unpair (Nat.unpair q).2).1 with
      | none => exact Or.inl rfl
      | some a =>
        cases hb : run Y (machine e) (Nat.unpair q).1 (Nat.unpair (Nat.unpair q).2).2 with
        | none => exact Or.inr (Or.inl rfl)
        | some b => exact Or.inr (Or.inr (congrArg some
            (hc _ _ _ _ _ (Option.mem_def.mpr ha) (Option.mem_def.mpr hb))))
  · intro h
    constructor
    · intro n
      obtain ⟨r, hr, _⟩ := h (Nat.pair n (Nat.pair 0 0))
      exact ⟨(Nat.unpair r).1, (Nat.unpair r).2.bodd, by simpa using hr⟩
    · intro n z w a b ha hb
      obtain ⟨r, _, hc⟩ := h (Nat.pair n (Nat.pair z w))
      simp only [Nat.unpair_pair] at hc
      rcases hc with hc | hc | hc
      · rw [hc] at ha; simp at ha
      · rw [hc] at hb; simp at hb
      · rw [Option.mem_def.mp ha, Option.mem_def.mp hb] at hc
        exact Option.some.inj hc

def checkMatrix (v : ℕ) : ℕ :=
  let wanted := (Nat.unpair v).1
  let s := (decode (α := Option ℕ) (Nat.unpair (Nat.unpair v).2).1).getD none
  let a := (decode (α := Option ℕ) (Nat.unpair (Nat.unpair (Nat.unpair v).2).2).1).getD none
  let b := (decode (α := Option ℕ) (Nat.unpair (Nat.unpair (Nat.unpair v).2).2).2).getD none
  if s = some (bit wanted.bodd) ∧ (a = none ∨ b = none ∨ a = b) then 1 else 0

theorem checkMatrix_primrec : Primrec checkMatrix := by
  let first := Primrec.fst.comp Primrec.unpair
  let rest := Primrec.snd.comp Primrec.unpair
  let dec : Primrec (fun v : ℕ => (decode (α := Option ℕ) v).getD none) :=
    Primrec.option_getD.comp Primrec.decode (Primrec.const none)
  let s := dec.comp (first.comp rest)
  let a := dec.comp (first.comp (rest.comp rest))
  let b := dec.comp (rest.comp (rest.comp rest))
  let want := Primrec.option_some.comp (bit_primrec.comp (Primrec.nat_bodd.comp first))
  exact Primrec.ite ((Primrec.eq.comp s want).and
    (((Primrec.eq.comp a (Primrec.const none)).or (Primrec.eq.comp b (Primrec.const none))).or
      (Primrec.eq.comp a b))) (Primrec.const 1) (Primrec.const 0) |>.of_eq (fun v => by
        simp only [checkMatrix, or_assoc])

theorem validMatrix_recursive (Y : Oracle) :
    Nat.RecursiveIn {oracleFunction Y} (fun v => Part.some
      (if validMatrix Y (Nat.unpair v).1 (Nat.unpair (Nat.unpair v).2).1
        (Nat.unpair (Nat.unpair v).2).2 then 1 else 0)) := by
  classical
  let O : Set (ℕ →. ℕ) := {oracleFunction Y}
  let fst := Primrec.fst.comp Primrec.unpair
  let snd := Primrec.snd.comp Primrec.unpair
  let e := fst
  let q := fst.comp snd
  let r := snd.comp snd
  let n := fst.comp q
  have mk : ∀ (f : ℕ → ℕ), Primrec f → Nat.RecursiveIn O
      (fun v => Part.some (encode (run Y (machine (Nat.unpair v).1)
        (Nat.unpair (Nat.unpair (Nat.unpair v).2).1).1 (f v)))) := by
    intro f hf
    have hin := total_pair (O := O) (total_primrec e) (total_pair (total_primrec n) (total_primrec hf))
    exact (total_comp (run_uniform_recursive Y) hin).of_eq (fun v => by simp)
  have hs := mk _ (fst.comp r)
  have ha := mk _ (fst.comp (snd.comp q))
  have hb := mk _ (snd.comp (snd.comp q))
  exact (total_comp (total_primrec checkMatrix_primrec)
    (total_pair (total_primrec (snd.comp r)) (total_pair hs (total_pair ha hb)))).of_eq (fun v => by
      simp [checkMatrix, validMatrix])

end TuringRigidity.IndexMatrix

end OAI