| import OAI.Computability.DegreeRigidity.Effective.CodingDiagonal |
|
|
| namespace OAI |
|
|
| namespace TuringRigidity.CodingGeneric |
| open CodingForcing CodingColumns CodingDiagonal |
|
|
| def Dense (A : ℕ → Oracle) (R : Condition → Prop) : Prop := |
| ∀ p, ∃ q, Extends A p q ∧ R q |
|
|
| private theorem extend_dense (A : ℕ → Oracle) (R : Condition → Prop) |
| (hR : Dense A R) (p : Condition) (n : ℕ) : |
| ∃ q, Extends A p q ∧ R q ∧ n < q.active ∧ n < q.left.length := by |
| obtain ⟨r, hpr, hn⟩ := length_dense A p (n+1) |
| obtain ⟨s, hrs, ha⟩ := active_dense A r n |
| obtain ⟨q, hsq, hRq⟩ := hR s |
| exact ⟨q, extends_trans hpr (extends_trans hrs hsq), hRq, |
| ha.trans_le hsq.2.2.1, |
| (Nat.lt_succ_self n).trans_le (hn.trans (hrs.1.length_le.trans hsq.1.length_le))⟩ |
|
|
| noncomputable def stage (A : ℕ → Oracle) (R : ℕ → Condition → Prop) |
| (hR : ∀ n, Dense A (R n)) : ℕ → Condition |
| | 0 => ⟨[], [], rfl, 0⟩ |
| | n+1 => Classical.choose (extend_dense A (R n) (hR n) (stage A R hR n) n) |
|
|
| theorem stage_spec (A : ℕ → Oracle) (R : ℕ → Condition → Prop) |
| (hR : ∀ n, Dense A (R n)) (n : ℕ) : |
| Extends A (stage A R hR n) (stage A R hR (n+1)) ∧ |
| R n (stage A R hR (n+1)) ∧ n < (stage A R hR (n+1)).active ∧ |
| n < (stage A R hR (n+1)).left.length := |
| Classical.choose_spec (extend_dense A (R n) (hR n) (stage A R hR n) n) |
|
|
| theorem stage_mono (A : ℕ → Oracle) (R : ℕ → Condition → Prop) |
| (hR : ∀ n, Dense A (R n)) {m n : ℕ} (h : m ≤ n) : |
| Extends A (stage A R hR m) (stage A R hR n) := by |
| induction h with |
| | refl => exact extends_refl A _ |
| | step h ih => exact extends_trans ih (stage_spec A R hR _).1 |
|
|
| noncomputable def leftReal (A : ℕ → Oracle) (R : ℕ → Condition → Prop) |
| (hR : ∀ n, Dense A (R n)) : Oracle := fun n => (stage A R hR (n+1)).left.getD n false |
| noncomputable def rightReal (A : ℕ → Oracle) (R : ℕ → Condition → Prop) |
| (hR : ∀ n, Dense A (R n)) : Oracle := fun n => (stage A R hR (n+1)).right.getD n false |
|
|
| theorem leftReal_extends (A : ℕ → Oracle) (R : ℕ → Condition → Prop) |
| (hR : ∀ n, Dense A (R n)) (s n : ℕ) (hn : n < (stage A R hR s).left.length) : |
| leftReal A R hR n = (stage A R hR s).left.getD n false := by |
| unfold leftReal |
| by_cases h : s ≤ n+1 |
| · exact getD_of_prefix (stage_mono A R hR h).1 hn |
| · exact (getD_of_prefix (stage_mono A R hR (Nat.le_of_not_ge h)).1 |
| (stage_spec A R hR n).2.2.2).symm |
|
|
| theorem rightReal_extends (A : ℕ → Oracle) (R : ℕ → Condition → Prop) |
| (hR : ∀ n, Dense A (R n)) (s n : ℕ) (hn : n < (stage A R hR s).left.length) : |
| rightReal A R hR n = (stage A R hR s).right.getD n false := by |
| unfold rightReal |
| by_cases h : s ≤ n+1 |
| · exact getD_of_prefix (stage_mono A R hR h).2.1 (by simpa [← Condition.sameLength] using hn) |
| · exact (getD_of_prefix (stage_mono A R hR (Nat.le_of_not_ge h)).2.1 |
| (by simpa [← Condition.sameLength] using (stage_spec A R hR n).2.2.2)).symm |
|
|
| theorem coding_agreement (A : ℕ → Oracle) (R : ℕ → Condition → Prop) |
| (hR : ∀ n, Dense A (R n)) (s m : ℕ) |
| (hm : CodingLocation A (stage A R hR s) m) : |
| leftReal A R hR m = rightReal A R hR m := by |
| let t := max s (m+1) |
| have hst := stage_mono A R hR (Nat.le_max_left s (m+1)) |
| have hmt := stage_mono A R hR (Nat.le_max_right s (m+1)) |
| have hlen : m < (stage A R hR t).left.length := |
| (stage_spec A R hR m).2.2.2.trans_le hmt.1.length_le |
| rw [leftReal_extends A R hR t m hlen, rightReal_extends A R hR t m hlen] |
| exact hst.2.2.2 m hm hlen |
|
|
| abbrev RequirementIndex := ℕ × ℕ × OracleCode |
|
|
| def requirements (A : ℕ → Oracle) (hA : ∀ k, {a | A k a = true}.Infinite) |
| (n : ℕ) (p : Condition) : Prop := |
| match Encodable.decode (α := RequirementIndex) n with |
| | none => True |
| | some (k, cutoff, e) => Diagonal A hA k cutoff e p |
|
|
| theorem requirements_dense (A : ℕ → Oracle) (hA : ∀ k, {a | A k a = true}.Infinite) |
| (n : ℕ) : Dense A (requirements A hA n) := by |
| intro p |
| unfold requirements |
| cases hd : Encodable.decode (α := RequirementIndex) n with |
| | none => exact ⟨p, extends_refl A p, trivial⟩ |
| | some v => exact diagonal_dense A hA v.1 v.2.1 v.2.2 p |
|
|
| theorem readColumn_not_reduces (A : ℕ → Oracle) (hA : ∀ k, {a | A k a = true}.Infinite) |
| (k cutoff : ℕ) : |
| ¬ Reduces (readColumn (A k) (hA k) k cutoff |
| (leftReal A (requirements A hA) (requirements_dense A hA))) (A k) := by |
| intro h |
| obtain ⟨e, he⟩ := OracleCode.turingReducible_iff_exists_code _ _ |>.mp h |
| let i := Encodable.encode (k, cutoff, e) |
| have hd := (stage_spec A (requirements A hA) (requirements_dense A hA) i).2.1 |
| have hd' : Diagonal A hA k cutoff e |
| (stage A (requirements A hA) (requirements_dense A hA) (i+1)) := by |
| simpa [requirements, i] using hd |
| obtain ⟨n, hn, hne⟩ := hd' |
| apply hne |
| rw [he] |
| change Part.some (if leftReal A (requirements A hA) (requirements_dense A hA) |
| (location (A k) (hA k) k cutoff n) then 1 else 0) = _ |
| rw [leftReal_extends A (requirements A hA) (requirements_dense A hA) (i+1) _ hn] |
|
|
| theorem common_noncomputable_columns (A : ℕ → Oracle) |
| (hA : ∀ k, {a | A k a = true}.Infinite) : |
| ∃ G₀ G₁ : Oracle, ∀ k, ∃ C : Oracle, |
| Reduces C (join G₀ (A k)) ∧ Reduces C (join G₁ (A k)) ∧ ¬ Reduces C (A k) := by |
| let R := requirements A hA |
| let hR := requirements_dense A hA |
| let G₀ := leftReal A R hR |
| let G₁ := rightReal A R hR |
| refine ⟨G₀, G₁, ?_⟩ |
| intro k |
| let p := stage A R hR (k+1) |
| let cutoff := p.left.length |
| let C := readColumn (A k) (hA k) k cutoff G₀ |
| have heq : C = readColumn (A k) (hA k) k cutoff G₁ := by |
| funext n |
| apply coding_agreement A R hR (k+1) |
| have hm := location_mem (A k) (hA k) k cutoff n |
| simp only [column] at hm |
| split at hm |
| next h => |
| refine ⟨h.1, ?_, ?_⟩ |
| · rw [h.2] |
| exact (stage_spec A R hR k).2.2.1 |
| · simpa only [h.2] using hm |
| next h => simp at hm |
| exact ⟨C, readColumn_reduces _ _ _ _ _, heq ▸ readColumn_reduces _ _ _ _ _, |
| readColumn_not_reduces A hA k cutoff⟩ |
|
|
| theorem coding_first_clause (A : ℕ → Oracle) : |
| ∃ G₀ G₁ : Oracle, ∀ k, ∃ C : Oracle, |
| Reduces C (join G₀ (A k)) ∧ Reduces C (join G₁ (A k)) ∧ ¬ Reduces C (A k) := by |
| let B := fun k => Introreducible.prefixSet (A k) |
| obtain ⟨G₀, G₁, h⟩ := common_noncomputable_columns B |
| (fun k => Introreducible.prefixSet_infinite (A k)) |
| refine ⟨G₀, G₁, ?_⟩ |
| intro k |
| obtain ⟨C, h₀, h₁, hn⟩ := h k |
| have hBA := Introreducible.prefixSet_reduces (A k) |
| have hAB := ((degree_eq_iff _ _).mp (Introreducible.prefixSet_degree (A k))).2 |
| exact ⟨C, reduces_trans h₀ (join_mono (reduces_refl G₀) hBA), |
| reduces_trans h₁ (join_mono (reduces_refl G₁) hBA), fun hCA => hn (reduces_trans hCA hAB)⟩ |
|
|
| end TuringRigidity.CodingGeneric |
|
|
| end OAI |
|
|
