File size: 5,665 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 | import OAI.Computability.DegreeRigidity.Effective.CodingBounds
import OAI.Computability.DegreeRigidity.Effective.LocalColumnIndices
namespace OAI
namespace TuringRigidity.EnumerationDecoding
open IndexPresentation IndexTuples ArithmeticHierarchy DecodingTheorem
open SetCoding RelationCoding BoundedDecoding OracleJump ArithmeticModelDecoding
structure Enumeration where
node : ℕ → Degree
injective : Function.Injective node
output : ℕ → Degree
successor : RelationCode 2
payload : RelationCode 2
successor_spec : ∀ a b, successor.Holds (two a b) ↔ ∃ k, a = node k ∧ b = node (k+1)
payload_spec : ∀ a b, payload.Holds (two a b) ↔ ∃ k, a = node k ∧ b = output k
theorem path_node {Y} (c : Enumeration) {z : ℕ} (hz : Dom Y z) (he : value Y z = c.node 0)
{n t : ℕ} (hpath : Path Y c.successor z n t) :
∀ i, i ≤ n → Dom Y (item t i) ∧ value Y (item t i) = c.node i := by
intro i hi
induction i with
| zero =>
exact ⟨hpath.1, (le_antisymm ((le_iff hpath.1 hz).mp hpath.2.1)
((le_iff hz hpath.1).mp hpath.2.2.1)).trans he⟩
| succ i ih =>
have hprev := ih (by omega)
have hs := hpath.2.2.2 i (by omega)
have hnext : Dom Y (item t (i+1)) := by
simpa [twoIndex,entry] using hs.1 (1 : Fin 2)
obtain ⟨k,hk,hkn⟩ := (c.successor_spec _ _).mp ((presented_two hprev.1 hnext).mp hs)
have hki : k = i := c.injective (hk.symm.trans hprev.2)
exact ⟨hnext, by simpa [hki] using hkn⟩
theorem node_below (Y : Oracle) (c : Enumeration)
(hS : RelationBelow c.successor (degree Y)) (n : ℕ) : c.node n ≤ degree Y := by
have hs := (c.successor_spec (c.node n) (c.node (n+1))).mpr ⟨n,rfl,rfl⟩
obtain ⟨d,hd,_⟩ := hs
exact (graph_bounded (hS.1 0) (hd 0)).1
theorem path_sigma (Y : Oracle) (S : RelationCode 2) (z : ℕ)
(hS : RelationBelow S (degree Y)) : Sigma Y 5 (fun v => Path Y S z (Nat.unpair v).1 (Nat.unpair v).2) := by
let f := Primrec.fst.comp Primrec.unpair
let r := Primrec.snd.comp Primrec.unpair
let start := item_primrec.comp r (Primrec.const 0)
have hd : Sigma Y 5 (fun v => Dom Y (item (Nat.unpair v).2 0)) :=
(dom_pi Y start).switch.raise.raise
have hl := (le_sigma Y start (Primrec.const z)).raise.raise
have hr := (le_sigma Y (Primrec.const z) start).raise.raise
have hs := ((RelationPresentation.sigma5_decoding Y S hS).comp
(twoIndex_primrec.comp (item_primrec.comp (r.comp f) r)
(item_primrec.comp (r.comp f) (Primrec.succ.comp r)))).bounded_all f
exact (hd.and (hl.and (hr.and hs))).congr (fun v => by
simp only [ArithmeticModelDecoding.Path,Presented,Nat.unpair_pair])
def Defined (Y : Oracle) (S P : RelationCode 2) (z n j : ℕ) : Prop :=
∃ t, Path Y S z n t ∧ Presented Y P (twoIndex (item t n) j)
theorem defined_sigma (Y : Oracle) (S P : RelationCode 2) (z : ℕ)
(hS : RelationBelow S (degree Y)) (hP : RelationBelow P (degree Y)) :
Sigma Y 5 (fun v => Defined Y S P z (Nat.unpair v).1 (Nat.unpair v).2) := by
let f := Primrec.fst.comp Primrec.unpair
let r := Primrec.snd.comp Primrec.unpair
have hs := (path_sigma Y S z hS).comp (Primrec₂.natPair.comp (f.comp f) r)
have hp := (RelationPresentation.sigma5_decoding Y P hP).comp
(twoIndex_primrec.comp (item_primrec.comp r (f.comp f)) (r.comp f))
exact ((hs.and hp).ex).congr (fun v => by simp only [Defined,Presented,Nat.unpair_pair])
theorem defined_iff {Y} (c : Enumeration) {z j : ℕ} (hz : Dom Y z) (hj : Dom Y j)
(he : value Y z = c.node 0) (hS : RelationBelow c.successor (degree Y)) (n : ℕ) :
Defined Y c.successor c.payload z n j ↔ c.output n = value Y j := by
constructor
· rintro ⟨t,hpath,hp⟩
have hn := path_node c hz he hpath n le_rfl
obtain ⟨k,hk,hval⟩ := (c.payload_spec _ _).mp ((presented_two hn.1 hj).mp hp)
have hkn := c.injective (hk.symm.trans hn.2)
exact hkn ▸ hval.symm
· intro hU
choose e hd hev using (fun i => value_surjective Y (c.node i) (node_below Y c hS i))
obtain ⟨t,ht⟩ := (exists_items (n+1) (fun i a => a = e i)).mp
(fun i _ => ⟨e i,rfl⟩)
have hdom (i : ℕ) (hi : i ≤ n) : Dom Y (item t i) := by rw [ht i (by omega)]; exact hd i
have hval (i : ℕ) (hi : i ≤ n) : value Y (item t i) = c.node i := by
rw [ht i (by omega),hev i]
refine ⟨t,⟨hdom 0 (by omega),?_,?_,?_⟩,?_⟩
· apply (le_iff (hdom 0 (by omega)) hz).mpr
rw [hval 0 (by omega),he]
· apply (le_iff hz (hdom 0 (by omega))).mpr
rw [hval 0 (by omega),he]
· intro i hi
apply (presented_two (hdom i (by omega)) (hdom (i+1) (by omega))).mpr
exact (c.successor_spec _ _).mpr ⟨i,hval i (by omega),hval (i+1) (by omega)⟩
· apply (presented_two (hdom n le_rfl) hj).mpr
exact (c.payload_spec _ _).mpr ⟨n,hval n le_rfl,hU.symm⟩
theorem graph_sigma {H Y : Oracle} (hHY : Reduces H Y) (c : Enumeration)
(hS : RelationBelow c.successor (degree Y)) (hP : RelationBelow c.payload (degree Y)) :
Sigma Y 5 (fun v => c.output (Nat.unpair v).1 = degree (EncodedForcing.columns H (Nat.unpair v).2)) := by
obtain ⟨z,hz,he⟩ := value_surjective Y (c.node 0) (node_below Y c hS 0)
obtain ⟨idx,hidx,hrep⟩ := LocalColumnIndices.uniform_indices hHY
have hi := (defined_sigma Y c.successor c.payload z hS hP).comp
(Primrec₂.natPair.comp (Primrec.fst.comp Primrec.unpair)
(hidx.comp (Primrec.snd.comp Primrec.unpair)))
apply hi.congr
intro v
simp only [Nat.unpair_pair]
rw [defined_iff c hz ((TableIndices.valid_iff_represents _ _).mpr ⟨_,hrep _⟩) he hS]
rw [value_eq (hrep _)]
end TuringRigidity.EnumerationDecoding
end OAI
|