import OAI.Computability.DegreeRigidity.Effective.CodingForcing
import OAI.Computability.DegreeRigidity.Computability.OracleEnumeration
import OAI.Computability.DegreeRigidity.Computability.Joins

namespace OAI

namespace TuringRigidity.CodingColumns
open PrefixComputability OracleEnumeration

def column (A : Oracle) (k cutoff : ℕ) (m : ℕ) : Bool :=
  if cutoff ≤ m ∧ (Nat.unpair m).1 = k then A (Nat.unpair m).2 else false

@[simp] theorem column_pair (A : Oracle) (k cutoff a : ℕ) :
    column A k cutoff (Nat.pair k a) = (if cutoff ≤ Nat.pair k a then A a else false) := by
  simp [column]

theorem column_infinite (A : Oracle) (hA : {a | A a = true}.Infinite) (k cutoff : ℕ) :
    {m | column A k cutoff m = true}.Infinite := by
  have hi : (Nat.pair k '' {a | A a = true}).Infinite :=
    hA.image (fun a _ b _ h => (Nat.pair_eq_pair.mp h).2)
  apply (hi.sdiff (Set.finite_le_nat cutoff)).mono
  rintro m ⟨⟨a, ha, rfl⟩, hm⟩
  have hc : cutoff ≤ Nat.pair k a := Nat.le_of_lt (Nat.lt_of_not_ge hm)
  change A a = true at ha
  simp [hc, ha]

private def columnStep (k cutoff : ℕ) (p : ℕ) : ℕ :=
  if cutoff ≤ (Nat.unpair p).1 ∧ (Nat.unpair (Nat.unpair p).1).1 = k
  then (Nat.unpair p).2 else 0

private theorem columnStep_primrec (k cutoff : ℕ) : Primrec (columnStep k cutoff) :=
  Primrec.ite ((Primrec.nat_le.comp (Primrec.const cutoff) (Primrec.fst.comp Primrec.unpair)).and
    (Primrec.eq.comp (Primrec.fst.comp (Primrec.unpair.comp (Primrec.fst.comp Primrec.unpair)))
      (Primrec.const k))) (Primrec.snd.comp Primrec.unpair) (Primrec.const 0)

theorem column_reduces (A : Oracle) (k cutoff : ℕ) : Reduces (column A k cutoff) A := by
  apply RecursiveIn.iff_nat.mpr
  have hq : Nat.RecursiveIn {oracleFunction A} (oracleFunction A) :=
    .oracle _ (Set.mem_singleton _)
  have hm := total_primrec (O := {oracleFunction A}) Primrec.id
  have ha := total_primrec (O := {oracleFunction A}) (Primrec.snd.comp Primrec.unpair)
  have hh := total_comp (total_primrec (columnStep_primrec k cutoff))
    (total_pair hm (total_comp hq ha))
  apply hh.of_eq
  intro m
  by_cases hc : cutoff ≤ m ∧ (Nat.unpair m).1 = k <;>
    simp [columnStep, column, oracleFunction, hc]

noncomputable def location (A : Oracle) (hA : {a | A a = true}.Infinite)
    (k cutoff : ℕ) : ℕ → ℕ := enumerate (column A k cutoff) (column_infinite A hA k cutoff)

theorem location_mem (A : Oracle) (hA : {a | A a = true}.Infinite) (k cutoff n : ℕ) :
    column A k cutoff (location A hA k cutoff n) = true := enumerate_mem _ _ _

theorem le_location (A : Oracle) (hA : {a | A a = true}.Infinite) (k cutoff n : ℕ) :
    n ≤ location A hA k cutoff n := le_enumerate _ _ _

theorem location_recursive (A : Oracle) (hA : {a | A a = true}.Infinite) (k cutoff : ℕ) :
    Nat.RecursiveIn {oracleFunction A} (fun n => Part.some (location A hA k cutoff n)) := by
  apply (enumerate_recursive (column A k cutoff) (column_infinite A hA k cutoff)).subst
  intro f hf
  have he : f = oracleFunction (column A k cutoff) := Set.mem_singleton_iff.mp hf
  subst f
  exact RecursiveIn.iff_nat.mp (column_reduces A k cutoff)

noncomputable def readColumn (A : Oracle) (hA : {a | A a = true}.Infinite)
    (k cutoff : ℕ) (G : Oracle) : Oracle := fun n => G (location A hA k cutoff n)

theorem readColumn_reduces (A : Oracle) (hA : {a | A a = true}.Infinite)
    (k cutoff : ℕ) (G : Oracle) : Reduces (readColumn A hA k cutoff G) (join G A) := by
  apply RecursiveIn.iff_nat.mpr
  have hloc := (location_recursive A hA k cutoff).subst (O' := {oracleFunction (join G A)})
    (fun f hf => by
      have he : f = oracleFunction A := Set.mem_singleton_iff.mp hf
      subst f
      exact RecursiveIn.iff_nat.mp (reduces_join_right G A))
  have hG := RecursiveIn.iff_nat.mp (reduces_join_left G A)
  exact total_comp hG hloc

end TuringRigidity.CodingColumns

end OAI