File size: 6,946 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 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 | 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
|