File size: 4,482 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 | import OAI.Computability.DegreeRigidity.Computability.Introreducible
namespace OAI
namespace TuringRigidity.CodingForcing
structure Condition where
left : List Bool
right : List Bool
sameLength : left.length = right.length
active : ℕ
def CodingLocation (A : ℕ → Oracle) (p : Condition) (m : ℕ) : Prop :=
p.left.length ≤ m ∧ (Nat.unpair m).1 < p.active ∧
A (Nat.unpair m).1 (Nat.unpair m).2 = true
def Extends (A : ℕ → Oracle) (p q : Condition) : Prop :=
p.left <+: q.left ∧ p.right <+: q.right ∧ p.active ≤ q.active ∧
∀ m, CodingLocation A p m → m < q.left.length →
q.left.getD m false = q.right.getD m false
theorem extends_refl (A : ℕ → Oracle) (p : Condition) : Extends A p p := by
refine ⟨List.prefix_rfl, List.prefix_rfl, le_rfl, ?_⟩
intro m hm hlt
exact False.elim (Nat.not_lt_of_ge hm.1 hlt)
theorem getD_of_prefix {s t : List Bool} (h : s <+: t) {m : ℕ}
(hm : m < s.length) : t.getD m false = s.getD m false := by
obtain ⟨u, rfl⟩ := h
simp [List.getD_eq_getElem?_getD, List.getElem?_append, hm]
theorem extends_trans {A : ℕ → Oracle} {p q r : Condition}
(hpq : Extends A p q) (hqr : Extends A q r) : Extends A p r := by
refine ⟨hpq.1.trans hqr.1, hpq.2.1.trans hqr.2.1,
hpq.2.2.1.trans hqr.2.2.1, ?_⟩
intro m hm hmr
by_cases hmq : m < q.left.length
· rw [getD_of_prefix hqr.1 hmq,
getD_of_prefix hqr.2.1 (by simpa [← q.sameLength] using hmq)]
exact hpq.2.2.2 m hm hmq
· exact hqr.2.2.2 m ⟨Nat.le_of_not_gt hmq, hm.2.1.trans_le hpq.2.2.1, hm.2.2⟩ hmr
theorem extends_antisymm {A : ℕ → Oracle} {p q : Condition}
(hpq : Extends A p q) (hqp : Extends A q p) : p = q := by
have hl := hpq.1.eq_of_length (Nat.le_antisymm hpq.1.length_le hqp.1.length_le)
have hr := hpq.2.1.eq_of_length (Nat.le_antisymm hpq.2.1.length_le hqp.2.1.length_le)
have ha := Nat.le_antisymm hpq.2.2.1 hqp.2.2.1
cases p
cases q
simp_all
def activate (p : Condition) (k : ℕ) : Condition :=
⟨p.left, p.right, p.sameLength, max p.active k⟩
theorem activate_extends (A : ℕ → Oracle) (p : Condition) (k : ℕ) :
Extends A p (activate p k) := by
refine ⟨List.prefix_rfl, List.prefix_rfl, Nat.le_max_left _ _, ?_⟩
intro m hm hlt
exact False.elim (Nat.not_lt_of_ge hm.1 hlt)
theorem active_dense (A : ℕ → Oracle) (p : Condition) (k : ℕ) :
∃ q, Extends A p q ∧ k < q.active :=
⟨activate p (k+1), activate_extends A p (k+1),
Nat.lt_of_lt_of_le (Nat.lt_succ_self k) (Nat.le_max_right _ _)⟩
def append (p : Condition) (s : List Bool) : Condition where
left := p.left ++ s
right := p.right ++ s
sameLength := by simp [p.sameLength]
active := p.active
theorem append_extends (A : ℕ → Oracle) (p : Condition) (s : List Bool) :
Extends A p (append p s) := by
refine ⟨List.prefix_append _ _, List.prefix_append _ _, le_rfl, ?_⟩
intro m hm _
simp only [append, List.getD_eq_getElem?_getD, List.getElem?_append]
rw [ite_eq_right (Nat.not_lt.mpr hm.1),
ite_eq_right (by simpa [← p.sameLength] using Nat.not_lt.mpr hm.1), p.sameLength]
theorem arbitrary_left_extension (A : ℕ → Oracle) (p : Condition)
(s : List Bool) (hs : p.left <+: s) :
∃ q, Extends A p q ∧ q.left = s := by
obtain ⟨u, rfl⟩ := hs
exact ⟨append p u, append_extends A p u, rfl⟩
theorem length_dense (A : ℕ → Oracle) (p : Condition) (n : ℕ) :
∃ q, Extends A p q ∧ n ≤ q.left.length := by
refine ⟨append p (List.replicate n false), append_extends A p _, ?_⟩
simp [append]
theorem codingLocation_unbounded (A : ℕ → Oracle) (p : Condition) (k : ℕ)
(hk : k < p.active) (hinf : {a | A k a = true}.Infinite) (n : ℕ) :
∃ a, A k a = true ∧ max n p.left.length ≤ Nat.pair k a ∧
CodingLocation A p (Nat.pair k a) := by
have hi : (Nat.pair k '' {a | A k a = true}).Infinite :=
hinf.image (fun a _ b _ h => (Nat.pair_eq_pair.mp h).2)
have hex : ∃ m ∈ Nat.pair k '' {a | A k a = true}, max n p.left.length < m := by
by_contra h
apply hi
apply (Set.finite_le_nat (max n p.left.length)).subset
intro m hm
exact Nat.le_of_not_gt (fun hgt => h ⟨m, hm, hgt⟩)
obtain ⟨m, ⟨a, ha, rfl⟩, hm⟩ := hex
refine ⟨a, ha, Nat.le_of_lt hm, ?_⟩
simp only [CodingLocation, Nat.unpair_pair]
exact ⟨le_trans (Nat.le_max_right _ _) (Nat.le_of_lt hm), hk, ha⟩
end TuringRigidity.CodingForcing
end OAI
|