| 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 |
|
|
