| import OAI.Computability.DegreeRigidity.Effective.CodingOnePoint |
|
|
| namespace OAI |
|
|
| namespace TuringRigidity.CodingSplitting |
| open CodingForcing |
|
|
| def OnePoint (base : List Bool) (f : List Bool → Part ℕ) : Prop := |
| ∃ s m b v w, base <+: s ∧ base.length ≤ m ∧ m < s.length ∧ v ≠ w ∧ |
| v ∈ f s ∧ w ∈ f (s.set m b) |
|
|
| private theorem interpolate (base : List Bool) (f : List Bool → Part ℕ) |
| (hmono : ∀ {s t}, s <+: t → ∀ v, v ∈ f s → v ∈ f t) |
| (hdense : ∀ s, base <+: s → ∃ u v, v ∈ f (s ++ u)) |
| (u : List Bool) : ∀ v : List Bool, u.length = v.length → |
| ∀ pre tail, base <+: pre → ∀ a b, |
| a ∈ f (pre ++ u ++ tail) → b ∈ f (pre ++ v ++ tail) → a ≠ b → OnePoint base f := by |
| induction u with |
| | nil => |
| intro v hlen pre tail hpre a b ha hb hab |
| have hv : v = [] := List.length_eq_zero_iff.mp hlen.symm |
| subst v |
| exact False.elim (hab (Part.mem_unique ha hb)) |
| | cons x u ih => |
| intro v hlen pre tail hpre a b ha hb hab |
| cases v with |
| | nil => simp at hlen |
| | cons y v => |
| have hlen' : u.length = v.length := Nat.succ.inj hlen |
| let mid := pre ++ (x :: v) ++ tail |
| have hmid : base <+: mid := by |
| simpa only [mid, List.append_assoc] using hpre.trans (List.prefix_append pre ((x :: v) ++ tail)) |
| obtain ⟨extra, c, hc⟩ := hdense mid hmid |
| have ha' : a ∈ f ((pre ++ (x :: u) ++ tail) ++ extra) := |
| hmono (List.prefix_append _ _) a ha |
| have hb' : b ∈ f ((pre ++ (y :: v) ++ tail) ++ extra) := |
| hmono (List.prefix_append _ _) b hb |
| by_cases hcb : c = b |
| · apply ih v hlen' (pre ++ [x]) (tail ++ extra) |
| (hpre.trans (List.prefix_append _ _)) a c |
| · simpa only [List.append_assoc, List.cons_append, List.nil_append] using ha' |
| · simpa only [mid, List.append_assoc, List.cons_append, List.nil_append] using hc |
| · simpa only [hcb] using hab |
| · refine ⟨mid ++ extra, pre.length, y, c, b, |
| hmid.trans (List.prefix_append _ _), hpre.length_le, ?_, hcb, hc, ?_⟩ |
| · simp [mid] |
| · have heq : (mid ++ extra).set pre.length y = |
| (pre ++ (y :: v) ++ tail) ++ extra := by |
| simp [mid, List.append_assoc, List.set_append_right] |
| rw [heq] |
| exact hb' |
|
|
| theorem onePoint_of_dense {base s t : List Bool} {f : List Bool → Part ℕ} |
| (hmono : ∀ {s t}, s <+: t → ∀ v, v ∈ f s → v ∈ f t) |
| (hdense : ∀ s, base <+: s → ∃ u v, v ∈ f (s ++ u)) |
| (hs : base <+: s) (ht : base <+: t) (a b : ℕ) |
| (ha : a ∈ f s) (hb : b ∈ f t) (hab : a ≠ b) : OnePoint base f := by |
| obtain ⟨u, rfl⟩ := hs |
| obtain ⟨v, rfl⟩ := ht |
| let L := max u.length v.length |
| let u' := u ++ List.replicate (L - u.length) false |
| let v' := v ++ List.replicate (L - v.length) false |
| have hlu : u'.length = L := by simp only [u', List.length_append, List.length_replicate]; omega |
| have hlv : v'.length = L := by simp only [v', List.length_append, List.length_replicate]; omega |
| have ha' : a ∈ f (base ++ u') := by |
| apply hmono (show base ++ u <+: base ++ u' from ?_) a ha |
| exact ⟨List.replicate (L-u.length) false, by simp [u', List.append_assoc]⟩ |
| have hb' : b ∈ f (base ++ v') := by |
| apply hmono (show base ++ v <+: base ++ v' from ?_) b hb |
| exact ⟨List.replicate (L-v.length) false, by simp [v', List.append_assoc]⟩ |
| exact interpolate base f hmono hdense u' v' (hlu.trans hlv.symm) |
| base [] List.prefix_rfl a b (by simpa using ha') (by simpa using hb') hab |
|
|
| theorem split_or_divergent_word {Y : Oracle} {e : OracleCode} {base s t : List Bool} |
| (hs : base <+: s) (ht : base <+: t) (n a b : ℕ) |
| (ha : a ∈ CommonIdeal.run Y e s n) (hb : b ∈ CommonIdeal.run Y e t n) (hab : a ≠ b) : |
| OnePoint base (fun w => CommonIdeal.run Y e w n) ∨ |
| ∃ w, base <+: w ∧ ∀ u v, v ∉ CommonIdeal.run Y e (w ++ u) n := by |
| by_cases hd : ∀ w, base <+: w → ∃ u v, v ∈ CommonIdeal.run Y e (w ++ u) n |
| · exact Or.inl (onePoint_of_dense (fun h v hv => CommonIdeal.run_mono h n v hv) |
| hd hs ht a b ha hb hab) |
| · right |
| push Not at hd |
| exact hd |
|
|
| end TuringRigidity.CodingSplitting |
|
|
| end OAI |
|
|
