File size: 7,457 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 128 129 130 131 | import OAI.Computability.DegreeRigidity.Effective.CodingLocations
namespace OAI
namespace TuringRigidity.CodingSplitSearch
open Encodable PrefixComputability CodingLocations
abbrev Witness := (List Bool × (ℕ × Bool)) × (ℕ × (ℕ × ℕ))
def finiteTrial (d : Nat.Partrec.Code) (base : List Bool) (L : List ℕ) (w : Witness) : Option ℕ :=
let a := d.evaln w.2.2.1 (Nat.pair (encode L) (Nat.pair (encode w.1.1) w.2.1))
let b := d.evaln w.2.2.2 (Nat.pair (encode L) (Nat.pair (encode (w.1.1.set w.1.2.1 w.1.2.2)) w.2.1))
if w.1.2.1 < w.1.1.length ∧ a ≠ none ∧ b ≠ none ∧ a.getD 0 ≠ b.getD 0
then some (base.length + w.1.2.1) else none
theorem finiteTrial_primrec (d : Nat.Partrec.Code) (base : List Bool) : Primrec₂ (finiteTrial d base) := by
let hL : Primrec (fun z : List ℕ × Witness => z.1) := Primrec.fst
let hu : Primrec (fun z : List ℕ × Witness => z.2.1.1) := Primrec.fst.comp (Primrec.fst.comp Primrec.snd)
let hi : Primrec (fun z : List ℕ × Witness => z.2.1.2.1) := Primrec.fst.comp (Primrec.snd.comp (Primrec.fst.comp Primrec.snd))
let hb : Primrec (fun z : List ℕ × Witness => z.2.1.2.2) := Primrec.snd.comp (Primrec.snd.comp (Primrec.fst.comp Primrec.snd))
let hn : Primrec (fun z : List ℕ × Witness => z.2.2.1) := Primrec.fst.comp (Primrec.snd.comp Primrec.snd)
let ht₀ : Primrec (fun z : List ℕ × Witness => z.2.2.2.1) := Primrec.fst.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd))
let ht₁ : Primrec (fun z : List ℕ × Witness => z.2.2.2.2) := Primrec.snd.comp (Primrec.snd.comp (Primrec.snd.comp Primrec.snd))
let hu' := Primrec.list_set.comp hu (hi.pair hb)
let ha₀ := Nat.Partrec.Code.primrec_evaln.comp
((ht₀.pair (Primrec.const d)).pair
(Primrec₂.natPair.comp (Primrec.encode.comp hL) (Primrec₂.natPair.comp (Primrec.encode.comp hu) hn)))
let ha₁ := Nat.Partrec.Code.primrec_evaln.comp
((ht₁.pair (Primrec.const d)).pair
(Primrec₂.natPair.comp (Primrec.encode.comp hL) (Primrec₂.natPair.comp (Primrec.encode.comp hu') hn)))
exact Primrec.ite ((Primrec.nat_lt.comp hi (Primrec.list_length.comp hu)).and
(((Primrec.eq.comp ha₀ (Primrec.const none)).not).and
(((Primrec.eq.comp ha₁ (Primrec.const none)).not).and
(Primrec.eq.comp (Primrec.option_getD_default.comp ha₀)
(Primrec.option_getD_default.comp ha₁)).not)))
(Primrec.option_some.comp (Primrec.nat_add.comp (Primrec.const base.length) hi))
(Primrec.const none)
def trial (Y : Oracle) (d : Nat.Partrec.Code) (base : List Bool) (z : ℕ) : Option ℕ :=
finiteTrial d base (oraclePrefix (fun n => CommonIdeal.bit (Y n)) (Nat.unpair z).1)
((decode (α := Witness) (Nat.unpair z).2).getD default)
theorem trial_recursive (Y : Oracle) (d : Nat.Partrec.Code) (base : List Bool) :
Nat.RecursiveIn {oracleFunction Y} (fun z => Part.some (encode (trial Y d base z))) := by
have hpre := total_comp (prefix_recursive (fun n => CommonIdeal.bit (Y n)))
(total_primrec (Primrec.fst.comp Primrec.unpair))
have hw := total_primrec (O := {oracleFunction Y}) (Primrec.snd.comp Primrec.unpair)
have hrun := total_primrec (O := {oracleFunction Y}) (Primrec.encode.comp
((finiteTrial_primrec d base).comp
(Primrec.option_getD_default.comp (Primrec.decode.comp (Primrec.fst.comp Primrec.unpair)))
(Primrec.option_getD_default.comp (Primrec.decode.comp (Primrec.snd.comp Primrec.unpair)))))
exact (total_comp hrun (total_pair hpre hw)).of_eq (fun z => by simp [trial])
theorem trial_sound (Y : Oracle) (e : OracleCode) (base : List Bool)
(d : Nat.Partrec.Code)
(hd : ∀ L w, d.eval (Nat.pair (encode L) w) = CommonIdeal.finiteRun e base L w)
(z m : ℕ) (h : m ∈ trial Y d base z) : SplittingLocation Y e base m := by
let L := oraclePrefix (fun n => CommonIdeal.bit (Y n)) (Nat.unpair z).1
let w := ((decode (α := Witness) (Nat.unpair z).2).getD default)
change m ∈ finiteTrial d base L w at h
dsimp only [finiteTrial] at h
split at h
next hg =>
have hm : m = base.length + w.1.2.1 := (Option.mem_some_iff.mp h).symm
let a := d.evaln w.2.2.1 (Nat.pair (encode L) (Nat.pair (encode w.1.1) w.2.1))
let b := d.evaln w.2.2.2 (Nat.pair (encode L) (Nat.pair (encode (w.1.1.set w.1.2.1 w.1.2.2)) w.2.1))
have ha : a.getD 0 ∈ a := by
cases ha' : a with
| none => exact False.elim (hg.2.1 ha')
| some v => simp
have hb : b.getD 0 ∈ b := by
cases hb' : b with
| none => exact False.elim (hg.2.2.1 hb')
| some v => simp
have hva := Nat.Partrec.Code.evaln_sound ha
have hvb := Nat.Partrec.Code.evaln_sound hb
rw [hd] at hva hvb
have hA := (CommonIdeal.finiteRun_approximates Y e base (encode w.1.1) w.2.1).1
(Nat.unpair z).1 (a.getD 0) hva
have hB := (CommonIdeal.finiteRun_approximates Y e base
(encode (w.1.1.set w.1.2.1 w.1.2.2)) w.2.1).1 (Nat.unpair z).1 (b.getD 0) hvb
rw [hm]
refine ⟨base ++ w.1.1, w.1.2.2, w.2.1, a.getD 0, b.getD 0,
List.prefix_append _ _, by omega, by simp; omega, hg.2.2.2, ?_, ?_⟩
· simpa [BorelGeneric.word] using hA
· simpa [BorelGeneric.word, List.set_append_right] using hB
next hg => simp at h
theorem trial_complete (Y : Oracle) (e : OracleCode) (base : List Bool)
(d : Nat.Partrec.Code)
(hd : ∀ L w, d.eval (Nat.pair (encode L) w) = CommonIdeal.finiteRun e base L w)
{m : ℕ} (hm : SplittingLocation Y e base m) : ∃ z, m ∈ trial Y d base z := by
obtain ⟨s, b, n, a, c, ⟨u, rfl⟩, hbase, hms, hac, ha, hc⟩ := hm
let i := m - base.length
have hmi : m = base.length + i := by omega
have hi : i < u.length := by simp only [List.length_append] at hms; omega
have hc' : c ∈ CommonIdeal.run Y e (base ++ u.set i b) n := by
simpa [List.set_append_right _ _ hbase] using hc
have hau : a ∈ CommonIdeal.run Y e (base ++ BorelGeneric.word (encode u)) n := by
simpa [BorelGeneric.word] using ha
have hcu : c ∈ CommonIdeal.run Y e (base ++ BorelGeneric.word (encode (u.set i b))) n := by
simpa [BorelGeneric.word] using hc'
obtain ⟨M₀, hM₀⟩ := (CommonIdeal.finiteRun_approximates Y e base (encode u) n).2 a hau
obtain ⟨M₁, hM₁⟩ := (CommonIdeal.finiteRun_approximates Y e base (encode (u.set i b)) n).2 c hcu
let M := max M₀ M₁
have hfa := hM₀ M (Nat.le_max_left _ _)
have hfc := hM₁ M (Nat.le_max_right _ _)
dsimp only at hfa hfc
rw [← hd] at hfa hfc
obtain ⟨t₀, ht₀⟩ := Nat.Partrec.Code.evaln_complete.mp hfa
obtain ⟨t₁, ht₁⟩ := Nat.Partrec.Code.evaln_complete.mp hfc
let w : Witness := ((u, i, b), (n, t₀, t₁))
refine ⟨Nat.pair M (encode w), ?_⟩
have ht₀' := Option.mem_def.mp ht₀
have ht₁' := Option.mem_def.mp ht₁
simp only [UniformOracle.oraclePrefix] at ht₀' ht₁'
simp [trial, finiteTrial, oraclePrefix, w, ht₀', ht₁', hi, hac, hmi]
theorem splittingLocations_enumerable (Y : Oracle) (e : OracleCode) (base : List Bool) :
∃ E : ℕ → Option ℕ,
Nat.RecursiveIn {oracleFunction Y} (fun z => Part.some (encode (E z))) ∧
∀ m, SplittingLocation Y e base m ↔ ∃ z, m ∈ E z := by
obtain ⟨d, hd⟩ := CommonIdeal.finiteRun_code e base
refine ⟨trial Y d base, trial_recursive Y d base, ?_⟩
intro m
exact ⟨trial_complete Y e base d hd, fun ⟨z, hz⟩ => trial_sound Y e base d hd z m hz⟩
end TuringRigidity.CodingSplitSearch
end OAI
|