File size: 5,800 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 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 | import OAI.Computability.DegreeRigidity.Effective.UniformPrograms
import OAI.Computability.DegreeRigidity.Representation.GenericTopology
namespace OAI
namespace TuringRigidity.ContinuousCode
open UniformPrograms UniformOracle BinarySeries FiniteShuffle GenericTopology Set Encodable
theorem table_agreement {A B : Oracle} {n : ℕ}
(h : oraclePrefix (bit A) n = oraclePrefix (bit B) n) : Agree n A B := by
intro i hi
have hh := congrArg (fun L : List ℕ => L.getD i 0) h
have hb : bit A i = bit B i := by simpa [oraclePrefix,List.getD,hi] using hh
cases ha : A i <;> cases hb' : B i <;> simp_all [bit]
def LocalAnswer (U : Set Oracle) (f : Oracle → Oracle) (n : ℕ) (L : List ℕ) (a : ℕ) : Prop :=
∀ A ∈ U, oraclePrefix (bit A) L.length = L → bit (f A) n = a
noncomputable def parameter (U : Set Oracle) (f : Oracle → Oracle) : Oracle := by
classical
exact fun k => decide (LocalAnswer U f (Nat.unpair k).1
((decode (α := List ℕ) (Nat.unpair (Nat.unpair k).2).1).getD [])
(Nat.unpair (Nat.unpair k).2).2)
def queryIndex (A : Oracle) (n k : ℕ) : ℕ :=
Nat.pair n (Nat.pair (encode (oraclePrefix (bit A) (Nat.unpair k).1)) (Nat.unpair k).2)
def trial (A P : Oracle) (n k : ℕ) : Option ℕ :=
if P (queryIndex A n k) then some (Nat.unpair k).2 else none
theorem trial_sound (U : Set Oracle) (f : Oracle → Oracle) (A : Oracle) (hA : A ∈ U)
(n k a : ℕ) (ha : a ∈ trial A (parameter U f) n k) : a = bit (f A) n := by
unfold trial at ha
split at ha
· rename_i hp
have hval : a = (Nat.unpair k).2 := by symm; simpa using ha
have hl : LocalAnswer U f n (oraclePrefix (bit A) (Nat.unpair k).1) (Nat.unpair k).2 := by
simp only [parameter, decide_eq_true_eq] at hp
simpa [queryIndex] using hp
have hs := hl A hA (by simp [oraclePrefix])
exact hval.trans hs.symm
· simp at ha
private def choiceValue (z : ℕ × ℕ) : Option ℕ := if z.1=1 then some z.2 else none
private theorem choiceValue_primrec : Primrec choiceValue :=
Primrec.ite ((Primrec.eq.comp Primrec.fst (Primrec.const 1)))
(Primrec.option_some.comp Primrec.snd) (Primrec.const none)
theorem trial_program (P : Oracle) :
Runs (fun A : Oracle => oracleFunction (join A P))
(fun A z => Part.some (encode (trial A P (Nat.unpair z).1 (Nat.unpair z).2))) := by
let O : Oracle → ℕ →. ℕ := fun A => oracleFunction (join A P)
have hO : Runs O (fun A n => Part.some (bit (join A P) n)) := query
have hA : Runs O (fun A n => Part.some (bit A n)) :=
(UniformPrograms.total_comp hO (primrec (Primrec.nat_mul.comp (Primrec.const 2) Primrec.id))).of_eq
(fun A n => by simp [bit])
have hP : Runs O (fun _ n => Part.some (bit P n)) :=
(UniformPrograms.total_comp hO (primrec (Primrec.succ.comp
(Primrec.nat_mul.comp (Primrec.const 2) Primrec.id)))).of_eq
(fun A n => by simp [bit])
have hn := primrec (O := O) (Primrec.fst.comp Primrec.unpair)
have hm := primrec (O := O) (Primrec.fst.comp (Primrec.unpair.comp
(Primrec.snd.comp Primrec.unpair)))
have ha := primrec (O := O) (Primrec.snd.comp (Primrec.unpair.comp
(Primrec.snd.comp Primrec.unpair)))
have hL := UniformPrograms.total_comp (initial_program (fun A => bit A) hA) hm
have hq := UniformPrograms.total_pair hn (UniformPrograms.total_pair hL ha)
have hb := UniformPrograms.total_comp hP hq
have hd := primrec (O := O) (Primrec.encode.comp (choiceValue_primrec.comp Primrec.unpair))
exact (UniformPrograms.total_comp hd (UniformPrograms.total_pair hb ha)).of_eq (fun A z => by
cases hp : P (queryIndex A (Nat.unpair z).1 (Nat.unpair z).2) <;>
simp [trial,choiceValue,queryIndex,bit] at hp ⊢ <;> rfl)
theorem local_answer_exists (U : Set Oracle) (f : Oracle → Oracle) (hf : ContinuousOn f U)
(A : Oracle) (hA : A ∈ U) (n : ℕ) :
∃ m, LocalAnswer U f n (oraclePrefix (bit A) m) (bit (f A) n) := by
have hc : ContinuousWithinAt (fun B => f B n) U A :=
(continuous_apply n).continuousAt.comp_continuousWithinAt (hf A hA)
have hp : {B | f B n = f A n} ∈ nhdsWithin A U :=
hc ((isOpen_discrete ({f A n} : Set Bool)).mem_nhds (by simp))
obtain ⟨V,hV,hAV,hsub⟩ := mem_nhdsWithin.mp hp
obtain ⟨m,hm⟩ := cylinder_basis V hV A hAV
refine ⟨m,?_⟩
intro B hB htable
have ht : oraclePrefix (bit B) m = oraclePrefix (bit A) m := by
simpa only [oraclePrefix,List.length_map,List.length_range] using htable
have he : f B n = f A n := hsub ⟨hm B (table_agreement ht).symm,hB⟩
simp [bit,he]
theorem trial_complete (U : Set Oracle) (f : Oracle → Oracle) (hf : ContinuousOn f U)
(A : Oracle) (hA : A ∈ U) (n : ℕ) :
∃ k a, a ∈ trial A (parameter U f) n k := by
obtain ⟨m,hm⟩ := local_answer_exists U f hf A hA n
refine ⟨Nat.pair m (bit (f A) n),bit (f A) n,?_⟩
have hp : parameter U f (queryIndex A n (Nat.pair m (bit (f A) n))) = true := by
simp only [parameter, decide_eq_true_eq]
simpa [queryIndex] using hm
simp [trial,hp]
theorem continuous_uniform_program (U : Set Oracle) (f : Oracle → Oracle) (hf : ContinuousOn f U) :
∃ P : Oracle, ∃ p : OracleCode, ∀ A ∈ U,
OracleCode.eval (oracleFunction (join A P)) p = oracleFunction (f A) := by
let P := parameter U f
let O : U → ℕ →. ℕ := fun A => oracleFunction (join A.val P)
have he : Runs O (fun A z => Part.some (encode (trial A.val P (Nat.unpair z).1 (Nat.unpair z).2))) := by
obtain ⟨p,hp⟩ := trial_program P
exact ⟨p,fun A => hp A.val⟩
obtain ⟨p,hp⟩ := UniformPrograms.total_search he (fun A => bit (f A.val))
(fun A => trial_sound U f A.val A.property)
(fun A => trial_complete U f hf A.val A.property)
exact ⟨P,p,fun A hA => hp ⟨A,hA⟩⟩
end TuringRigidity.ContinuousCode
end OAI
|