import OAI.Computability.DegreeRigidity.Computability.Introreducible

namespace OAI

namespace TuringRigidity.CodingForcing

structure Condition where
  left : List Bool
  right : List Bool
  sameLength : left.length = right.length
  active : ℕ

def CodingLocation (A : ℕ → Oracle) (p : Condition) (m : ℕ) : Prop :=
  p.left.length ≤ m ∧ (Nat.unpair m).1 < p.active ∧
    A (Nat.unpair m).1 (Nat.unpair m).2 = true

def Extends (A : ℕ → Oracle) (p q : Condition) : Prop :=
  p.left <+: q.left ∧ p.right <+: q.right ∧ p.active ≤ q.active ∧
    ∀ m, CodingLocation A p m → m < q.left.length →
      q.left.getD m false = q.right.getD m false

theorem extends_refl (A : ℕ → Oracle) (p : Condition) : Extends A p p := by
  refine ⟨List.prefix_rfl, List.prefix_rfl, le_rfl, ?_⟩
  intro m hm hlt
  exact False.elim (Nat.not_lt_of_ge hm.1 hlt)

theorem getD_of_prefix {s t : List Bool} (h : s <+: t) {m : ℕ}
    (hm : m < s.length) : t.getD m false = s.getD m false := by
  obtain ⟨u, rfl⟩ := h
  simp [List.getD_eq_getElem?_getD, List.getElem?_append, hm]

theorem extends_trans {A : ℕ → Oracle} {p q r : Condition}
    (hpq : Extends A p q) (hqr : Extends A q r) : Extends A p r := by
  refine ⟨hpq.1.trans hqr.1, hpq.2.1.trans hqr.2.1,
    hpq.2.2.1.trans hqr.2.2.1, ?_⟩
  intro m hm hmr
  by_cases hmq : m < q.left.length
  · rw [getD_of_prefix hqr.1 hmq,
      getD_of_prefix hqr.2.1 (by simpa [← q.sameLength] using hmq)]
    exact hpq.2.2.2 m hm hmq
  · exact hqr.2.2.2 m ⟨Nat.le_of_not_gt hmq, hm.2.1.trans_le hpq.2.2.1, hm.2.2⟩ hmr

theorem extends_antisymm {A : ℕ → Oracle} {p q : Condition}
    (hpq : Extends A p q) (hqp : Extends A q p) : p = q := by
  have hl := hpq.1.eq_of_length (Nat.le_antisymm hpq.1.length_le hqp.1.length_le)
  have hr := hpq.2.1.eq_of_length (Nat.le_antisymm hpq.2.1.length_le hqp.2.1.length_le)
  have ha := Nat.le_antisymm hpq.2.2.1 hqp.2.2.1
  cases p
  cases q
  simp_all

def activate (p : Condition) (k : ℕ) : Condition :=
  ⟨p.left, p.right, p.sameLength, max p.active k⟩

theorem activate_extends (A : ℕ → Oracle) (p : Condition) (k : ℕ) :
    Extends A p (activate p k) := by
  refine ⟨List.prefix_rfl, List.prefix_rfl, Nat.le_max_left _ _, ?_⟩
  intro m hm hlt
  exact False.elim (Nat.not_lt_of_ge hm.1 hlt)

theorem active_dense (A : ℕ → Oracle) (p : Condition) (k : ℕ) :
    ∃ q, Extends A p q ∧ k < q.active :=
  ⟨activate p (k+1), activate_extends A p (k+1),
    Nat.lt_of_lt_of_le (Nat.lt_succ_self k) (Nat.le_max_right _ _)⟩

def append (p : Condition) (s : List Bool) : Condition where
  left := p.left ++ s
  right := p.right ++ s
  sameLength := by simp [p.sameLength]
  active := p.active

theorem append_extends (A : ℕ → Oracle) (p : Condition) (s : List Bool) :
    Extends A p (append p s) := by
  refine ⟨List.prefix_append _ _, List.prefix_append _ _, le_rfl, ?_⟩
  intro m hm _
  simp only [append, List.getD_eq_getElem?_getD, List.getElem?_append]
  rw [ite_eq_right (Nat.not_lt.mpr hm.1),
    ite_eq_right (by simpa [← p.sameLength] using Nat.not_lt.mpr hm.1), p.sameLength]

theorem arbitrary_left_extension (A : ℕ → Oracle) (p : Condition)
    (s : List Bool) (hs : p.left <+: s) :
    ∃ q, Extends A p q ∧ q.left = s := by
  obtain ⟨u, rfl⟩ := hs
  exact ⟨append p u, append_extends A p u, rfl⟩

theorem length_dense (A : ℕ → Oracle) (p : Condition) (n : ℕ) :
    ∃ q, Extends A p q ∧ n ≤ q.left.length := by
  refine ⟨append p (List.replicate n false), append_extends A p _, ?_⟩
  simp [append]

theorem codingLocation_unbounded (A : ℕ → Oracle) (p : Condition) (k : ℕ)
    (hk : k < p.active) (hinf : {a | A k a = true}.Infinite) (n : ℕ) :
    ∃ a, A k a = true ∧ max n p.left.length ≤ Nat.pair k a ∧
      CodingLocation A p (Nat.pair k a) := by
  have hi : (Nat.pair k '' {a | A k a = true}).Infinite :=
    hinf.image (fun a _ b _ h => (Nat.pair_eq_pair.mp h).2)
  have hex : ∃ m ∈ Nat.pair k '' {a | A k a = true}, max n p.left.length < m := by
    by_contra h
    apply hi
    apply (Set.finite_le_nat (max n p.left.length)).subset
    intro m hm
    exact Nat.le_of_not_gt (fun hgt => h ⟨m, hm, hgt⟩)
  obtain ⟨m, ⟨a, ha, rfl⟩, hm⟩ := hex
  refine ⟨a, ha, Nat.le_of_lt hm, ?_⟩
  simp only [CodingLocation, Nat.unpair_pair]
  exact ⟨le_trans (Nat.le_max_right _ _) (Nat.le_of_lt hm), hk, ha⟩

end TuringRigidity.CodingForcing

end OAI