openAI-math-dataset / lean /OAI /Computability /DegreeRigidity /SetModels /ConservativeExtension.lean
| import OAI.Computability.DegreeRigidity.Representation.CommonIdealSearch | |
| namespace OAI | |
| namespace TuringRigidity.ConservativeExtension | |
| open CommonIdeal | |
| def Decide (A Y : Oracle) (e : OracleCode) (s : List Bool) : Prop := | |
| (∃ n a, a ∈ run A e s n ∧ a ≠ bit (Y n)) ∨ | |
| ∀ t, s <+: t → ∀ n a, a ∈ run A e t n → a = bit (Y n) | |
| theorem decide_dense (A Y : Oracle) (e : OracleCode) (s : List Bool) : | |
| ∃ t, s <+: t ∧ Decide A Y e t := by | |
| by_cases h : ∃ t, s <+: t ∧ ∃ n a, a ∈ run A e t n ∧ a ≠ bit (Y n) | |
| · obtain ⟨t, ht, h⟩ := h | |
| exact ⟨t, ht, Or.inl h⟩ | |
| · refine ⟨s, List.prefix_rfl, Or.inr ?_⟩ | |
| intro t ht n a ha | |
| by_contra hn | |
| exact h ⟨t, ht, n, a, ha, hn⟩ | |
| theorem removes_oracle {A Y G : Oracle} {e : OracleCode} {s : List Bool} | |
| (hG : Extends G s) (hD : Decide A Y e s) | |
| (he : OracleCode.eval (oracleFunction (join A G)) e = oracleFunction Y) : | |
| Reduces Y A := by | |
| have hu : ∀ t, s <+: t → ∀ n a, a ∈ run A e t n → a = bit (Y n) := by | |
| rcases hD with ⟨n, a, ha, hn⟩ | hD | |
| · have hh := run_total hG n a ha | |
| rw [he] at hh | |
| exact False.elim (hn (Part.mem_some_iff.mp hh)) | |
| · exact hD | |
| apply common_output_reduces (G := G) (H := G) (p := e) (q := e) | |
| (s := s) (t := s) hG hG (Or.inr ?_) he he | |
| intro u v n a b hu' hv' ha hb | |
| exact (hu u hu' n a ha).trans (hu v hv' n b hb).symm | |
| def Diagonal (B : Oracle) (e : OracleCode) (s : List Bool) : Prop := | |
| ∃ n, n < s.length ∧ | |
| OracleCode.eval (oracleFunction B) e n ≠ Part.some (bit (s.getD n false)) | |
| theorem diagonal_dense (B : Oracle) (e : OracleCode) (s : List Bool) : | |
| ∃ t, s <+: t ∧ Diagonal B e t := by | |
| have hex : ∃ b : Bool, OracleCode.eval (oracleFunction B) e s.length ≠ Part.some (bit b) := by | |
| by_cases h : OracleCode.eval (oracleFunction B) e s.length = Part.some (bit false) | |
| · exact ⟨true, by rw [h]; simp [bit]⟩ | |
| · exact ⟨false, h⟩ | |
| obtain ⟨b, hb⟩ := hex | |
| refine ⟨s ++ [b], List.prefix_append _ _, s.length, by simp, ?_⟩ | |
| simpa [List.getD_eq_getElem?_getD, List.getElem?_append] using hb | |
| theorem meets_countable {ι : Type*} [Countable ι] (R : ι → List Bool → Prop) | |
| (hR : ∀ i s, ∃ t, s <+: t ∧ R i t) : | |
| ∃ G : Oracle, ∀ i, ∃ s, Extends G s ∧ R i s := by | |
| classical | |
| let := Encodable.ofCountable ι | |
| let Q : Unit → ℕ → ℕ → Prop := fun _ n c => | |
| ∀ i, Encodable.decode n = some i → R i (BorelGeneric.word c) | |
| have hd : ∀ x n s, ∃ t, BorelGeneric.Ext s t ∧ Q x n t := by | |
| intro x n s | |
| let u := BorelGeneric.word s ++ [false] | |
| have hs : BorelGeneric.word s <+: u := List.prefix_append _ _ | |
| have hl : (BorelGeneric.word s).length < u.length := by simp [u] | |
| cases hh : Encodable.decode (α := ι) n with | |
| | none => | |
| obtain ⟨t, ht⟩ := BorelGeneric.word_surjective u | |
| refine ⟨t, ⟨ht ▸ hs, ht ▸ hl⟩, ?_⟩ | |
| intro i hi | |
| simp [hh] at hi | |
| | some i => | |
| obtain ⟨v, huv, hv⟩ := hR i u | |
| obtain ⟨t, ht⟩ := BorelGeneric.word_surjective v | |
| refine ⟨t, ⟨ht ▸ hs.trans huv, ht ▸ hl.trans_le huv.length_le⟩, ?_⟩ | |
| intro j hj | |
| have he : i = j := Option.some.inj (hh.symm.trans hj) | |
| subst j | |
| simpa [ht] using hv | |
| refine ⟨BorelGeneric.generic Q hd (), ?_⟩ | |
| intro i | |
| let n := Encodable.encode i | |
| let t := BorelGeneric.stage Q hd (n+1) () | |
| refine ⟨BorelGeneric.word t, BorelGeneric.meets_stage Q hd () (n+1), ?_⟩ | |
| exact (BorelGeneric.next_spec Q hd n () (BorelGeneric.stage Q hd n ())).2 i | |
| (by simp [n]) | |
| theorem exists_conservative_extension (B : Oracle) : | |
| ∃ C : Oracle, ¬ Reduces C B ∧ | |
| ∀ A Y : Oracle, Reduces A B → Reduces Y B → | |
| Reduces Y (join A C) → Reduces Y A := by | |
| let L := {A : Oracle // Reduces A B} | |
| have : Countable L := (countable_reduces B).to_subtype | |
| let I := Sum OracleCode (L × L × OracleCode) | |
| let R : I → List Bool → Prop := fun i s => match i with | |
| | .inl e => Diagonal B e s | |
| | .inr (A, Y, e) => Decide A.val Y.val e s | |
| have hR : ∀ i s, ∃ t, s <+: t ∧ R i t := by | |
| intro i s | |
| cases i with | |
| | inl e => exact diagonal_dense B e s | |
| | inr v => exact decide_dense v.1.val v.2.1.val v.2.2 s | |
| obtain ⟨C, hC⟩ := meets_countable R hR | |
| refine ⟨C, ?_, ?_⟩ | |
| · intro h | |
| obtain ⟨e, he⟩ := (OracleCode.turingReducible_iff_exists_code _ _).mp h | |
| obtain ⟨s, hs, n, hn, hne⟩ := hC (.inl e) | |
| apply hne | |
| rw [he] | |
| change Part.some (bit (C n)) = _ | |
| rw [hs n hn] | |
| · intro A Y hA hY h | |
| obtain ⟨e, he⟩ := (OracleCode.turingReducible_iff_exists_code _ _).mp h | |
| obtain ⟨s, hs, hd⟩ := hC (.inr (⟨A, hA⟩, ⟨Y, hY⟩, e)) | |
| exact removes_oracle hs hd he | |
| theorem exists_conservative_degree (b : Degree) : | |
| ∃ c : Degree, ¬ c ≤ b ∧ | |
| ∀ a y : Degree, a ≤ b → y ≤ b → y ≤ a ⊔ c → y ≤ a := by | |
| obtain ⟨B, rfl⟩ := degree_surjective b | |
| obtain ⟨C, hC, h⟩ := exists_conservative_extension B | |
| refine ⟨degree C, hC, ?_⟩ | |
| intro a y ha hy hr | |
| obtain ⟨A, rfl⟩ := degree_surjective a | |
| obtain ⟨Y, rfl⟩ := degree_surjective y | |
| exact h A Y ha hy hr | |
| end TuringRigidity.ConservativeExtension | |
| end OAI | |