| import OAI.Computability.DegreeRigidity.Effective.CodingExtraction |
|
|
| namespace OAI |
|
|
| namespace TuringRigidity.CodingRequirements |
| open CodingForcing CodingAgreement CodingLocations CodingExtraction |
|
|
| def Good (A : ℕ → Oracle) (Y : Oracle) (e₀ e₁ : OracleCode) (p : Condition) : Prop := |
| Disagreement Y e₀ e₁ p ∨ |
| (∃ n, ∀ q, Extends A p q → ∀ v, v ∉ CommonIdeal.run Y e₀ q.left n) ∨ |
| (∃ n, ∀ q, Extends A p q → ∀ v, v ∉ CommonIdeal.run Y e₁ q.right n) ∨ |
| UniqueValues A Y e₀ p ∨ ∃ k, Reduces (A k) Y |
|
|
| theorem good_dense (A : ℕ → Oracle) |
| (hIntro : ∀ k Z, (∀ a, Z a = true → A k a = true) → |
| {a | Z a = true}.Infinite → Reduces (A k) Z) |
| (Y : Oracle) (e₀ e₁ : OracleCode) (p : Condition) : |
| ∃ q, Extends A p q ∧ Good A Y e₀ e₁ q := by |
| obtain ⟨q, hpq, hd | hn⟩ := disagreement_decision_dense A Y e₀ e₁ p |
| · exact ⟨q, hpq, Or.inl hd⟩ |
| · by_cases hl : ∃ r, Extends A q r ∧ ∃ n, ∀ s, Extends A r s → ∀ v, v ∉ CommonIdeal.run Y e₀ s.left n |
| · obtain ⟨r, hqr, hdiv⟩ := hl |
| exact ⟨r, extends_trans hpq hqr, Or.inr (Or.inl hdiv)⟩ |
| · by_cases hr : ∃ r, Extends A q r ∧ ∃ n, ∀ s, Extends A r s → ∀ v, v ∉ CommonIdeal.run Y e₁ s.right n |
| · obtain ⟨r, hqr, hdiv⟩ := hr |
| exact ⟨r, extends_trans hpq hqr, Or.inr (Or.inr (Or.inl hdiv))⟩ |
| · by_cases hu : ∃ r, Extends A q r ∧ UniqueValues A Y e₀ r |
| · obtain ⟨r, hqr, hu⟩ := hu |
| exact ⟨r, extends_trans hpq hqr, Or.inr (Or.inr (Or.inr (Or.inl hu)))⟩ |
| · have hL : DenseLeft A Y e₀ q := by |
| intro r hqr n |
| by_contra h |
| push Not at h |
| exact hl ⟨r, hqr, n, fun s hrs v => h s v hrs⟩ |
| have hR : DenseRight A Y e₁ q := by |
| intro r hqr n |
| by_contra h |
| push Not at h |
| exact hr ⟨r, hqr, n, fun s hrs v => h s v hrs⟩ |
| have hU : ∀ r, Extends A q r → ¬ UniqueValues A Y e₀ r := |
| fun r hqr huni => hu ⟨r, hqr, huni⟩ |
| obtain ⟨k, _, hk⟩ := case2_computes_member hIntro hn hL hR hU |
| exact ⟨q, hpq, Or.inr (Or.inr (Or.inr (Or.inr ⟨k, hk⟩)))⟩ |
|
|
| theorem arbitrary_right_extension (A : ℕ → Oracle) (p : Condition) |
| (s : List Bool) (hs : p.right <+: s) : ∃ q, Extends A p q ∧ q.right = s := by |
| obtain ⟨u, rfl⟩ := hs |
| exact ⟨append p u, append_extends A p u, rfl⟩ |
|
|
| theorem good_common_output {A : ℕ → Oracle} {Y G₀ G₁ Z : Oracle} |
| {e₀ e₁ : OracleCode} {p : Condition} |
| (h₀ : CommonIdeal.Extends G₀ p.left) (h₁ : CommonIdeal.Extends G₁ p.right) |
| (he₀ : OracleCode.eval (oracleFunction (join Y G₀)) e₀ = oracleFunction Z) |
| (he₁ : OracleCode.eval (oracleFunction (join Y G₁)) e₁ = oracleFunction Z) |
| (h : Good A Y e₀ e₁ p) : Reduces Z Y ∨ ∃ k, Reduces (A k) Y := by |
| rcases h with hd | hl | hr | hu | ha |
| · obtain ⟨n, a, b, hab, hva, hvb⟩ := hd |
| have hta := CommonIdeal.run_total h₀ n a hva |
| have htb := CommonIdeal.run_total h₁ n b hvb |
| rw [he₀] at hta |
| rw [he₁] at htb |
| exact False.elim (hab (Part.mem_unique hta htb)) |
| · obtain ⟨n, hn⟩ := hl |
| obtain ⟨s, hs, hv⟩ := CommonIdeal.run_finite_extension h₀ n (CommonIdeal.bit (Z n)) (by |
| rw [he₀]; exact Part.mem_some _) |
| obtain ⟨q, hpq, hq⟩ := arbitrary_left_extension A p s hs |
| exact False.elim (hn q hpq _ (hq ▸ hv)) |
| · obtain ⟨n, hn⟩ := hr |
| obtain ⟨s, hs, hv⟩ := CommonIdeal.run_finite_extension h₁ n (CommonIdeal.bit (Z n)) (by |
| rw [he₁]; exact Part.mem_some _) |
| obtain ⟨q, hpq, hq⟩ := arbitrary_right_extension A p s hs |
| exact False.elim (hn q hpq _ (hq ▸ hv)) |
| · exact Or.inl (case1_reduces hu h₀ he₀) |
| · exact Or.inr ha |
|
|
| def GoodForCode (A : ℕ → Oracle) (B : Oracle) (c e₀ e₁ : OracleCode) (p : Condition) : Prop := |
| ∀ Y : Oracle, OracleCode.eval (oracleFunction B) c = oracleFunction Y → Good A Y e₀ e₁ p |
|
|
| theorem goodForCode_dense (A : ℕ → Oracle) |
| (hIntro : ∀ k Z, (∀ a, Z a = true → A k a = true) → |
| {a | Z a = true}.Infinite → Reduces (A k) Z) |
| (B : Oracle) (c e₀ e₁ : OracleCode) (p : Condition) : |
| ∃ q, Extends A p q ∧ GoodForCode A B c e₀ e₁ q := by |
| by_cases h : ∃ Y : Oracle, OracleCode.eval (oracleFunction B) c = oracleFunction Y |
| · obtain ⟨Y, hY⟩ := h |
| obtain ⟨q, hpq, hg⟩ := good_dense A hIntro Y e₀ e₁ p |
| refine ⟨q, hpq, ?_⟩ |
| intro Z hZ |
| have he : Y = Z := oracleFunction_injective (hY.symm.trans hZ) |
| exact he ▸ hg |
| · exact ⟨p, extends_refl A p, fun Y hY => False.elim (h ⟨Y, hY⟩)⟩ |
|
|
| end TuringRigidity.CodingRequirements |
|
|
| end OAI |
|
|
