| import OAI.Computability.DegreeRigidity.Effective.CodingSplitSearch |
| import OAI.Computability.DegreeRigidity.Effective.RecursiveInfiniteSubset |
|
|
| namespace OAI |
|
|
| namespace TuringRigidity.CodingExtraction |
| open CodingForcing CodingAgreement CodingLocations CodingSplitSearch PrefixComputability |
|
|
| theorem recursive_coding_locations {A : ℕ → Oracle} {Y : Oracle} {e₀ e₁ : OracleCode} |
| {p : Condition} (hn : NoDisagreement A Y e₀ e₁ p) |
| (hL : DenseLeft A Y e₀ p) (hR : DenseRight A Y e₁ p) |
| (hU : ∀ q, Extends A p q → ¬ UniqueValues A Y e₀ q) : |
| ∃ C : Oracle, Reduces C Y ∧ {m | C m = true}.Infinite ∧ |
| ∀ m, C m = true → CodingLocation A p m := by |
| obtain ⟨E, hE, hEq⟩ := splittingLocations_enumerable Y e₀ p.left |
| have hu : RecursiveInfiniteSubset.Unbounded E := by |
| intro N |
| obtain ⟨m, hm, hs⟩ := splittingLocation_unbounded hL hU N |
| obtain ⟨z, hz⟩ := (hEq m).mp hs |
| exact ⟨z, m, hm, hz⟩ |
| obtain ⟨C, hCY, hCinf, hC⟩ := RecursiveInfiniteSubset.infinite_recursive_subset Y E hu hE |
| refine ⟨C, hCY, hCinf, ?_⟩ |
| intro m hm |
| exact splittingLocation_sound hn hR ((hEq m).mpr (hC m hm)) |
|
|
| theorem column_projection_reduces (C : Oracle) (k : ℕ) : |
| Reduces (fun a => C (Nat.pair k a)) C := by |
| apply RecursiveIn.iff_nat.mpr |
| have hq : Nat.RecursiveIn {oracleFunction C} (oracleFunction C) := .oracle _ (Set.mem_singleton _) |
| exact total_comp hq (total_primrec (Primrec₂.natPair.comp (Primrec.const k) Primrec.id)) |
|
|
| theorem infinite_column {A : ℕ → Oracle} {Y C : Oracle} {p : Condition} |
| (hCY : Reduces C Y) (hinf : {m | C m = true}.Infinite) |
| (hC : ∀ m, C m = true → CodingLocation A p m) : |
| ∃ k, k < p.active ∧ ∃ Z : Oracle, Reduces Z Y ∧ {a | Z a = true}.Infinite ∧ |
| ∀ a, Z a = true → A k a = true := by |
| let F := fun k : Fin p.active => {m : ℕ | C m = true ∧ (Nat.unpair m).1 = k.val} |
| have hex : ∃ k : Fin p.active, (F k).Infinite := by |
| by_contra h |
| have hf : ∀ k : Fin p.active, (F k).Finite := by |
| intro k |
| by_contra hi |
| exact h ⟨k, hi⟩ |
| apply hinf |
| apply (Set.finite_iUnion hf).subset |
| intro m hm |
| refine Set.mem_iUnion.mpr ⟨⟨(Nat.unpair m).1, (hC m hm).2.1⟩, ?_⟩ |
| exact ⟨hm, rfl⟩ |
| obtain ⟨k, hk⟩ := hex |
| let Z : Oracle := fun a => C (Nat.pair k.val a) |
| refine ⟨k.val, k.isLt, Z, reduces_trans (column_projection_reduces C k.val) hCY, ?_, ?_⟩ |
| · intro hZ |
| apply hk |
| apply (hZ.image (Nat.pair k.val)).subset |
| intro m hm |
| refine ⟨(Nat.unpair m).2, ?_, ?_⟩ |
| · change C (Nat.pair k.val (Nat.unpair m).2) = true |
| rw [← hm.2, Nat.pair_unpair] |
| exact hm.1 |
| · rw [← hm.2, Nat.pair_unpair] |
| · intro a ha |
| have hc := (hC (Nat.pair k.val a) ha).2.2 |
| simpa only [Nat.unpair_pair] using hc |
|
|
| theorem case2_computes_member {A : ℕ → Oracle} {Y : Oracle} {e₀ e₁ : OracleCode} |
| {p : Condition} |
| (hIntro : ∀ k Z, (∀ a, Z a = true → A k a = true) → |
| {a | Z a = true}.Infinite → Reduces (A k) Z) |
| (hn : NoDisagreement A Y e₀ e₁ p) |
| (hL : DenseLeft A Y e₀ p) (hR : DenseRight A Y e₁ p) |
| (hU : ∀ q, Extends A p q → ¬ UniqueValues A Y e₀ q) : |
| ∃ k, k < p.active ∧ Reduces (A k) Y := by |
| obtain ⟨C, hCY, hCinf, hC⟩ := recursive_coding_locations hn hL hR hU |
| obtain ⟨k, hk, Z, hZY, hZinf, hZ⟩ := infinite_column hCY hCinf hC |
| exact ⟨k, hk, reduces_trans (hIntro k Z hZ hZinf) hZY⟩ |
|
|
| end TuringRigidity.CodingExtraction |
|
|
| end OAI |
|
|
