File size: 3,529 Bytes
9dbc64e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 | 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
|