File size: 4,777 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 | import OAI.Computability.DegreeRigidity.OrdinalCodes.IndexedOrder
import OAI.Computability.DegreeRigidity.Syntax.BoundedRecursive
namespace OAI
namespace TuringRigidity.CertificateMatrix
open Encodable UniformOracle TableIndices IndexMatrix IndexedOrder BoundedRecursive
def table (c : ℕ) : List (ℕ × ℕ) := (decode c).getD []
theorem table_primrec : Primrec table := Primrec.option_getD.comp Primrec.decode (Primrec.const [])
def entry (c j : ℕ) : ℕ × ℕ := (table c).getD j (0, 0)
theorem entry_primrec : Primrec₂ entry :=
(Primrec.list_getD (0, 0)).comp (table_primrec.comp Primrec.fst) Primrec.snd
def entryCheck (Y : Oracle) (v : ℕ) : ℕ :=
let e := (Nat.unpair (Nat.unpair v).1).1
let c := (Nat.unpair (Nat.unpair v).1).2
let j := (Nat.unpair v).2
if TableIndices.run Y (machine e) j (entry c j).2 = some (entry c j).1 then 1 else 0
theorem entryCheck_recursive (Y : Oracle) :
Nat.RecursiveIn {oracleFunction Y} (fun v => Part.some (entryCheck Y v)) := by
let O : Set (ℕ →. ℕ) := {oracleFunction Y}
let fst := Primrec.fst.comp Primrec.unpair
let snd := Primrec.snd.comp Primrec.unpair
let e := fst.comp fst
let c := snd.comp fst
let j := snd
let en := entry_primrec.comp c j
have hv := total_comp (run_uniform_recursive Y)
(total_pair (total_primrec e) (total_pair (total_primrec j)
(total_primrec (Primrec.snd.comp en))))
have hw := total_primrec (O := O) (Primrec.encode.comp (Primrec.option_some.comp (Primrec.fst.comp en)))
have heq := total_primrec (O := O)
(Primrec.ite (Primrec.eq.comp fst snd) (Primrec.const 1) (Primrec.const 0))
exact (total_comp heq (total_pair hv hw)).of_eq (fun v => by simp only [entryCheck, Nat.unpair_pair, Encodable.encode_injective.eq_iff])
def readsCheck (Y : Oracle) (v : ℕ) : ℕ :=
allBelow (entryCheck Y) v (table (Nat.unpair v).2).length
theorem readsCheck_recursive (Y : Oracle) :
Nat.RecursiveIn {oracleFunction Y} (fun v => Part.some (readsCheck Y v)) := by
have ha := total_pair (O := {oracleFunction Y}) (total_primrec Primrec.id)
(total_primrec (Primrec.list_length.comp (table_primrec.comp (Primrec.snd.comp Primrec.unpair))))
exact (total_comp (allBelow_recursive (entryCheck_recursive Y)) ha).of_eq (fun v => by simp [readsCheck])
theorem readsCheck_spec (Y : Oracle) (e c : ℕ) :
readsCheck Y (Nat.pair e c) = 1 ↔ Reads Y (machine e) (table c) := by
rw [readsCheck, Nat.unpair_pair, allBelow_spec]
simp only [entryCheck, Nat.unpair_pair, ite_eq_left_iff, Nat.zero_ne_one, imp_false, not_not]
constructor
· intro h j
have hh := h j.val j.isLt
simpa [entry, List.getD_eq_getElem?_getD, List.getElem?_eq_getElem j.isLt] using hh
· intro h j hj
have hh := h ⟨j, hj⟩
simpa [entry, List.getD_eq_getElem?_getD, List.getElem?_eq_getElem hj] using hh
instance (Y : Oracle) (e : Nat.Partrec.Code) (L : List (ℕ × ℕ)) : Decidable (Reads Y e L) := by
unfold Reads
infer_instance
instance (Y : Oracle) (e d : Nat.Partrec.Code) (n a z : ℕ) : Decidable (Certificate Y e d n a z) := by
unfold Certificate
infer_instance
theorem certificate_recursive (Y : Oracle) :
Nat.RecursiveIn {oracleFunction Y} (fun v => Part.some
(if Certificate Y (machine (Nat.unpair v).1) (machine (Nat.unpair (Nat.unpair v).2).1)
(Nat.unpair (Nat.unpair (Nat.unpair v).2).2).1
(Nat.unpair (Nat.unpair (Nat.unpair (Nat.unpair v).2).2).2).1
(Nat.unpair (Nat.unpair (Nat.unpair (Nat.unpair v).2).2).2).2 then 1 else 0)) := by
let O : Set (ℕ →. ℕ) := {oracleFunction Y}
let fst := Primrec.fst.comp Primrec.unpair
let snd := Primrec.snd.comp Primrec.unpair
let e := fst
let d := fst.comp snd
let n := fst.comp (snd.comp snd)
let a := fst.comp (snd.comp (snd.comp snd))
let z := snd.comp (snd.comp (snd.comp snd))
let L := table_primrec.comp (fst.comp z)
let vs := Primrec.list_map L (Primrec.fst.comp Primrec.snd).to₂
have hread := total_comp (readsCheck_recursive Y)
(total_pair (total_primrec e) (total_primrec (fst.comp z)))
let ve := Nat.Partrec.Code.primrec_evaln.comp
(((snd.comp z).pair (machine_primrec.comp d)).pair
(Primrec₂.natPair.comp (Primrec.encode.comp vs) n))
have heval := total_primrec (O := O)
(Primrec.ite (Primrec.eq.comp ve (Primrec.option_some.comp a)) (Primrec.const 1) (Primrec.const 0))
have hand := total_primrec (O := O)
(Primrec.ite ((Primrec.eq.comp fst (Primrec.const 1)).and (Primrec.eq.comp snd (Primrec.const 1)))
(Primrec.const 1) (Primrec.const 0))
exact (total_comp hand (total_pair hread heval)).of_eq (fun v => by
simp only [Nat.unpair_pair, readsCheck_spec, Certificate, values, table]
split_ifs <;> simp_all)
end TuringRigidity.CertificateMatrix
end OAI
|