File size: 5,878 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 117 118 119 120 121 122 123 124 125 126 127 | import OAI.Computability.DegreeRigidity.Effective.TableIndices
namespace OAI
namespace TuringRigidity.IndexMatrix
open Encodable UniformOracle CommonIdeal TableIndices
def machine (e : ℕ) : Nat.Partrec.Code := (decode e).getD .zero
theorem machine_primrec : Primrec machine :=
Primrec.option_getD.comp Primrec.decode (Primrec.const Nat.Partrec.Code.zero)
@[simp] theorem machine_encode (d : Nat.Partrec.Code) : machine (encode d) = d := by
simp [machine]
theorem run_uniform_recursive (Y : Oracle) :
Nat.RecursiveIn {oracleFunction Y} (fun v => Part.some
(encode (run Y (machine (Nat.unpair v).1)
(Nat.unpair (Nat.unpair v).2).1 (Nat.unpair (Nat.unpair v).2).2))) := by
let O : Set (ℕ →. ℕ) := {oracleFunction Y}
let e := Primrec.fst.comp Primrec.unpair
let rest := Primrec.snd.comp Primrec.unpair
let n := Primrec.fst.comp (Primrec.unpair.comp rest)
let z := Primrec.snd.comp (Primrec.unpair.comp rest)
have he := total_primrec (O := O) e
have hn := total_primrec (O := O) n
have hm := total_primrec (O := O) (Primrec.fst.comp (Primrec.unpair.comp z))
have ht := total_primrec (O := O) (Primrec.snd.comp (Primrec.unpair.comp z))
have hL := total_comp (prefix_recursive (fun k => bit (Y k))) hm
let r := Primrec.snd.comp Primrec.unpair
have hdecode := total_primrec (O := O) (Primrec.encode.comp (Nat.Partrec.Code.primrec_evaln.comp
(((Primrec.fst.comp Primrec.unpair).pair
(machine_primrec.comp (Primrec.fst.comp (Primrec.unpair.comp r)))).pair
(Primrec.snd.comp (Primrec.unpair.comp r)))))
exact (total_comp hdecode (total_pair ht (total_pair he (total_pair hL hn)))).of_eq
(fun v => by simp [TableIndices.run, trial])
def validMatrix (Y : Oracle) (e q r : ℕ) : Prop :=
run Y (machine e) (Nat.unpair q).1 (Nat.unpair r).1 =
some (bit (Nat.unpair r).2.bodd) ∧
let a := run Y (machine e) (Nat.unpair q).1 (Nat.unpair (Nat.unpair q).2).1
let b := run Y (machine e) (Nat.unpair q).1 (Nat.unpair (Nat.unpair q).2).2
a = none ∨ b = none ∨ a = b
instance (Y : Oracle) (e q r : ℕ) : Decidable (validMatrix Y e q r) := by
unfold validMatrix
infer_instance
theorem valid_normal_form (Y : Oracle) (e : ℕ) :
Valid Y (machine e) ↔ ∀ q, ∃ r, validMatrix Y e q r := by
constructor
· rintro ⟨ht, hc⟩ q
obtain ⟨z, b, hb⟩ := ht (Nat.unpair q).1
refine ⟨Nat.pair z (if b then 1 else 0), ?_, ?_⟩
· cases b <;> simpa [Nat.unpair_pair] using hb
· dsimp only
cases ha : run Y (machine e) (Nat.unpair q).1 (Nat.unpair (Nat.unpair q).2).1 with
| none => exact Or.inl rfl
| some a =>
cases hb : run Y (machine e) (Nat.unpair q).1 (Nat.unpair (Nat.unpair q).2).2 with
| none => exact Or.inr (Or.inl rfl)
| some b => exact Or.inr (Or.inr (congrArg some
(hc _ _ _ _ _ (Option.mem_def.mpr ha) (Option.mem_def.mpr hb))))
· intro h
constructor
· intro n
obtain ⟨r, hr, _⟩ := h (Nat.pair n (Nat.pair 0 0))
exact ⟨(Nat.unpair r).1, (Nat.unpair r).2.bodd, by simpa using hr⟩
· intro n z w a b ha hb
obtain ⟨r, _, hc⟩ := h (Nat.pair n (Nat.pair z w))
simp only [Nat.unpair_pair] at hc
rcases hc with hc | hc | hc
· rw [hc] at ha; simp at ha
· rw [hc] at hb; simp at hb
· rw [Option.mem_def.mp ha, Option.mem_def.mp hb] at hc
exact Option.some.inj hc
def checkMatrix (v : ℕ) : ℕ :=
let wanted := (Nat.unpair v).1
let s := (decode (α := Option ℕ) (Nat.unpair (Nat.unpair v).2).1).getD none
let a := (decode (α := Option ℕ) (Nat.unpair (Nat.unpair (Nat.unpair v).2).2).1).getD none
let b := (decode (α := Option ℕ) (Nat.unpair (Nat.unpair (Nat.unpair v).2).2).2).getD none
if s = some (bit wanted.bodd) ∧ (a = none ∨ b = none ∨ a = b) then 1 else 0
theorem checkMatrix_primrec : Primrec checkMatrix := by
let first := Primrec.fst.comp Primrec.unpair
let rest := Primrec.snd.comp Primrec.unpair
let dec : Primrec (fun v : ℕ => (decode (α := Option ℕ) v).getD none) :=
Primrec.option_getD.comp Primrec.decode (Primrec.const none)
let s := dec.comp (first.comp rest)
let a := dec.comp (first.comp (rest.comp rest))
let b := dec.comp (rest.comp (rest.comp rest))
let want := Primrec.option_some.comp (bit_primrec.comp (Primrec.nat_bodd.comp first))
exact Primrec.ite ((Primrec.eq.comp s want).and
(((Primrec.eq.comp a (Primrec.const none)).or (Primrec.eq.comp b (Primrec.const none))).or
(Primrec.eq.comp a b))) (Primrec.const 1) (Primrec.const 0) |>.of_eq (fun v => by
simp only [checkMatrix, or_assoc])
theorem validMatrix_recursive (Y : Oracle) :
Nat.RecursiveIn {oracleFunction Y} (fun v => Part.some
(if validMatrix Y (Nat.unpair v).1 (Nat.unpair (Nat.unpair v).2).1
(Nat.unpair (Nat.unpair v).2).2 then 1 else 0)) := by
classical
let O : Set (ℕ →. ℕ) := {oracleFunction Y}
let fst := Primrec.fst.comp Primrec.unpair
let snd := Primrec.snd.comp Primrec.unpair
let e := fst
let q := fst.comp snd
let r := snd.comp snd
let n := fst.comp q
have mk : ∀ (f : ℕ → ℕ), Primrec f → Nat.RecursiveIn O
(fun v => Part.some (encode (run Y (machine (Nat.unpair v).1)
(Nat.unpair (Nat.unpair (Nat.unpair v).2).1).1 (f v)))) := by
intro f hf
have hin := total_pair (O := O) (total_primrec e) (total_pair (total_primrec n) (total_primrec hf))
exact (total_comp (run_uniform_recursive Y) hin).of_eq (fun v => by simp)
have hs := mk _ (fst.comp r)
have ha := mk _ (fst.comp (snd.comp q))
have hb := mk _ (snd.comp (snd.comp q))
exact (total_comp (total_primrec checkMatrix_primrec)
(total_pair (total_primrec (snd.comp r)) (total_pair hs (total_pair ha hb)))).of_eq (fun v => by
simp [checkMatrix, validMatrix])
end TuringRigidity.IndexMatrix
end OAI
|