Add lean source and binary files (part 60)

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticPersistenceDegreeModel.lean

@@ -0,0 +1,72 @@
+import OAI.Computability.DegreeRigidity.Constructibility.PersistenceExtensionAbsoluteness
+import OAI.Computability.DegreeRigidity.Representation.SourceTModelBridge
+
+namespace OAI
+
+
+namespace TuringRigidity.BoundedSetTheory
+open TransitiveNameModel EncodedForcing PersistentRestrictions PersistentPresentation OracleJump
+open ArithmeticTree ArithmeticPersistence
+universe u
+
+theorem sourceT_arithmetic_persistent_graph (M : ZFSet.{u}) (hM : Transitive M) (hT : SourceT M)
+    (S : ZFSet.{u}) (hSM : S ∈ M)
+    (hS : ∀ A : Oracle, realCode A ∈ S ↔ A ∈ modelReals M)
+    (hSd : ∀ x ∈ S, ∃ A : Oracle, realCode A = x)
+    (A R : Oracle) (hA : A ∈ modelReals M) (hR : R ∈ modelReals M)
+    (hp : ∀ H ∈ modelReals M, Base A R ∧ Matrix (parameters A R H) 0) :
+    ∃ I : CountableIdeal, ∃ hAI : Presented I A, ∃ ρ : I ≃o I,
+      (∀ v, R v = true ↔ Graph ρ hAI v) ∧ Persistent I ρ ∧
+      presentationGraph S A R ∈ M ∧
+      (LevySigma.persistent 0 1 2 3 4).Realize M
+        (modelDegreeEnv S (presentationSet S A) (presentationGraph S A R)) := by
+  obtain ⟨I,hAI,hz,ρ,hgraph,hpers⟩ := (sourceT_persistence_presentation M hM hT A R hA hR).mp hp
+  have hc : ∀ n, realCode (columns A n) ∈ S :=
+    fun n => (hS _).mpr (sourceT_real_column M hM hT hA n)
+  have hbridge := sourceT_arbitrary_persistent_graph M hM hT S hSM hS hSd hAI hA ρ hpers hz
+    (presentationGraph S A R) (fun _ h => (ZFSet.mem_sep.mp h).1)
+    (presentationGraph_actual S hAI hc ρ hgraph)
+  exact ⟨I,hAI,ρ,hgraph,hpers,hbridge⟩
+
+theorem sourceT_presentation_transfer (M N : ZFSet.{u})
+    (hM : Transitive M) (hN : Transitive N) (hTM : SourceT M) (hTN : SourceT N)
+    (A R : Oracle) (hAM : A ∈ modelReals M) (hRM : R ∈ modelReals M)
+    (hAN : A ∈ modelReals N) (hRN : R ∈ modelReals N)
+    (hp : ∀ H ∈ modelReals M, Base A R ∧ Matrix (parameters A R H) 0) :
+    ∃ S ∈ N, degreeUniverse S ∈ N ∧ degreeOrder S ∈ N ∧
+      presentationGraph S A R ∈ N ∧
+      (LevySigma.persistent 0 1 2 3 4).Realize N
+        (modelDegreeEnv S (presentationSet S A) (presentationGraph S A R)) := by
+  have hpN := (persistence_between_models M N hM hN hTM hTN A R hAM hRM hAN hRN).mp hp
+  obtain ⟨S,hSN,hS,hSd⟩ := internal_real_power N hN hTN
+  have hd : ∀ x ∈ S, ∃ B : Oracle, realCode B = x := by
+    intro x hx; obtain ⟨B,_,hB⟩ := hSd x hx; exact ⟨B,hB⟩
+  obtain ⟨_,_,_,_,_,hgraph,hpers⟩ := sourceT_arithmetic_persistent_graph N hN hTN S hSN hS hd A R hAN hRN hpN
+  exact ⟨S,hSN,internal_degreeUniverse N hN hTN S hSN hd,
+    internal_degreeOrder N hN hTN S hSN hd,hgraph,hpers⟩
+
+theorem generic_extension_persistent_degree_model (M : ZFSet.{u}) (hM : Transitive M) (hT : SourceT M)
+    {c o : ZFSet.{u}} [Preorder (Conditions c)] [Top (Conditions c)] (hc : c ∈ M) (hoM : o ∈ M)
+    (ho : ∀ r s : Conditions c, ZFSet.pair (label c r) (label c s) ∈ o ↔ r ≤ s)
+    (G : CountableForcing.GenericFilter (Conditions c)) (hG : AtomicForcing.GroundGeneric M G)
+    (htop : ⊤ ∈ G.carrier) (A R : Oracle) (hA : A ∈ modelReals M) (hR : R ∈ modelReals M)
+    (hp : ∀ H ∈ modelReals M, Base A R ∧ Matrix (parameters A R H) 0) :
+    let E := genericExtensionSet M c G.carrier
+    ∃ S ∈ E, degreeUniverse S ∈ E ∧ degreeOrder S ∈ E ∧
+      presentationGraph S A R ∈ E ∧
+      (LevySigma.persistent 0 1 2 3 4).Realize E
+        (modelDegreeEnv S (presentationSet S A) (presentationGraph S A R)) := by
+  have hi := ground_inclusion_set M c hM hT.pairing hT.union hT.powerSet
+    hT.separation.finitePrefix.bounded hT.replacement.finitePrefix hT.infinity hc G.carrier htop
+  have hAE : A ∈ modelReals (genericExtensionSet M c G.carrier) := by
+    change realCode A ∈ genericExtensionSet M c G.carrier
+    exact hi hA
+  have hRE : R ∈ modelReals (genericExtensionSet M c G.carrier) := by
+    change realCode R ∈ genericExtensionSet M c G.carrier
+    exact hi hR
+  exact sourceT_presentation_transfer M _ hM (genericExtensionSet_transitive M c hM G.carrier)
+    hT (extension_sourceT M hM hT hc hoM ho G hG htop) A R hA hR hAE hRE hp
+
+end TuringRigidity.BoundedSetTheory
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticPrefixFamilies.lean

@@ -0,0 +1,49 @@
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticGenericTruth
+
+namespace OAI
+
+
+namespace TuringRigidity.ArithmeticPrefixFamilies
+open UniformArithmetic ArithmeticPrefixForcing ShuffleRequirements FiniteShuffle
+
+theorem prefix_comp {Q : PrefixPredicate} (hQ : ArithmeticPrefix Q)
+    {f : ℕ → ℕ} (hf : Primrec f) : ArithmeticPrefix (fun O v => Q O (f v)) :=
+  (hQ.comp _ (Primrec₂.natPair.comp (hf.comp left_primrec) right_primrec)).congr
+    (fun _ _ => by simp only [left,right,Nat.unpair_pair])
+
+theorem prefix_exists {Q : PrefixPredicate} (hQ : ArithmeticPrefix Q) :
+    ArithmeticPrefix (fun O v s => ∃ n, Q O (Nat.pair v n) s) :=
+  ((hQ.comp _ (Primrec₂.natPair.comp
+    (Primrec₂.natPair.comp (left_primrec.comp left_primrec) right_primrec)
+    (right_primrec.comp left_primrec))).ex).congr
+      (fun _ _ => by simp only [left,right,Nat.unpair_pair])
+
+theorem dense_and {D E : List Bool → Prop} (hD : DenseOpen D) (hE : DenseOpen E) :
+    DenseOpen (fun s => D s ∧ E s) := by
+  constructor
+  · intro s
+    obtain ⟨t,hst,ht⟩ := hD.1 s
+    obtain ⟨u,htu,hu⟩ := hE.1 t
+    exact ⟨u,hst.trans htu,hD.2 t u htu ht,hu⟩
+  · intro s t hst hs
+    exact ⟨hD.2 s t hst hs.1,hE.2 s t hst hs.2⟩
+
+theorem dense_true : DenseOpen (fun _ : List Bool => True) :=
+  ⟨fun s => ⟨s,List.prefix_rfl,True.intro⟩,fun _ _ _ _ => True.intro⟩
+
+theorem avoid_truth_of_decides (Q : List Bool → Prop) (hQ : Upward Q) (G : Oracle)
+    (hG : G ∈ OpenSet (Decides Q)) :
+    G ∈ OpenSet (Avoid Q) ↔ ¬ G ∈ OpenSet Q := by
+  constructor
+  · rintro ⟨s,hs,hGs⟩ ⟨t,ht,hGt⟩
+    obtain ⟨u,hsu,htu,_⟩ := realizes_common hGs hGt
+    exact hs u hsu (hQ t u htu ht)
+  · intro hn
+    obtain ⟨s,hs,hGs⟩ := hG
+    rcases hs with hs | hs
+    · exact False.elim (hn ⟨s,hs,hGs⟩)
+    · exact ⟨s,hs,hGs⟩
+
+end TuringRigidity.ArithmeticPrefixFamilies
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticPrefixForcing.lean

@@ -0,0 +1,100 @@
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticCommonRequirement
+import OAI.Computability.DegreeRigidity.SetModels.ShuffleRequirements
+
+namespace OAI
+
+
+namespace TuringRigidity.ArithmeticPrefixForcing
+open Encodable UniformArithmetic FiniteShuffle ShuffleRequirements
+open EncodedForcing (word word_primrec)
+
+abbrev PrefixPredicate := Oracles → ℕ → List Bool → Prop
+abbrev ArithmeticPrefix (Q : PrefixPredicate) :=
+  Arith (fun O v => Q O (left v) (word (right v)))
+
+def Upward (Q : List Bool → Prop) : Prop :=
+  ∀ s t, s <+: t → Q s → Q t
+
+def Avoid (Q : List Bool → Prop) (s : List Bool) : Prop :=
+  ∀ t, s <+: t → ¬ Q t
+
+def Decides (Q : List Bool → Prop) (s : List Bool) : Prop := Q s ∨ Avoid Q s
+
+def Generic (O : Oracles) (G : Oracle) : Prop :=
+  ∀ D : Oracles → List Bool → Prop,
+    Arith (fun O n => D O (word n)) → DenseOpen (D O) →
+    ∃ s, D O s ∧ Realizes s G
+
+theorem avoids_upward (Q : List Bool → Prop) : Upward (Avoid Q) :=
+  fun _ _ h hs u hu => hs u (h.trans hu)
+
+theorem decides_dense (Q : List Bool → Prop) (hQ : Upward Q) :
+    DenseOpen (Decides Q) := by
+  classical
+  constructor
+  · intro s
+    by_cases h : ∃ t, s <+: t ∧ Q t
+    · obtain ⟨t,ht,hq⟩ := h
+      exact ⟨t,ht,Or.inl hq⟩
+    · exact ⟨s,List.prefix_rfl,Or.inr (fun t ht hq => h ⟨t,ht,hq⟩)⟩
+  · intro s t h
+    exact Or.imp (hQ s t h) (avoids_upward Q s t h)
+
+theorem avoids_arith {Q : PrefixPredicate} (hQ : ArithmeticPrefix Q) :
+    ArithmeticPrefix (fun O v => Avoid (Q O v)) := by
+  have hp := ArithmeticCommonRequirement.prefix_arith
+    (right_primrec.comp left_primrec) right_primrec
+  have h := hQ.comp _ (Primrec₂.natPair.comp (left_primrec.comp left_primrec) right_primrec)
+  apply (hp.imp h.neg).all.congr
+  intro O v
+  simp only [left,right,Nat.unpair_pair]
+  constructor
+  · intro h t ht
+    have hh := h (encode t)
+    simpa only [word,Encodable.encodek,Option.getD_some] using hh (by
+      simpa only [word,Encodable.encodek,Option.getD_some] using ht)
+  · intro h t ht
+    exact h (word t) ht
+
+theorem decides_arith {Q : PrefixPredicate} (hQ : ArithmeticPrefix Q) :
+    ArithmeticPrefix (fun O v => Decides (Q O v)) := hQ.or (avoids_arith hQ)
+
+theorem realizes_common {s t : List Bool} {G : Oracle}
+    (hs : Realizes s G) (ht : Realizes t G) :
+    ∃ u, s <+: u ∧ t <+: u ∧ Realizes u G := by
+  refine ⟨initial G (max s.length t.length), ?_, ?_,
+    (realizes_initial _ _ _).mpr (fun _ _ => rfl)⟩
+  · rw [←prefix_default s]
+    exact initial_prefix (by simp) hs
+  · rw [←prefix_default t]
+    exact initial_prefix (by simp) ht
+
+theorem open_and (Q R : List Bool → Prop) (hQ : Upward Q) (hR : Upward R) (G : Oracle) :
+    G ∈ OpenSet (fun s => Q s ∧ R s) ↔ G ∈ OpenSet Q ∧ G ∈ OpenSet R := by
+  constructor
+  · rintro ⟨s,⟨hq,hr⟩,hs⟩
+    exact ⟨⟨s,hq,hs⟩,⟨s,hr,hs⟩⟩
+  · rintro ⟨⟨s,hq,hs⟩,⟨t,hr,ht⟩⟩
+    obtain ⟨u,hsu,htu,hu⟩ := realizes_common hs ht
+    exact ⟨u,⟨hQ s u hsu hq,hR t u htu hr⟩,hu⟩
+
+theorem open_avoid {Q : PrefixPredicate} (hQ : ArithmeticPrefix Q)
+    (hup : ∀ O v, Upward (Q O v)) (O : Oracles) (v : ℕ) (G : Oracle)
+    (hG : Generic O G) :
+    G ∈ OpenSet (Avoid (Q O v)) ↔ ¬ G ∈ OpenSet (Q O v) := by
+  constructor
+  · rintro ⟨s,hs,hGs⟩ ⟨t,ht,hGt⟩
+    obtain ⟨u,hsu,htu,_⟩ := realizes_common hGs hGt
+    exact hs u hsu (hup O v t u htu ht)
+  · intro hn
+    have hd : Arith (fun O n => Decides (Q O v) (word n)) :=
+      ((decides_arith hQ).comp _ (Primrec₂.natPair.comp (Primrec.const v) Primrec.id)).congr
+        (fun _ _ => by simp only [left,right,Nat.unpair_pair,id_eq])
+    obtain ⟨s,hs,hGs⟩ := hG (fun O s => Decides (Q O v) s) hd (decides_dense _ (hup O v))
+    rcases hs with hs | hs
+    · exact False.elim (hn ⟨s,hs,hGs⟩)
+    · exact ⟨s,hs,hGs⟩
+
+end TuringRigidity.ArithmeticPrefixForcing
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticPresentation.lean

@@ -0,0 +1,50 @@
+import OAI.Computability.DegreeRigidity.SetModels.EnumerationTransport
+
+namespace OAI
+
+namespace TuringRigidity.ArithmeticPresentation
+open OracleJump ArithmeticHierarchy EncodedForcing BoundedDecoding IdealInterpretation
+open EnumerationDecoding EnumerationConstruction EnumerationTransport GlobalLocality
+noncomputable section
+
+theorem reduces_iterate (H : Oracle) (n : ℕ) : Reduces H (iterate H n) := by
+  induction n with
+  | zero => exact reduces_refl H
+  | succ n ih => exact reduces_trans ih (reduces_jump _)
+
+def Graph (π : Degree ≃o Degree) (H : Oracle) (v : ℕ) : Prop :=
+  π (degree (columns H (Nat.unpair v).1)) = degree (columns H (Nat.unpair v).2)
+
+theorem graph_arithmetic (π : Degree ≃o Degree) (H : Oracle)
+    (hz : Reduces (jump FixedArithmetic.zero) H)
+    (hpre : π.symm (degree (jump FixedArithmetic.zero)) ≤ degree H) :
+    Sigma (iterate H 6) 5 (Graph π H) ∧ RecursivePred (iterate H 11) (Graph π H) := by
+  obtain ⟨c,hout,hS,hP⟩ := enumeration_exists H hz
+  let d := mapEnumeration π c
+  obtain ⟨hdS,hdP⟩ := mapEnumeration_below π c (degree (jump H)) hS hP
+  have hb : π (degree (jump H)) ≤ degree (iterate H 6) := by
+    have hh := source_3_3_1 π (degree (jump H)) (hpre.trans (reduces_jump H))
+    rw [degreeIterate_degree] at hh
+    exact hh
+  have hg := graph_sigma (reduces_iterate H 6) d (hdS.mono hb) (hdP.mono hb)
+  have h : Sigma (iterate H 6) 5 (Graph π H) := hg.congr (fun v => by
+    simp only [d,mapEnumeration,hout,Graph])
+  have hr := form_recursive h
+  exact ⟨h,hr⟩
+
+theorem source_3_3_5 (π : Degree ≃o Degree) (I : DegreeIdeal) (H : Oracle)
+    (hpres : ∀ x, x ∈ I.carrier ↔ ∃ k, degree (columns H k) = x)
+    (hz : degree (jump FixedArithmetic.zero) ∈ I.carrier)
+    (hinv : ∀ x, π x ∈ I.carrier ↔ x ∈ I.carrier) :
+    Sigma (iterate H 6) 5 (Graph π H) ∧ RecursivePred (iterate H 11) (Graph π H) := by
+  have hbound (x : Degree) (hx : x ∈ I.carrier) : x ≤ degree H := by
+    obtain ⟨k,rfl⟩ := (hpres x).mp hx
+    exact CodingExtraction.column_projection_reduces H k
+  have hp : π.symm (degree (jump FixedArithmetic.zero)) ∈ I.carrier :=
+    (hinv _).mp (by simpa only [π.apply_symm_apply] using hz)
+  exact graph_arithmetic π H (hbound _ hz) (hbound _ hp)
+
+end
+end TuringRigidity.ArithmeticPresentation
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticPresentationProperty.lean

@@ -0,0 +1,98 @@
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticPersistence
+
+namespace OAI
+
+namespace TuringRigidity.ArithmeticPersistence
+open EncodedForcing OracleJump UniformArithmetic PersistentRestrictions
+open PersistentPresentation NumericalAutomorphism
+noncomputable section
+
+def IdealCode (A : Oracle) : Prop :=
+  (∀ n e, IndexPresentation.Dom (columns A n) e →
+    ∃ m, IndexPresentation.value (columns A n) e = degree (columns A m)) ∧
+  ∀ n m, ∃ k, degree (columns A n) ⊔ degree (columns A m) = degree (columns A k)
+
+def idealOfCode (A : Oracle) (h : IdealCode A) : CountableIdeal where
+  carrier := Set.range (fun n => degree (columns A n))
+  nonempty := ⟨degree (columns A 0),0,rfl⟩
+  countable := Set.countable_range _
+  lower := by
+    intro a b hab hb
+    obtain ⟨n,rfl⟩ := hb
+    obtain ⟨e,he,hv⟩ := IndexPresentation.value_surjective (columns A n) a hab
+    obtain ⟨m,hm⟩ := h.1 n e he
+    exact ⟨m,hm.symm.trans hv⟩
+  join_mem := by
+    intro a b ha hb
+    obtain ⟨n,rfl⟩ := ha
+    obtain ⟨m,rfl⟩ := hb
+    obtain ⟨k,hk⟩ := h.2 n m
+    exact ⟨k,hk.symm⟩
+
+theorem ideal_code {I : CountableIdeal} {A : Oracle} (hA : Presented I A) : IdealCode A := by
+  constructor
+  · intro n e _
+    obtain ⟨m,hm⟩ := (hA _).mp
+      (I.lower (IndexPresentation.value_below (columns A n) e) (entry hA n).property)
+    exact ⟨m,hm.symm⟩
+  · intro n m
+    obtain ⟨k,hk⟩ := (hA _).mp (I.join_mem (entry hA n).property (entry hA m).property)
+    exact ⟨k,hk.symm⟩
+
+def Base (A R : Oracle) : Prop :=
+  IdealCode A ∧ (∃ n, degree (jump FixedArithmetic.zero) = degree (columns A n)) ∧
+    Action A (fun v => R v = true)
+
+def Property (A R : Oracle) : Prop :=
+  ∃ I : CountableIdeal, ∃ hA : Presented I A,
+    degree (jump FixedArithmetic.zero) ∈ I.carrier ∧
+      ∃ ρ : I ≃o I, (∀ v, R v = true ↔ Graph ρ hA v) ∧ Persistent I ρ
+
+theorem property_iff (A R : Oracle) : Property A R ↔ Base A R ∧ Criterion A R := by
+  constructor
+  · rintro ⟨I,hA,hz,ρ,hR,hp⟩
+    have ha : Action A (fun v => R v = true) :=
+      (PersistenceCriterion.action_congr hR).mpr (action_of_automorphism hA ρ)
+    obtain ⟨n,hn⟩ := (hA _).mp hz
+    exact ⟨⟨ideal_code hA,⟨n,hn.symm⟩,ha⟩,(persistent_iff hA ρ hz hR).mp hp⟩
+  · rintro ⟨⟨hi,⟨n,hn⟩,ha⟩,hc⟩
+    let I := idealOfCode A hi
+    have hA : Presented I A := fun _ => Iff.rfl
+    have hz : degree (jump FixedArithmetic.zero) ∈ I.carrier := (hA _).mpr ⟨n,hn.symm⟩
+    obtain ⟨ρ,hR⟩ := reconstruct hA ha
+    exact ⟨I,hA,hz,ρ,hR,(persistent_iff hA ρ hz hR).mpr hc⟩
+
+theorem base_arith : Arith (fun O (_ : ℕ) => Base (O 0) (O 1)) := by
+  have hA := parameter_arith 0
+  have hR := parameter_arith 1
+  have hz : ArithmeticOracle (fun _ _ => FixedArithmetic.zero) := by
+    exact (equal (Primrec.const 0) (Primrec.const 1)).congr
+      (fun _ _ => by simp [FixedArithmetic.zero])
+  have hz' := (degree_equal_arith (jump_arith hz) (column_arith hA UniformArithmetic.right_primrec)).ex
+  have hi := (lower_arith hA).and (join_closed_arith hA)
+  exact (hi.and (hz'.and (action_arith hA hR))).congr
+    (fun _ _ => by simp only [Base,IdealCode,UniformArithmetic.right,Nat.unpair_pair])
+
+def parameters (A R H : Oracle) : Oracles
+  | 0 => A
+  | 1 => R
+  | _ => H
+
+def PiOneOne (P : Oracle → Oracle → Prop) : Prop :=
+  ∃ Q : Predicate, Arith Q ∧ ∀ A R, P A R ↔ ∀ H : Oracle, Q (parameters A R H) 0
+
+theorem source_4_2_1 : PiOneOne Property := by
+  refine ⟨fun O v => Base (O 0) (O 1) ∧ Matrix O v,
+    base_arith.and matrix_arith,fun A R => ?_⟩
+  rw [property_iff]
+  change Base A R ∧ Criterion A R ↔ ∀ H, Base A R ∧
+    (NumericalIdeal.JumpCode H → NumericalIdeal.Includes A H →
+      ∃ e, NumericalAutomorphism.Action H (fun v => tableOracle (iterate H 11) e v = true) ∧
+        NumericalExtension.Compatible A H (fun v => R v = true)
+          (fun v => tableOracle (iterate H 11) e v = true))
+  exact ⟨fun h H => ⟨h.1,h.2 H⟩,fun h => ⟨(h FixedArithmetic.zero).1,fun H => (h H).2⟩⟩
+
+end
+end TuringRigidity.ArithmeticPersistence
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticPrincipalIntersection.lean

@@ -0,0 +1,52 @@
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticRelations
+import OAI.Computability.DegreeRigidity.Representation.GenericIdentity
+
+namespace OAI
+
+
+namespace TuringRigidity.ArithmeticPrincipalIntersection
+open Encodable UniformArithmetic TableIndices IndexMatrix
+
+theorem principal_iff_tables (U L R : Oracle) :
+    GenericIdentity.PrincipalIntersection U L R ↔
+      Reduces U L ∧ Reduces U R ∧ ∀ e : ℕ, IndexPresentation.Dom L e →
+        Reduces (tableOracle L e) R → Reduces (tableOracle L e) U := by
+  constructor
+  · intro h
+    have hU := (h (degree U)).mp le_rfl
+    refine ⟨hU.1,hU.2,fun e he hR => ?_⟩
+    exact (h (degree (tableOracle L e))).mpr
+      ⟨represents_reduces ((valid_tableOracle L e).mp he),hR⟩
+  · rintro ⟨hL,hR,h⟩ b
+    obtain ⟨A,rfl⟩ := degree_surjective b
+    constructor
+    · intro hA
+      exact ⟨reduces_trans hA hL,reduces_trans hA hR⟩
+    · rintro ⟨haL,haR⟩
+      change Reduces A R at haR
+      change Reduces A U
+      obtain ⟨d,hd⟩ := (reduces_iff_represents A L).mp haL
+      have he : Represents L (machine (encode d)) A := by simpa using hd
+      have hvalid : IndexPresentation.Dom L (encode d) :=
+        (valid_iff_represents L _).mpr ⟨A,he⟩
+      have ht := tableOracle_eq he
+      have hh := h (encode d) hvalid (by simpa only [ht] using haR)
+      simpa only [ht] using hh
+
+theorem principal_arith {U L R : OracleFamily}
+    (hU : ArithmeticOracle U) (hL : ArithmeticOracle L) (hR : ArithmeticOracle R) :
+    Arith (fun O v => GenericIdentity.PrincipalIntersection (U O v) (L O v) (R O v)) := by
+  have hleft := reduces_arith hU hL
+  have hright := reduces_arith hU hR
+  have hd := valid_arith (hL.comp left_primrec) right_primrec
+  have hout := tableOracle_arith (hL.comp left_primrec) right_primrec
+  have hr := reduces_arith hout (hR.comp left_primrec)
+  have hu := reduces_arith hout (hU.comp left_primrec)
+  apply (hleft.and (hright.and (hd.imp (hr.imp hu)).all)).congr
+  intro O v
+  simp only [left,right,Nat.unpair_pair]
+  exact (principal_iff_tables (U O v) (L O v) (R O v)).symm
+
+end TuringRigidity.ArithmeticPrincipalIntersection
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticProgramGraph.lean

@@ -0,0 +1,43 @@
+import OAI.Computability.DegreeRigidity.Effective.UniformPartialGraph
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticRelations
+import OAI.Computability.DegreeRigidity.Representation.GenericTotality
+
+namespace OAI
+
+
+namespace TuringRigidity.ArithmeticProgramGraph
+open Encodable UniformArithmetic IndexMatrix GenericIdentity
+
+theorem eval_arith (p : OracleCode) {B : OracleFamily} (hB : ArithmeticOracle B)
+    {c n a : ℕ → ℕ} (hc : Primrec c) (hn : Primrec n) (ha : Primrec a) :
+    Arith (fun O v => a v ∈ OracleCode.eval (oracleFunction (B O (c v))) p (n v)) := by
+  obtain ⟨d, hd⟩ := UniformPartialGraph.eval_iff_table p
+  have h := (run_arith hB (hc.comp left_primrec) (Primrec.const (encode d))
+    (hn.comp left_primrec) right_primrec (ha.comp left_primrec)).ex
+  exact h.congr (fun O v => by
+    simpa only [left, right, Nat.unpair_pair, machine_encode, Option.mem_def] using
+      (hd (B O (c v)) (n v) (a v)).symm)
+
+theorem output_arith (p : OracleCode) {B : OracleFamily} (hB : ArithmeticOracle B) :
+    ArithmeticOracle (fun O v => programOutput p (B O v)) :=
+  (eval_arith p hB left_primrec right_primrec (Primrec.const 1)).congr
+    (fun _ _ => by simp [programOutput])
+
+theorem value_arith (p : OracleCode) {P A : OracleFamily}
+    (hP : ArithmeticOracle P) (hA : ArithmeticOracle A) :
+    ArithmeticOracle (fun O v => value p (P O v) (A O v)) :=
+  output_arith p (join_arith hA hP)
+
+theorem total_arith (p : OracleCode) {P A : OracleFamily}
+    (hP : ArithmeticOracle P) (hA : ArithmeticOracle A) :
+    Arith (fun O v => Total p (P O v) (A O v)) := by
+  have hB := join_arith hA hP
+  have h0 := eval_arith p hB left_primrec right_primrec (Primrec.const 0)
+  have h1 := eval_arith p hB left_primrec right_primrec (Primrec.const 1)
+  exact (h0.or h1).all.congr (fun O v => by
+    simpa only [left, right, Nat.unpair_pair, BinaryHalts] using
+      (total_iff_binaryHalts p (P O v) (A O v)).symm)
+
+end TuringRigidity.ArithmeticProgramGraph
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticRelations.lean

@@ -0,0 +1,75 @@
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticOracles
+
+namespace OAI
+
+namespace TuringRigidity.UniformArithmetic
+open Encodable CommonIdeal IndexMatrix TableIndices OracleJump
+noncomputable section
+
+theorem represents_arith {A B : OracleFamily} (hA : ArithmeticOracle A)
+    (hB : ArithmeticOracle B) {e : ℕ → ℕ} (he : Primrec e) :
+    Arith (fun O v => Represents (B O v) (machine (e v)) (A O v)) := by
+  let c := left_primrec.comp (left_primrec.comp left_primrec)
+  let n := right_primrec.comp (left_primrec.comp left_primrec)
+  let z := right_primrec.comp left_primrec
+  have hr := run_arith hB c (he.comp c) n z right_primrec
+  have hb := bit_equal hA c n right_primrec
+  have h := ((hr.imp hb).all.all.all).and ((hr.and hb).ex.ex.all)
+  apply h.congr
+  intro O v
+  simp only [left,right,Nat.unpair_pair]
+  constructor
+  · rintro ⟨hs,ht⟩
+    exact ⟨fun n z a ha => hs n z a (Option.mem_def.mp ha),
+      fun n => by obtain ⟨z,a,ha,_⟩ := ht n; exact ⟨z,a,Option.mem_def.mpr ha⟩⟩
+  · rintro ⟨hs,ht⟩
+    exact ⟨fun n z a ha => hs n z a (Option.mem_def.mpr ha),
+      fun n => by obtain ⟨z,a,ha⟩ := ht n; exact ⟨z,a,Option.mem_def.mp ha,hs n z a ha⟩⟩
+
+theorem valid_tableOracle (B : Oracle) (e : ℕ) :
+    Valid B (machine e) ↔ Represents B (machine e) (tableOracle B e) := by
+  constructor
+  · intro hv
+    obtain ⟨A,hA⟩ := (valid_iff_represents B (machine e)).mp hv
+    rw [tableOracle_eq hA]
+    exact hA
+  · intro h
+    exact (valid_iff_represents B (machine e)).mpr ⟨_,h⟩
+
+theorem valid_arith {B : OracleFamily} (hB : ArithmeticOracle B)
+    {e : ℕ → ℕ} (he : Primrec e) :
+    Arith (fun O v => IndexPresentation.Dom (B O v) (e v)) :=
+  (represents_arith (tableOracle_arith hB he) hB he).congr
+    (fun O v => (valid_tableOracle (B O v) (e v)).symm)
+
+theorem reduces_arith {A B : OracleFamily} (hA : ArithmeticOracle A)
+    (hB : ArithmeticOracle B) : Arith (fun O v => Reduces (A O v) (B O v)) := by
+  have h := (represents_arith (hA.comp left_primrec) (hB.comp left_primrec) right_primrec).ex
+  apply h.congr
+  intro O v
+  simp only [left,right,Nat.unpair_pair]
+  rw [reduces_iff_represents]
+  constructor
+  · rintro ⟨e,he⟩
+    exact ⟨machine e,he⟩
+  · rintro ⟨e,he⟩
+    exact ⟨encode e,by simpa using he⟩
+
+theorem degree_equal_arith {A B : OracleFamily} (hA : ArithmeticOracle A)
+    (hB : ArithmeticOracle B) : Arith (fun O v => degree (A O v) = degree (B O v)) :=
+  ((reduces_arith hA hB).and (reduces_arith hB hA)).congr
+    (fun O v => (degree_eq_iff (A O v) (B O v)).symm)
+
+theorem join_arith {A B : OracleFamily} (hA : ArithmeticOracle A)
+    (hB : ArithmeticOracle B) : ArithmeticOracle (fun O v => join (A O v) (B O v)) := by
+  have ht : Arith (fun (_ : Oracles) v => (right v).bodd = true) :=
+    .pure _ (Primrec.eq.comp (Primrec.nat_bodd.comp right_primrec) (Primrec.const true))
+  have hd : Primrec (fun v => right v / 2) := Primrec.nat_div.comp right_primrec (Primrec.const 2)
+  exact ((ht.and (query_at hB left_primrec hd)).or
+    (ht.neg.and (query_at hA left_primrec hd))).congr (fun O v => by
+      cases h : (right v).bodd <;> simp [join,h])
+
+end
+end TuringRigidity.UniformArithmetic
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticSetSyntax.lean

@@ -0,0 +1,103 @@
+import OAI.Computability.DegreeRigidity.Syntax.PrimitivePredicateFormula
+import OAI.Computability.DegreeRigidity.SetModels.ModelReals
+import OAI.Computability.DegreeRigidity.Computability.UniformArithmetic
+
+namespace OAI
+
+
+namespace TuringRigidity.BoundedSetTheory
+open UniformArithmetic
+universe u
+
+noncomputable def arithmeticEnv (Q : ZFSet.{u}) (O : Oracles) (n : ℕ) : ℕ → ZFSet.{u} :=
+  cons (natSet n) (cons ZFSet.omega (cons Q (fun i => realCode (O i))))
+
+def DefinesArithmetic (φ : Formula) (P : Predicate) : Prop :=
+  ∀ Q : ZFSet.{u}, (∀ f : ℕ → ℕ, ∀ k, finiteNaturalGraph f k ∈ Q) → ∀ O n,
+    (φ.Eval (arithmeticEnv Q O n) ↔ P O n)
+
+namespace Formula
+def arithmeticVars (k : ℕ) : ℕ → ℕ
+  | 0 => 0
+  | i+1 => i+k+1
+
+theorem eval_arithmetic_shift_one (φ : Formula) (Q : ZFSet.{u}) (O : Oracles) (n m : ℕ) :
+    (φ.rename (arithmeticVars 1)).Eval (cons (natSet m) (arithmeticEnv Q O n)) ↔
+      φ.Eval (arithmeticEnv Q O m) := by
+  rw [eval_rename]
+  have he : (fun i => cons (natSet m) (arithmeticEnv Q O n) (arithmeticVars 1 i)) = arithmeticEnv Q O m := by
+    funext i; cases i <;> rfl
+  rw [he]
+
+theorem eval_arithmetic_shift_two (φ : Formula) (Q : ZFSet.{u}) (O : Oracles) (n k m : ℕ) :
+    (φ.rename (arithmeticVars 2)).Eval (cons (natSet m) (cons (natSet k) (arithmeticEnv Q O n))) ↔
+      φ.Eval (arithmeticEnv Q O m) := by
+  rw [eval_rename]
+  have he : (fun i => cons (natSet m) (cons (natSet k) (arithmeticEnv Q O n)) (arithmeticVars 2 i)) =
+      arithmeticEnv Q O m := by
+    funext i; cases i <;> rfl
+  rw [he]
+
+def arithmeticExists (φ : Formula) : Formula := .existsMem 1 (.existsMem 2
+  (.conj (naturalPair 3 4 2 1 0) (φ.rename (arithmeticVars 2))))
+
+def arithmeticComp (φ ψ : Formula) : Formula := .existsMem 1
+  (.conj (unary ψ 2 3 1 0) (φ.rename (arithmeticVars 1)))
+end Formula
+
+theorem DefinesArithmetic.existsNat {φ : Formula} {P : Predicate} (hφ : DefinesArithmetic.{u} φ P) :
+    DefinesArithmetic.{u} φ.arithmeticExists (fun O n => ∃ k, P O (Nat.pair n k)) := by
+  intro Q hQ O n
+  have hp (k : ℕ) (w : ZFSet.{u}) := Formula.naturalPair_spec 3 4 2 1 0
+    (cons w (cons (natSet k) (arithmeticEnv Q O n))) rfl hQ n k rfl rfl
+  simp only [Formula.arithmeticExists,Formula.Eval,arithmeticEnv,cons_zero,cons_succ]
+  constructor
+  · rintro ⟨x,hx,w,_,hpair,h⟩
+    obtain ⟨k,rfl⟩ := (mem_omega x).mp hx
+    obtain rfl := (hp k w).mp hpair
+    exact ⟨k,(hφ Q hQ O _).mp ((Formula.eval_arithmetic_shift_two φ Q O n k _).mp h)⟩
+  · rintro ⟨k,h⟩
+    exact ⟨natSet k,(mem_omega _).mpr ⟨k,rfl⟩,natSet (Nat.pair n k),
+      (mem_omega _).mpr ⟨Nat.pair n k,rfl⟩,(hp k _).mpr rfl,
+      (Formula.eval_arithmetic_shift_two φ Q O n k _).mpr ((hφ Q hQ O _).mpr h)⟩
+
+theorem DefinesArithmetic.comp {φ ψ : Formula} {P : Predicate} {f : ℕ → ℕ}
+    (hφ : DefinesArithmetic.{u} φ P) (hψ : DefinesNatural.{u} ψ f) :
+    DefinesArithmetic.{u} (φ.arithmeticComp ψ) (fun O n => P O (f n)) := by
+  intro Q hQ O n
+  have hf (w : ZFSet.{u}) := Formula.unary_spec hψ 2 3 1 0
+    (cons w (arithmeticEnv Q O n)) rfl hQ n rfl
+  simp only [Formula.arithmeticComp,Formula.Eval,arithmeticEnv,cons_zero,cons_succ]
+  constructor
+  · rintro ⟨w,_,hw,h⟩
+    obtain rfl := (hf w).mp hw
+    exact (hφ Q hQ O _).mp ((Formula.eval_arithmetic_shift_one φ Q O n _).mp h)
+  · intro h
+    exact ⟨natSet (f n),(mem_omega _).mpr ⟨f n,rfl⟩,(hf _).mpr rfl,
+      (Formula.eval_arithmetic_shift_one φ Q O n _).mpr ((hφ Q hQ O _).mpr h)⟩
+
+theorem arithmetic_bounded_definition {P : Predicate} (hP : Arith P) :
+    ∃ φ : Formula, DefinesArithmetic.{u} φ P := by
+  induction hP with
+  | pure P hP =>
+    obtain ⟨φ,hφ⟩ := primitive_predicate_bounded.{u} hP
+    exact ⟨φ,fun Q hQ O n => hφ (arithmeticEnv Q O n) rfl hQ n rfl⟩
+  | query i =>
+    exact ⟨.member 0 (i+3),fun Q _ O n => natSet_mem_realCode (O i) n⟩
+  | neg h ih =>
+    obtain ⟨φ,hφ⟩ := ih
+    exact ⟨.neg φ,fun Q hQ O n => not_congr (hφ Q hQ O n)⟩
+  | and h k ih ik =>
+    obtain ⟨φ,hφ⟩ := ih; obtain ⟨ψ,hψ⟩ := ik
+    exact ⟨.conj φ ψ,fun Q hQ O n => and_congr (hφ Q hQ O n) (hψ Q hQ O n)⟩
+  | ex h ih =>
+    obtain ⟨φ,hφ⟩ := ih
+    exact ⟨φ.arithmeticExists,hφ.existsNat⟩
+  | comp f h hf ih =>
+    obtain ⟨φ,hφ⟩ := ih
+    obtain ⟨ψ,hψ⟩ := primitive_bounded_definition.{u} (Primrec.nat_iff.mp hf)
+    exact ⟨φ.arithmeticComp ψ,hφ.comp hψ⟩
+
+end TuringRigidity.BoundedSetTheory
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticShuffleCertificate.lean

@@ -0,0 +1,59 @@
+import OAI.Computability.DegreeRigidity.Effective.FiniteShuffleComputation
+import OAI.Computability.DegreeRigidity.Computability.UniformArithmetic
+
+namespace OAI
+
+
+namespace TuringRigidity.ArithmeticShuffleCertificate
+open Encodable UniformArithmetic FiniteShuffleComputation FiniteShuffleCertificate
+open EncodedForcing (word word_primrec)
+
+theorem certificate_arith :
+    Arith (fun O n => Certificate (fun t => O 0 (encode t) = true) (word n)) := by
+  let L := left_primrec
+  let R := right_primrec
+
+  let hn := L.comp (L.comp L)
+  let hk := R.comp (L.comp L)
+  let hs := R.comp L
+  have hshuffle := finiteShuffleWord_primrec.comp
+    (Primrec₂.natPair.comp hs (Primrec₂.natPair.comp hn R))
+  have hquery := (Arith.query 0).comp _ hshuffle
+  have hbound := Arith.pure (fun v => right v ≤ right (left (left v)))
+    (Primrec.nat_le.comp R hk)
+  have hex := (hbound.and hquery).ex
+  have hlength := equal (Primrec.list_length.comp (word_primrec.comp R)) (R.comp L)
+  have hall := (hlength.imp hex).all
+  have hsize := Arith.pure (fun v => 2 * right v ≤ (word (left v)).length)
+    (Primrec.nat_le.comp (Primrec.nat_mul.comp (Primrec.const 2) R)
+      (Primrec.list_length.comp (word_primrec.comp L)))
+  apply (hsize.and hall).ex.congr
+  intro O n
+  simp only [left,right,Nat.unpair_pair,finiteShuffleWord]
+  constructor
+  · rintro ⟨k,hk,h⟩
+    refine ⟨k,hk,fun s hs => ?_⟩
+    have hlen : (word (encode s)).length = k := by simpa [word] using hs
+    simpa [word] using h (encode s) hlen
+  · rintro ⟨k,hk,h⟩
+    exact ⟨k,hk,fun s hs => h (word s) hs⟩
+
+theorem open_arith : Arith (fun O n =>
+    ∃ r : List Bool, O 0 (encode r) = true ∧ r <+: word n) := by
+  have hp : Arith (fun (_ : Oracles) v => word (right v) <+: word (left v)) :=
+    (Arith.pure _ (Primrec.eq.comp (word_primrec.comp right_primrec)
+      (Primrec.list_take.comp (Primrec.list_length.comp (word_primrec.comp right_primrec))
+        (word_primrec.comp left_primrec)))).congr (fun _ _ => List.prefix_iff_eq_take.symm)
+  have hq := (Arith.query 0).comp _ (Primrec.encode.comp (word_primrec.comp right_primrec))
+  apply (hq.and hp).ex.congr
+  intro O n
+  simp only [left,right,Nat.unpair_pair]
+  constructor
+  · rintro ⟨r,hr,hp⟩
+    exact ⟨word r,hr,hp⟩
+  · rintro ⟨r,hr,hp⟩
+    exact ⟨encode r,by simpa [word] using hr,by simpa [word] using hp⟩
+
+end TuringRigidity.ArithmeticShuffleCertificate
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticShuffleGraph.lean

@@ -0,0 +1,77 @@
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticOracles
+import OAI.Computability.DegreeRigidity.Effective.FiniteShuffleComputation
+
+namespace OAI
+
+
+namespace TuringRigidity.ArithmeticShuffleGraph
+open Encodable UniformArithmetic FiniteShuffle ShuffleRequirements GenericCoding
+open EncodedForcing (word word_primrec)
+
+theorem realizes_arith {B : OracleFamily} (hB : ArithmeticOracle B)
+    {c s : ℕ → ℕ} (hc : Primrec c) (hs : Primrec s) :
+    Arith (fun O v => Realizes (word (s v)) (B O (c v))) := by
+  have hb := Arith.pure (fun v => (word (s (left v))).getD (right v) false = true)
+    (Primrec.eq.comp ((Primrec.list_getD false).comp
+      (word_primrec.comp (hs.comp left_primrec)) right_primrec) (Primrec.const true))
+  have hq := query_at hB (hc.comp left_primrec) right_primrec
+  have hl := less right_primrec
+    (Primrec.list_length.comp (word_primrec.comp (hs.comp left_primrec)))
+  apply (hl.imp (hb.iff hq)).all.congr
+  intro O v
+  simp only [left, right, Nat.unpair_pair]
+  constructor
+  · intro h i hi
+    have hh := h i hi
+    cases hb : (word (s v)).getD i false <;> cases ho : B O (c v) i <;> simp_all
+  · intro h i hi
+    rw [show (word (s v)).getD i false = B O (c v) i from h i hi]
+
+theorem code_bit_iff (Y L : Oracle) (n : ℕ) :
+    code Y L n = true ↔ ∃ s t : ℕ,
+      (word s).length = n + 1 ∧ (word t).length = 2 * (n + 1) ∧
+      Realizes (word s) Y ∧ Realizes (word t) L ∧
+      code (fun i => (word s).getD i false) (fun i => (word t).getD i false) n = true := by
+  constructor
+  · intro h
+    refine ⟨encode (initial Y (n + 1)), encode (initial L (2 * (n + 1))), ?_⟩
+    simp only [word, Encodable.encodek, Option.getD_some, prefix_length]
+    have hy : Realizes (initial Y (n + 1)) Y :=
+      (realizes_initial _ _ _).mpr (fun _ _ => rfl)
+    have hl : Realizes (initial L (2 * (n + 1))) L :=
+      (realizes_initial _ _ _).mpr (fun _ _ => rfl)
+    have he := code_agree (n := n + 1)
+      (show Agree (n + 1) (fun i => (initial Y (n+1)).getD i false) Y from
+        fun i hi => prefix_getD Y _ i hi)
+      (show Agree (2 * (n + 1)) (fun i => (initial L (2*(n+1))).getD i false) L from
+        fun i hi => prefix_getD L _ i hi)
+    exact ⟨True.intro, True.intro, hy, hl, (he n (by omega)).trans h⟩
+  · rintro ⟨s,t,hs,ht,hy,hl,h⟩
+    have hy' : Agree (n + 1) (fun i => (word s).getD i false) Y := by
+      simpa only [Realizes, hs] using hy
+    have hl' : Agree (2 * (n + 1)) (fun i => (word t).getD i false) L := by
+      simpa only [Realizes, ht] using hl
+    exact ((code_agree hy' hl') n (by omega)).symm.trans h
+
+theorem code_arith {Y L : OracleFamily}
+    (hY : ArithmeticOracle Y) (hL : ArithmeticOracle L) :
+    ArithmeticOracle (fun O v => code (Y O v) (L O v)) := by
+  let base := left_primrec.comp (left_primrec.comp left_primrec)
+  let n := right_primrec.comp (left_primrec.comp left_primrec)
+  let s := right_primrec.comp left_primrec
+  let t := right_primrec
+  have hs := equal (Primrec.list_length.comp (word_primrec.comp s)) (Primrec.succ.comp n)
+  have ht := equal (Primrec.list_length.comp (word_primrec.comp t))
+    (Primrec.nat_mul.comp (Primrec.const 2) (Primrec.succ.comp n))
+  have hy := realizes_arith hY base s
+  have hl := realizes_arith hL base t
+  have hb := Arith.pure _ (Primrec.eq.comp
+    (FiniteShuffleComputation.wordShuffleBit_primrec.comp
+      ((word_primrec.comp s).pair ((word_primrec.comp t).pair n))) (Primrec.const true))
+  exact (hs.and (ht.and (hy.and (hl.and hb)))).ex.ex.congr (fun O v => by
+    simpa only [base,n,s,t,left,right,Nat.unpair_pair] using
+      (code_bit_iff (Y O (left v)) (L O (left v)) (right v)).symm)
+
+end TuringRigidity.ArithmeticShuffleGraph
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticSkolem.lean

@@ -0,0 +1,165 @@
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticFiniteTest
+
+namespace OAI
+
+namespace TuringRigidity.ArithmeticTree
+open UniformArithmetic
+noncomputable section
+
+def HasTest (P : Predicate) : Prop := ∃ t : Test, t.Presents P
+
+namespace HasTest
+
+private def col (k : ℕ) (t : Test) : Test :=
+  t.subst .input (fun s => .witness (.pair (.const k) s))
+
+private theorem col_eval (k : ℕ) (t : Test) (O : Oracles) (f : ℕ → ℕ) (v : ℕ) :
+    (col k t).eval O f v ↔ t.eval O (fun n => f (Nat.pair k n)) v :=
+  t.eval_subst _ _ O f _ v (fun _ => rfl)
+
+theorem pure (P : ℕ → Prop) (hP : PrimrecPred P) : HasTest (fun _ v => P v) := by
+  refine ⟨.pure P hP (.left .input),fun O v => ?_⟩
+  simp only [Test.eval,Term.eval,Term.left,UniformArithmetic.left,Nat.unpair_pair]
+  exact ⟨fun h => ⟨fun _ => 0,fun _ => h⟩,fun ⟨_,h⟩ => h 0⟩
+
+theorem query (i : ℕ) : HasTest (fun O v => O i v = true) := by
+  refine ⟨.query i (.left .input),fun O v => ?_⟩
+  simp only [Test.eval,Term.eval,Term.left,UniformArithmetic.left,Nat.unpair_pair]
+  exact ⟨fun h => ⟨fun _ => 0,fun _ => h⟩,fun ⟨_,h⟩ => h 0⟩
+
+theorem not_pure (P : ℕ → Prop) (hP : PrimrecPred P) : HasTest (fun _ v => ¬ P v) := by
+  refine ⟨.neg (.pure P hP (.left .input)),fun O v => ?_⟩
+  simp only [Test.eval,Term.eval,Term.left,UniformArithmetic.left,Nat.unpair_pair]
+  exact ⟨fun h => ⟨fun _ => 0,fun _ => h⟩,fun ⟨_,h⟩ => h 0⟩
+
+theorem not_query (i : ℕ) : HasTest (fun O v => ¬ O i v = true) := by
+  refine ⟨.neg (.query i (.left .input)),fun O v => ?_⟩
+  simp only [Test.eval,Term.eval,Term.left,UniformArithmetic.left,Nat.unpair_pair]
+  exact ⟨fun h => ⟨fun _ => 0,fun _ => h⟩,fun ⟨_,h⟩ => h 0⟩
+
+theorem and {P Q} (hP : HasTest P) (hQ : HasTest Q) :
+    HasTest (fun O v => P O v ∧ Q O v) := by
+  classical
+  obtain ⟨t,ht⟩ := hP
+  obtain ⟨s,hs⟩ := hQ
+  refine ⟨.and (col 0 t) (col 1 s),fun O v => ?_⟩
+  simp only [Test.eval,col_eval]
+  constructor
+  · rintro ⟨hp,hq⟩
+    obtain ⟨f,hf⟩ := (ht O v).mp hp
+    obtain ⟨g,hg⟩ := (hs O v).mp hq
+    refine ⟨fun k => if (Nat.unpair k).1 = 0 then f (Nat.unpair k).2 else g (Nat.unpair k).2,?_⟩
+    intro n
+    constructor
+    · simpa only [Nat.unpair_pair,ite_eq_left rfl,ite_true] using hf n
+    · simpa only [Nat.unpair_pair,ite_eq_right (Nat.one_ne_zero)] using hg n
+  · rintro ⟨f,hf⟩
+    exact ⟨(ht O v).mpr ⟨_,fun n => (hf n).1⟩,
+      (hs O v).mpr ⟨_,fun n => (hf n).2⟩⟩
+
+private def tailTest (t : Test) : Test :=
+  t.subst .input (fun s => .witness (.prim Nat.succ Primrec.succ s))
+
+private theorem tail_eval (t : Test) (O : Oracles) (f : ℕ → ℕ) (v : ℕ) :
+    (tailTest t).eval O f v ↔ t.eval O (fun n => f (n+1)) v :=
+  t.eval_subst _ _ O f _ v (fun _ => rfl)
+
+private def zeroTag : Test :=
+  .pure (fun n => n = 0) (Primrec.eq.comp Primrec.id (Primrec.const 0))
+    (.witness (.const 0))
+
+theorem or {P Q} (hP : HasTest P) (hQ : HasTest Q) :
+    HasTest (fun O v => P O v ∨ Q O v) := by
+  classical
+  obtain ⟨t,ht⟩ := hP
+  obtain ⟨s,hs⟩ := hQ
+  refine ⟨(Test.and zeroTag (tailTest t)).or (.and (.neg zeroTag) (tailTest s)),fun O v => ?_⟩
+  simp only [Test.eval_or,Test.eval,tail_eval,zeroTag,Term.eval]
+  constructor
+  · intro h
+    rcases h with hp | hq
+    · obtain ⟨f,hf⟩ := (ht O v).mp hp
+      exact ⟨(fun n => Nat.casesOn n 0 f),fun n => Or.inl ⟨rfl,hf n⟩⟩
+    · obtain ⟨g,hg⟩ := (hs O v).mp hq
+      exact ⟨(fun n => Nat.casesOn n 1 g),fun n => Or.inr ⟨by simp,hg n⟩⟩
+  · rintro ⟨f,hf⟩
+    by_cases hz : f 0 = 0
+    · exact Or.inl ((ht O v).mpr ⟨_,fun n => ((hf n).resolve_right (fun h => h.1 hz)).2⟩)
+    · exact Or.inr ((hs O v).mpr ⟨_,fun n => ((hf n).resolve_left (fun h => hz h.1)).2⟩)
+
+theorem comp {P} (hP : HasTest P) (g : ℕ → ℕ) (hg : Primrec g) :
+    HasTest (fun O v => P O (g v)) := by
+  obtain ⟨t,ht⟩ := hP
+  let inputTerm : Term := .pair (.prim g hg (.left .input)) (.right .input)
+  refine ⟨t.subst inputTerm Term.witness,fun O v => ?_⟩
+  dsimp only
+  rw [ht]
+  apply exists_congr
+  intro f
+  apply forall_congr'
+  intro n
+  simpa only [inputTerm,Term.eval,Term.left,Term.right,UniformArithmetic.left,
+    UniformArithmetic.right,Nat.unpair_pair] using
+    (t.eval_subst inputTerm Term.witness O f f (Nat.pair v n) (fun _ => rfl)).symm
+
+theorem ex {P} (hP : HasTest P) : HasTest (fun O v => ∃ k, P O (Nat.pair v k)) := by
+  obtain ⟨t,ht⟩ := hP
+  let inputTerm : Term := .pair (.pair (.left .input) (.witness (.const 0))) (.right .input)
+  let q : Term → Term := fun s => .witness (.prim Nat.succ Primrec.succ s)
+  have he O f v n : (t.subst inputTerm q).eval O f (Nat.pair v n) ↔
+      t.eval O (fun k => f (k+1)) (Nat.pair (Nat.pair v (f 0)) n) := by
+    simpa only [inputTerm,Term.eval,Term.left,Term.right,UniformArithmetic.left,
+      UniformArithmetic.right,Nat.unpair_pair] using
+      t.eval_subst inputTerm q O f (fun k => f (k+1)) (Nat.pair v n) (fun _ => rfl)
+  refine ⟨t.subst inputTerm q,fun O v => ?_⟩
+  constructor
+  · rintro ⟨k,hk⟩
+    obtain ⟨f,hf⟩ := (ht O (Nat.pair v k)).mp hk
+    exact ⟨(fun n => Nat.casesOn n k f),fun n => (he _ _ _ _).mpr (hf n)⟩
+  · rintro ⟨f,hf⟩
+    exact ⟨f 0,(ht O _).mpr ⟨_,fun n => (he _ _ _ _).mp (hf n)⟩⟩
+
+theorem all {P} (hP : HasTest P) : HasTest (fun O v => ∀ k, P O (Nat.pair v k)) := by
+  classical
+  obtain ⟨t,ht⟩ := hP
+  let inputTerm : Term := .pair (.pair (.left .input) (.left (.right .input))) (.right (.right .input))
+  let q : Term → Term := fun s => .witness (.pair (.left (.right .input)) s)
+  have he O f v n : (t.subst inputTerm q).eval O f (Nat.pair v n) ↔
+      t.eval O (fun k => f (Nat.pair (Nat.unpair n).1 k))
+        (Nat.pair (Nat.pair v (Nat.unpair n).1) (Nat.unpair n).2) := by
+    simpa only [inputTerm,Term.eval,Term.left,Term.right,UniformArithmetic.left,
+      UniformArithmetic.right,Nat.unpair_pair] using
+      t.eval_subst inputTerm q O f (fun k => f (Nat.pair (Nat.unpair n).1 k))
+        (Nat.pair v n) (fun _ => by simp [q,Term.eval,Term.left,Term.right,
+          UniformArithmetic.left,UniformArithmetic.right])
+  refine ⟨t.subst inputTerm q,fun O v => ?_⟩
+  constructor
+  · intro h
+    have hh : ∀ k, ∃ f, ∀ n, t.eval O f (Nat.pair (Nat.pair v k) n) :=
+      fun k => (ht O _).mp (h k)
+    choose f hf using hh
+    refine ⟨fun n => f (Nat.unpair n).1 (Nat.unpair n).2,fun n => (he _ _ _ _).mpr ?_⟩
+    simpa only [Nat.unpair_pair] using hf (Nat.unpair n).1 (Nat.unpair n).2
+  · rintro ⟨f,hf⟩ k
+    refine (ht O _).mpr ⟨fun n => f (Nat.pair k n),fun n => ?_⟩
+    simpa only [Nat.unpair_pair] using (he _ _ _ _).mp (hf (Nat.pair k n))
+
+theorem congr {P Q} (hP : HasTest P) (he : ∀ O v, P O v ↔ Q O v) : HasTest Q := by
+  obtain ⟨t,ht⟩ := hP
+  exact ⟨t,fun O v => (he O v).symm.trans (ht O v)⟩
+end HasTest
+
+theorem arithmetic_tests {P} (h : Arith P) : HasTest P ∧ HasTest (fun O v => ¬ P O v) := by
+  induction h with
+  | pure P hP => exact ⟨HasTest.pure P hP,HasTest.not_pure P hP⟩
+  | query i => exact ⟨HasTest.query i,HasTest.not_query i⟩
+  | neg h ih => exact ⟨ih.2,ih.1.congr (fun _ _ => not_not.symm)⟩
+  | and h k ih ik =>
+    exact ⟨ih.1.and ik.1,(ih.2.or ik.2).congr (fun _ _ => not_and_or.symm)⟩
+  | ex h ih => exact ⟨ih.1.ex,ih.2.all.congr (fun _ _ => not_exists.symm)⟩
+  | comp f h hf ih => exact ⟨ih.1.comp f hf,ih.2.comp f hf⟩
+
+end
+end TuringRigidity.ArithmeticTree
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticSourceEquation.lean

@@ -0,0 +1,31 @@
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticProgramGraph
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticShuffleGraph
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticPrincipalIntersection
+
+namespace OAI
+
+
+namespace TuringRigidity.ArithmeticSourceEquation
+open UniformArithmetic ArithmeticProgramGraph ArithmeticShuffleGraph GenericIdentity
+
+theorem equation_arith (p : OracleCode) {P Y L R : OracleFamily}
+    (hP : ArithmeticOracle P) (hY : ArithmeticOracle Y)
+    (hL : ArithmeticOracle L) (hR : ArithmeticOracle R) :
+    Arith (fun O v => SourceEquation p (P O v) (Y O v, L O v, R O v)) := by
+  have hYL := code_arith hY hL
+  have hYR := code_arith hY hR
+  have hi := ArithmeticPrincipalIntersection.principal_arith (value_arith p hP hY)
+    (join_arith (value_arith p hP hYL) (value_arith p hP hL))
+    (join_arith (value_arith p hP hYR) (value_arith p hP hR))
+  exact (total_arith p hP hY).and ((total_arith p hP hL).and
+    ((total_arith p hP hR).and ((total_arith p hP hYL).and
+      ((total_arith p hP hYR).and hi))))
+
+theorem sourceEquation_arith (p : OracleCode) :
+    Arith (fun O _ => SourceEquation p (O 0) (O 1, O 2, O 3)) :=
+  equation_arith p (parameter_arith 0) (parameter_arith 1)
+    (parameter_arith 2) (parameter_arith 3)
+
+end TuringRigidity.ArithmeticSourceEquation
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticSourceTruth.lean

@@ -0,0 +1,48 @@
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticSourceEquation
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticGenericDensity
+
+namespace OAI
+
+
+namespace TuringRigidity.ArithmeticSourceTruth
+open UniformArithmetic ArithmeticPrefixForcing GenericIdentity GenericTruth ShuffleRequirements
+
+theorem binary_column_arith {B : OracleFamily} (hB : ArithmeticOracle B) (b : Bool) :
+    ArithmeticOracle (fun O v => PairGenericSelection.column b (B O v)) := by
+  have he := Primrec.nat_mul.comp (Primrec.const 2) right_primrec
+  cases b with
+  | false => exact query_at hB left_primrec he
+  | true => exact query_at hB left_primrec (Primrec.succ.comp he)
+
+theorem triple_equation_arith (p : OracleCode) :
+    Arith (fun O _ => SourceEquation p (O 1) (triple (O 0))) :=
+  ArithmeticSourceEquation.equation_arith p (parameter_arith 1)
+    (binary_column_arith (parameter_arith 0) false)
+    (binary_column_arith (binary_column_arith (parameter_arith 0) true) false)
+    (binary_column_arith (binary_column_arith (parameter_arith 0) true) true)
+
+theorem source_equation_truth (p : OracleCode) :
+    ∃ Q : PrefixPredicate, ArithmeticPrefix Q ∧ (∀ O v, Upward (Q O v)) ∧
+      ∀ P G : Oracle, Generic (fun _ => P) G →
+        (SourceEquation p P (triple G) ↔
+          G ∈ OpenSet (Q (fun _ => P) 0)) := by
+  obtain ⟨Q,hQ,hup,ht⟩ := ArithmeticGenericTruth.arithmetic_generic_truth (triple_equation_arith p)
+  refine ⟨Q,hQ,hup,?_⟩
+  intro P G hG
+  simpa using ht (fun _ => P) 0 G hG
+
+theorem source_equation_of_dense (p : OracleCode) (P : Oracle)
+    (hd : ∀ s : List Bool, ∃ H : Oracle,
+      Generic (fun _ => P) H ∧ Realizes s H ∧ SourceEquation p P (triple H)) :
+    ∀ G : Oracle, Generic (fun _ => P) G → SourceEquation p P (triple G) := by
+  have hden : ∀ s : List Bool, ∃ H : Oracle,
+      Generic (fun _ => P) H ∧ Realizes s H ∧
+        SourceEquation p ((Function.update (fun _ => P) 0 H) 1)
+          (triple ((Function.update (fun _ => P) 0 H) 0)) := by
+    simpa using hd
+  simpa using ArithmeticGenericDensity.truth_of_dense (triple_equation_arith p)
+    (fun _ => P) 0 hden
+
+end TuringRigidity.ArithmeticSourceTruth
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticTables.lean

@@ -0,0 +1,100 @@
+import OAI.Computability.DegreeRigidity.Computability.UniformArithmetic
+
+namespace OAI
+
+namespace TuringRigidity.UniformArithmetic
+open Encodable UniformOracle CommonIdeal IndexMatrix
+
+abbrev OracleFamily := Oracles → ℕ → Oracle
+abbrev ArithmeticOracle (B : OracleFamily) :=
+  Arith (fun O v => B O (left v) (right v) = true)
+
+theorem query_at {B : OracleFamily} (hB : ArithmeticOracle B)
+    {c n : ℕ → ℕ} (hc : Primrec c) (hn : Primrec n) :
+    Arith (fun O v => B O (c v) (n v) = true) :=
+  (hB.comp _ (Primrec₂.natPair.comp hc hn)).congr
+    (fun _ _ => by simp only [left,right,Nat.unpair_pair])
+
+theorem bit_equal {B : OracleFamily} (hB : ArithmeticOracle B)
+    {c n a : ℕ → ℕ} (hc : Primrec c) (hn : Primrec n) (ha : Primrec a) :
+    Arith (fun O v => a v = bit (B O (c v) (n v))) := by
+  have h := query_at hB hc hn
+  exact ((h.and (equal ha (Primrec.const 1))).or
+    (h.neg.and (equal ha (Primrec.const 0)))).congr (fun O v => by
+      cases B O (c v) (n v) <;> simp [bit])
+
+def table (c : ℕ) : List ℕ := (decode c).getD []
+def item (c k : ℕ) : ℕ := (table c).getD k 0
+
+theorem table_primrec : Primrec table :=
+  Primrec.option_getD.comp Primrec.decode (Primrec.const [])
+theorem item_primrec : Primrec₂ item :=
+  (Primrec.list_getD 0).comp (table_primrec.comp Primrec.fst) Primrec.snd
+
+def Prefix (B : Oracle) (m c : ℕ) : Prop :=
+  (table c).length = m ∧ ∀ k, k < m → item c k = bit (B k)
+
+theorem prefix_iff (B : Oracle) (m c : ℕ) :
+    Prefix B m c ↔ table c = oraclePrefix (fun k => bit (B k)) m := by
+  constructor
+  · rintro ⟨hlen,he⟩
+    apply List.ext_getElem
+    · simpa [oraclePrefix] using hlen
+    · intro k hk hk'
+      have hkm : k < m := by simpa [oraclePrefix] using hk'
+      have hh := he k hkm
+      simpa [item,List.getD_eq_getElem?_getD,List.getElem?_eq_getElem hk,
+        oraclePrefix] using hh
+  · intro he
+    constructor
+    · simp [he,oraclePrefix]
+    · intro k hk
+      simp [item,he,oraclePrefix,List.getD_eq_getElem?_getD,List.getElem?_range hk]
+
+theorem prefix_arith {B : OracleFamily} (hB : ArithmeticOracle B)
+    {c m l : ℕ → ℕ} (hc : Primrec c) (hm : Primrec m) (hl : Primrec l) :
+    Arith (fun O v => Prefix (B O (c v)) (m v) (l v)) := by
+  have hb := bit_equal hB (hc.comp left_primrec) right_primrec
+    (item_primrec.comp (hl.comp left_primrec) right_primrec)
+  have ht := ((less right_primrec (hm.comp left_primrec)).imp hb).all
+  exact ((equal (Primrec.list_length.comp (table_primrec.comp hl)) hm).and ht).congr
+    (fun _ _ => by simp only [Prefix,left,right,Nat.unpair_pair])
+
+def trialTest (e n m t a : ℕ) : Prop :=
+  (machine e).evaln t (Nat.pair (encode (table m)) n) = some a
+
+theorem trialTest_arith {e n m t a : ℕ → ℕ}
+    (he : Primrec e) (hn : Primrec n) (hm : Primrec m) (ht : Primrec t) (ha : Primrec a) :
+    Arith (fun _ v => trialTest (e v) (n v) (m v) (t v) (a v)) := by
+  apply Arith.pure
+  exact Primrec.eq.comp
+    (Nat.Partrec.Code.primrec_evaln.comp
+      ((ht.pair (machine_primrec.comp he)).pair
+        (Primrec₂.natPair.comp (Primrec.encode.comp (table_primrec.comp hm)) hn)))
+    (Primrec.option_some.comp ha)
+
+theorem run_arith {B : OracleFamily} (hB : ArithmeticOracle B)
+    {c e n z a : ℕ → ℕ} (hc : Primrec c) (he : Primrec e) (hn : Primrec n)
+    (hz : Primrec z) (ha : Primrec a) :
+    Arith (fun O v => TableIndices.run (B O (c v)) (machine (e v)) (n v) (z v) = some (a v)) := by
+  have hp := prefix_arith hB (hc.comp left_primrec)
+    ((left_primrec.comp hz).comp left_primrec) right_primrec
+  have ht := trialTest_arith (he.comp left_primrec) (hn.comp left_primrec)
+    right_primrec ((right_primrec.comp hz).comp left_primrec) (ha.comp left_primrec)
+  apply (hp.and ht).ex.congr
+  intro O v
+  simp only [left,right,Nat.unpair_pair]
+  constructor
+  · rintro ⟨l,hp,ht⟩
+    rw [prefix_iff] at hp
+    simpa [trialTest,TableIndices.run,trial,hp] using ht
+  · intro ht
+    let L := oraclePrefix (fun k => bit (B O (c v) k)) (Nat.unpair (z v)).1
+    refine ⟨encode L,?_,?_⟩
+    · rw [prefix_iff]
+      simp [table,L]
+    · simpa [trialTest,table,L,TableIndices.run,trial] using ht
+
+end TuringRigidity.UniformArithmetic
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticTestApproximation.lean

@@ -0,0 +1,155 @@
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticFiniteTest
+
+namespace OAI
+
+namespace TuringRigidity.ArithmeticTree
+open UniformArithmetic
+noncomputable section
+attribute [local instance] Classical.propDecidable
+
+abbrev Approx := ℕ → Option ℕ
+
+def Extends (s t : Approx) : Prop := ∀ i a, s i = some a → t i = some a
+
+def Captures (s : Approx) (f : ℕ → ℕ) (N : ℕ) : Prop := ∀ i < N, s i = some (f i)
+
+theorem Captures.mono {s f N K} (h : Captures s f N) (hK : K ≤ N) : Captures s f K :=
+  fun i hi => h i (lt_of_lt_of_le hi hK)
+
+namespace Term
+
+def approx (s : Approx) (v : ℕ) : Term → Option ℕ
+  | .input => some v
+  | .const n => some n
+  | .prim g _ t => (t.approx s v).bind (fun a => some (g a))
+  | .pair t u => (t.approx s v).bind (fun a => (u.approx s v).bind (fun b => some (Nat.pair a b)))
+  | .witness t => (t.approx s v).bind s
+
+theorem approx_mono (t : Term) {s u : Approx} (h : Extends s u) (v a : ℕ)
+    (ha : t.approx s v = some a) : t.approx u v = some a := by
+  induction t generalizing a with
+  | input => exact ha
+  | const n => exact ha
+  | prim g hg t ih =>
+    simp only [approx,Option.bind_eq_some_iff] at ha ⊢
+    obtain ⟨b,hb,he⟩ := ha
+    exact ⟨b,ih b hb,he⟩
+  | pair t w ih ik =>
+    simp only [approx,Option.bind_eq_some_iff] at ha ⊢
+    obtain ⟨b,hb,c,hc,he⟩ := ha
+    exact ⟨b,ih b hb,c,ik c hc,he⟩
+  | witness t ih =>
+    simp only [approx,Option.bind_eq_some_iff] at ha ⊢
+    obtain ⟨b,hb,he⟩ := ha
+    exact ⟨b,ih b hb,h b a he⟩
+
+@[simp] theorem approx_full (t : Term) (f : ℕ → ℕ) (v : ℕ) :
+    t.approx (fun i => some (f i)) v = some (t.eval f v) := by
+  induction t <;> simp_all [approx,eval]
+
+theorem approx_sound (t : Term) {s : Approx} {f : ℕ → ℕ}
+    (h : Extends s (fun i => some (f i))) (v a : ℕ) (ha : t.approx s v = some a) :
+    t.eval f v = a := by
+  simpa only [approx_full,Option.some.injEq] using t.approx_mono h v a ha
+
+theorem approx_complete (t : Term) (f : ℕ → ℕ) (v : ℕ) :
+    ∃ N, ∀ s : Approx, Captures s f N → t.approx s v = some (t.eval f v) := by
+  induction t with
+  | input => exact ⟨0,fun _ _ => rfl⟩
+  | const n => exact ⟨0,fun _ _ => rfl⟩
+  | prim g hg t ih =>
+    obtain ⟨N,hN⟩ := ih
+    exact ⟨N,fun s hs => by simp [approx,eval,hN s hs]⟩
+  | pair t u ih ik =>
+    obtain ⟨N,hN⟩ := ih
+    obtain ⟨K,hK⟩ := ik
+    exact ⟨max N K,fun s hs => by
+      simp [approx,eval,hN s (hs.mono (le_max_left _ _)),hK s (hs.mono (le_max_right _ _))]⟩
+  | witness t ih =>
+    obtain ⟨N,hN⟩ := ih
+    refine ⟨max N (t.eval f v + 1),fun s hs => ?_⟩
+    simp only [approx,hN s (hs.mono (le_max_left _ _)),Option.bind_some,eval]
+    exact hs _ (lt_of_lt_of_le (Nat.lt_succ_self _) (le_max_right _ _))
+end Term
+
+namespace Test
+
+def approx (O : Oracles) (s : Approx) (v : ℕ) : Test → Option Bool
+  | .pure P _ t => (t.approx s v).bind (fun a => some (decide (P a)))
+  | .query i t => (t.approx s v).bind (fun a => some (O i a))
+  | .neg t => (t.approx O s v).bind (fun a => some (!a))
+  | .and t u => (t.approx O s v).bind (fun a => (u.approx O s v).bind (fun b => some (a && b)))
+
+private theorem approx_mono (t : Test) (O : Oracles) {s u : Approx} (h : Extends s u)
+    (v : ℕ) (a : Bool) (ha : t.approx O s v = some a) : t.approx O u v = some a := by
+  induction t generalizing a with
+  | pure P hP t =>
+    simp only [approx,Option.bind_eq_some_iff] at ha ⊢
+    obtain ⟨b,hb,he⟩ := ha
+    exact ⟨b,t.approx_mono h v b hb,he⟩
+  | query i t =>
+    simp only [approx,Option.bind_eq_some_iff] at ha ⊢
+    obtain ⟨b,hb,he⟩ := ha
+    exact ⟨b,t.approx_mono h v b hb,he⟩
+  | neg t ih =>
+    simp only [approx,Option.bind_eq_some_iff] at ha ⊢
+    obtain ⟨b,hb,he⟩ := ha
+    exact ⟨b,ih b hb,he⟩
+  | and t w ih ik =>
+    simp only [approx,Option.bind_eq_some_iff] at ha ⊢
+    obtain ⟨b,hb,c,hc,he⟩ := ha
+    exact ⟨b,ih b hb,c,ik c hc,he⟩
+
+@[simp] theorem approx_full (t : Test) (O : Oracles) (f : ℕ → ℕ) (v : ℕ) :
+    t.approx O (fun i => some (f i)) v = some (decide (t.eval O f v)) := by
+  induction t with
+  | pure P hP t =>
+    by_cases h : P (t.eval f v) <;> simp [approx,eval,h]
+  | query i t => cases h : O i (t.eval f v) <;> simp [approx,eval,h]
+  | neg t ih => by_cases h : t.eval O f v <;> simp [approx,eval,ih,h]
+  | and t w ih ik =>
+    by_cases ht : t.eval O f v <;> by_cases hw : w.eval O f v <;> simp [approx,eval,ih,ik,ht,hw]
+
+theorem approx_sound (t : Test) (O : Oracles) {s : Approx} {f : ℕ → ℕ}
+    (h : Extends s (fun i => some (f i))) (v : ℕ) (a : Bool)
+    (ha : t.approx O s v = some a) : t.eval O f v ↔ a = true := by
+  have he : decide (t.eval O f v) = a := by
+    simpa only [approx_full,Option.some.injEq] using t.approx_mono O h v a ha
+  rw [← he]
+  simp
+
+theorem approx_complete (t : Test) (O : Oracles) (f : ℕ → ℕ) (v : ℕ) :
+    ∃ N, ∀ s : Approx, Captures s f N →
+      t.approx O s v = some (decide (t.eval O f v)) := by
+  induction t with
+  | pure P hP t =>
+    obtain ⟨N,hN⟩ := t.approx_complete f v
+    refine ⟨N,fun s hs => ?_⟩
+    rw [← approx_full]
+    simp only [approx,hN s hs,Term.approx_full]
+  | query i t =>
+    obtain ⟨N,hN⟩ := t.approx_complete f v
+    refine ⟨N,fun s hs => ?_⟩
+    rw [← approx_full]
+    simp only [approx,hN s hs,Term.approx_full]
+  | neg t ih =>
+    obtain ⟨N,hN⟩ := ih
+    refine ⟨N,fun s hs => ?_⟩
+    rw [← approx_full]
+    simp only [approx,hN s hs,approx_full]
+  | and t u ih ik =>
+    obtain ⟨N,hN⟩ := ih
+    obtain ⟨K,hK⟩ := ik
+    refine ⟨max N K,fun s hs => ?_⟩
+    rw [← approx_full]
+    simp only [approx,hN s (hs.mono (le_max_left _ _)),hK s (hs.mono (le_max_right _ _)),approx_full]
+
+theorem rejection_mono (t : Test) (O : Oracles) {s u : Approx} (h : Extends s u)
+    (v : ℕ) (ha : t.approx O s v = some false) : t.approx O u v = some false :=
+  t.approx_mono O h v false ha
+end Test
+
+end
+end TuringRigidity.ArithmeticTree
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticTreeDefinability.lean

@@ -0,0 +1,110 @@
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticWitnessTree
+import Mathlib.Computability.Primrec.List
+
+namespace OAI
+
+namespace TuringRigidity.ArithmeticTree
+open UniformArithmetic Encodable
+noncomputable section
+attribute [local instance] Classical.propDecidable
+
+theorem Term.approx_primrec (t : Term) :
+    Primrec (fun p : List ℕ × ℕ => t.approx (listApprox p.1) p.2) := by
+  induction t with
+  | input => exact Primrec.option_some.comp Primrec.snd
+  | const n => exact Primrec.const (some n)
+  | prim g hg t ih =>
+    exact Primrec.option_bind ih (Primrec.option_some.comp (hg.comp Primrec.snd))
+  | pair t u ih ik =>
+    exact Primrec.option_bind ih (Primrec.option_bind (ik.comp Primrec.fst)
+      (Primrec.option_some.comp (Primrec₂.natPair.comp (Primrec.snd.comp Primrec.fst) Primrec.snd)))
+  | witness t ih =>
+    exact Primrec.option_bind ih
+      (Primrec.list_getElem?.comp (Primrec.fst.comp Primrec.fst) Primrec.snd)
+
+private theorem option_neg_iff (a : Option Bool) (b : Bool) :
+    (a.bind (fun c => some (!c)) = some b) ↔ a = some (!b) := by
+  cases a with
+  | none => simp
+  | some a => cases a <;> cases b <;> decide
+
+private theorem option_and_true (a b : Option Bool) :
+    (a.bind (fun c => b.bind (fun d => some (c && d))) = some true) ↔
+      a = some true ∧ b = some true := by
+  cases a with
+  | none => simp
+  | some a => cases b with
+    | none => simp
+    | some b => cases a <;> cases b <;> decide
+
+private theorem option_and_false (a b : Option Bool) :
+    (a.bind (fun c => b.bind (fun d => some (c && d))) = some false) ↔
+      (a = some false ∧ b = some false) ∨
+      (a = some false ∧ b = some true) ∨ (a = some true ∧ b = some false) := by
+  cases a with
+  | none => simp
+  | some a => cases b with
+    | none => simp
+    | some b => cases a <;> cases b <;> decide
+
+theorem Test.approx_arith (t : Test) {s : ℕ → List ℕ} (hs : Primrec s)
+    {v : ℕ → ℕ} (hv : Primrec v) (b : Bool) :
+    Arith (fun O k => t.approx O (listApprox (s k)) (v k) = some b) := by
+  induction t generalizing s v b with
+  | pure P hP t =>
+    have hp : Primrec (fun k : ℕ => (t.approx (listApprox (s k)) (v k)).bind
+        (fun a => some (decide (P a)))) := Primrec.option_bind ((t.approx_primrec).comp (hs.pair hv))
+      (Primrec.option_some.comp (hP.decide.comp Primrec.snd))
+    exact .pure _ (Primrec.eq.comp hp (Primrec.const (some b)))
+  | query i t =>
+    have ht := (t.approx_primrec).comp ((hs.comp left_primrec).pair (hv.comp left_primrec))
+    have hh : Arith (fun _ k => t.approx (listApprox (s (left k))) (v (left k)) = some (right k)) :=
+      .pure _ (Primrec.eq.comp ht (Primrec.option_some.comp right_primrec))
+    have hq : Arith (fun O k => O i (right k) = b) := by
+      cases b with
+      | true => exact (Arith.query i).comp _ right_primrec
+      | false =>
+        exact ((Arith.query i).comp _ right_primrec).neg.congr
+          (fun O k => by cases O i (right k) <;> simp)
+    exact (hh.and hq).ex.congr (fun O k => by
+      simp only [left,right,Nat.unpair_pair,Test.approx,Option.bind_eq_some_iff,Option.some.injEq])
+  | neg t ih =>
+    exact (ih hs hv (!b)).congr (fun O k => (option_neg_iff _ b).symm)
+  | and t u ih ik =>
+    cases b with
+    | true =>
+      exact ((ih hs hv true).and (ik hs hv true)).congr
+        (fun O k => (option_and_true _ _).symm)
+    | false =>
+      exact (((ih hs hv false).and (ik hs hv false)).or
+        (((ih hs hv false).and (ik hs hv true)).or ((ih hs hv true).and (ik hs hv false)))).congr
+        (fun O k => (option_and_false _ _).symm)
+
+theorem Test.accepts_arith (t : Test) {s : ℕ → List ℕ} (hs : Primrec s)
+    {v : ℕ → ℕ} (hv : Primrec v) : Arith (fun O k => t.accepts O (v k) (s k)) := by
+  have hlen : Arith (fun _ k => right k < (s (left k)).length) :=
+    .pure _ (Primrec.nat_lt.comp right_primrec (Primrec.list_length.comp (hs.comp left_primrec)))
+  have ht := t.approx_arith (hs.comp left_primrec)
+    (Primrec₂.natPair.comp (hv.comp left_primrec) right_primrec) false
+  exact (hlen.imp ht.neg).all.congr (fun O k => by
+    simp only [Test.accepts,left,right,Nat.unpair_pair])
+
+def decodeNode (n : ℕ) : List ℕ := (decode (α := List ℕ) n).getD []
+
+theorem decodeNode_primrec : Primrec decodeNode :=
+  Primrec.option_getD.comp Primrec.decode (Primrec.const [])
+
+@[simp] theorem decodeNode_encode (s : List ℕ) : decodeNode (encode s) = s := by
+  simp [decodeNode]
+
+def Test.nodeCode (t : Test) (O : Oracles) (v : ℕ) : Oracle :=
+  fun n => decide (t.accepts O v (decodeNode n))
+
+theorem Test.nodeCode_arith (t : Test) (v : ℕ) :
+    Arith (fun O n => t.nodeCode O v n = true) :=
+  (t.accepts_arith decodeNode_primrec (Primrec.const v)).congr (fun _ _ => by simp [Test.nodeCode])
+
+end
+end TuringRigidity.ArithmeticTree
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticTreeDescent.lean

@@ -0,0 +1,85 @@
+import OAI.Computability.DegreeRigidity.SetModels.SetModelTreeRelations
+import OAI.Computability.DegreeRigidity.Constructibility.PersistenceWitnessTree
+
+namespace OAI
+
+namespace TuringRigidity.ArithmeticTree
+open UniformArithmetic SetModelReals SetModelSyntax SetModelFunctions
+universe u
+noncomputable section
+attribute [local instance] Classical.propDecidable
+
+def unionRead (c : ℕ → ℕ) (i : ℕ) : ℕ := (decodeNode (c (i+1)))[i]?.getD 0
+
+private theorem length_chain (c : ℕ → ℕ)
+    (hs : ∀ n, ∃ a, decodeNode (c (n+1)) = decodeNode (c n) ++ [a]) (n : ℕ) :
+    n ≤ (decodeNode (c n)).length := by
+  induction n with
+  | zero => omega
+  | succ n ih =>
+    obtain ⟨a,ha⟩ := hs n
+    simp only [ha,List.length_append,List.length_singleton]
+    omega
+
+private theorem extends_chain (c : ℕ → ℕ)
+    (hs : ∀ n, ∃ a, decodeNode (c (n+1)) = decodeNode (c n) ++ [a])
+    {i j : ℕ} (hij : i ≤ j) : Extends (listApprox (decodeNode (c i))) (listApprox (decodeNode (c j))) := by
+  induction j, hij using Nat.le_induction with
+  | base => exact fun _ _ h => h
+  | succ j hj ih =>
+    obtain ⟨a,ha⟩ := hs j
+    intro k b hb
+    rw [ha]
+    exact listApprox_append _ _ k b (ih k b hb)
+
+theorem unionRead_captures (c : ℕ → ℕ)
+    (hs : ∀ n, ∃ a, decodeNode (c (n+1)) = decodeNode (c n) ++ [a]) (n : ℕ) :
+    Captures (listApprox (decodeNode (c n))) (unionRead c) n := by
+  intro i hi
+  have hil : i < (decodeNode (c (i+1))).length :=
+    lt_of_lt_of_le (Nat.lt_succ_self _) (length_chain c hs _)
+  have he : (decodeNode (c (i+1)))[i]? = some ((decodeNode (c (i+1)))[i]) :=
+    List.getElem?_eq_some_iff.mpr ⟨hil,rfl⟩
+  have hv : unionRead c i = (decodeNode (c (i+1)))[i] := by simp [unionRead,he]
+  rw [hv]
+  exact extends_chain c hs (Nat.succ_le_of_lt hi) i _ he
+
+theorem Test.eval_of_descent (t : Test) (O : Oracles) (v : ℕ) (c : ℕ → ℕ)
+    (hc : ∀ n, t.edgePredicate O v (c (n+1)) (c n)) :
+    ∀ n, t.eval O (unionRead c) (Nat.pair v n) := by
+  have hs : ∀ n, ∃ a, decodeNode (c (n+1)) = decodeNode (c n) ++ [a] := fun n => (hc n).2.2
+  intro n
+  obtain ⟨N,hN⟩ := t.approx_complete O (unionRead c) (Nat.pair v n)
+  let K := max N (n+1)
+  have he := hN (listApprox (decodeNode (c K))) ((unionRead_captures c hs K).mono (le_max_left _ _))
+  have hnK : n < (decodeNode (c K)).length :=
+    lt_of_lt_of_le (lt_of_lt_of_le (Nat.lt_succ_self _) (le_max_right _ _)) (length_chain c hs K)
+  have hh := (hc K).2.1.2 n hnK
+  by_contra hp
+  exact hh (he.trans (by simp [hp]))
+
+private theorem read_primrec : Primrec (fun p : ℕ × ℕ => (decodeNode p.1)[p.2]?.getD 0) :=
+  Primrec.option_getD.comp (Primrec.list_getElem?.comp (decodeNode_primrec.comp Primrec.fst) Primrec.snd)
+    (Primrec.const 0)
+
+theorem union_real_mem {M : ZFSet.{u}} (C : Context M) (G : Oracle) (hG : G ∈ reals M)
+    (c : ℕ → ℕ) (hc : ∀ n k, G (Nat.pair n k) = true ↔ k = c n) :
+    Test.realPart (unionRead c) ∈ reals M := by
+  let idx : ℕ → ℕ := fun n => Nat.pair 0 n
+  have hi : Primrec idx := Primrec₂.natPair.comp (Primrec.const 0) Primrec.id
+  have hq := (Arith.query 0).comp
+    (fun n => Nat.pair (idx (left n)+1) (right n))
+    (Primrec₂.natPair.comp (Primrec.succ.comp (hi.comp left_primrec)) right_primrec)
+  have hr : Arith (fun _ n => (decodeNode (right n))[idx (left n)]?.getD 0 = 1) :=
+    .pure _ (Primrec.eq.comp (read_primrec.comp (right_primrec.pair (hi.comp left_primrec))) (Primrec.const 1))
+  apply arithmetic_comprehension C (hq.and hr).ex (fun _ => G) (fun _ => hG) _
+  intro n
+  simp only [left,right,Nat.unpair_pair]
+  change (∃ k, G (Nat.pair (idx n + 1) k) = true ∧ (decodeNode k)[idx n]?.getD 0 = 1) ↔ _
+  simp only [hc,exists_eq_left,Test.realPart,unionRead,idx]
+  exact ⟨decide_eq_true,of_decide_eq_true⟩
+
+end
+end TuringRigidity.ArithmeticTree
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticTreeSequence.lean

@@ -0,0 +1,87 @@
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticTreeDefinability
+
+namespace OAI
+
+
+namespace TuringRigidity.ArithmeticTree
+open UniformArithmetic Encodable
+noncomputable section
+
+def Test.codeChild (t : Test) (O : Oracles) (v x y : ℕ) : Prop :=
+  t.accepts O v (decodeNode x) ∧ t.accepts O v (decodeNode y) ∧
+    ∃ a, decodeNode x = decodeNode y ++ [a]
+
+theorem Test.codeChild_arith (t : Test) (v : ℕ) :
+    Arith (fun O k => t.codeChild O v (left k) (right k)) := by
+  have hx := t.accepts_arith (decodeNode_primrec.comp left_primrec) (Primrec.const v)
+  have hy := t.accepts_arith (decodeNode_primrec.comp right_primrec) (Primrec.const v)
+  have he : Arith (fun _ k => decodeNode (left (left k)) = decodeNode (right (left k)) ++ [right k]) :=
+    .pure _ (Primrec.eq.comp (decodeNode_primrec.comp (left_primrec.comp left_primrec))
+      (Primrec.list_append.comp (decodeNode_primrec.comp (right_primrec.comp left_primrec))
+        (Primrec.list_cons.comp right_primrec (Primrec.const []))))
+  exact (hx.and (hy.and he.ex)).congr (fun _ _ => by
+    simp only [Test.codeChild,left,right,Nat.unpair_pair])
+
+def chainValue (s : ℕ → ℕ) (i : ℕ) : ℕ := ((decodeNode (s (i+1)))[i]?).getD 0
+
+theorem code_chain_extends (s : ℕ → ℕ)
+    (h : ∀ n, ∃ a, decodeNode (s (n+1)) = decodeNode (s n) ++ [a])
+    {i j : ℕ} (hij : i ≤ j) :
+    Extends (listApprox (decodeNode (s i))) (listApprox (decodeNode (s j))) := by
+  induction j, hij using Nat.le_induction with
+  | base => exact fun _ _ h => h
+  | succ j hj ih =>
+    obtain ⟨a,ha⟩ := h j
+    intro k b hb
+    rw [ha]
+    exact listApprox_append _ _ k b (ih k b hb)
+
+theorem code_chain_length (s : ℕ → ℕ)
+    (h : ∀ n, ∃ a, decodeNode (s (n+1)) = decodeNode (s n) ++ [a]) (n : ℕ) :
+    n ≤ (decodeNode (s n)).length := by
+  induction n with
+  | zero => omega
+  | succ n ih =>
+    obtain ⟨a,ha⟩ := h n
+    simp only [ha,List.length_append,List.length_singleton]
+    omega
+
+theorem code_chain_captures (s : ℕ → ℕ)
+    (h : ∀ n, ∃ a, decodeNode (s (n+1)) = decodeNode (s n) ++ [a]) (n : ℕ) :
+    Captures (listApprox (decodeNode (s n))) (chainValue s) n := by
+  intro i hi
+  have hil : i < (decodeNode (s (i+1))).length :=
+    lt_of_lt_of_le (Nat.lt_succ_self _) (code_chain_length s h _)
+  have he : (decodeNode (s (i+1)))[i]? = some (chainValue s i) := by
+    simp only [chainValue,List.getElem?_eq_getElem hil,Option.getD_some]
+  exact code_chain_extends s h (Nat.succ_le_of_lt hi) i _ he
+
+theorem Test.code_chain_eval (t : Test) (O : Oracles) (v : ℕ) (s : ℕ → ℕ)
+    (h : ∀ n, t.codeChild O v (s (n+1)) (s n)) :
+    ∀ n, t.eval O (chainValue s) (Nat.pair v n) := by
+  intro n
+  have hstep := fun k => (h k).2.2
+  obtain ⟨N,hN⟩ := t.approx_complete O (chainValue s) (Nat.pair v n)
+  let K := max N (n+1)
+  have he := hN (listApprox (decodeNode (s K)))
+    ((code_chain_captures s hstep K).mono (le_max_left _ _))
+  have hn : n < (decodeNode (s K)).length :=
+    lt_of_lt_of_le (lt_of_lt_of_le (Nat.lt_succ_self _) (le_max_right _ _))
+      (code_chain_length s hstep K)
+  have hh := (h K).2.1 n hn
+  by_contra hp
+  exact hh (he.trans (by simp [hp]))
+
+theorem Test.code_chain_exists (t : Test) (O : Oracles) (v : ℕ)
+    (h : ∃ f : ℕ → ℕ, ∀ n, t.eval O f (Nat.pair v n)) :
+    ∃ s : ℕ → ℕ, ∀ n, t.codeChild O v (s (n+1)) (s n) := by
+  obtain ⟨f,hf⟩ := h
+  refine ⟨fun n => encode (initialSegment f n),fun n => ?_⟩
+  simp only [Test.codeChild,decodeNode_encode]
+  exact ⟨(t.branch_iff O v f).mpr hf (n+1),(t.branch_iff O v f).mpr hf n,
+    f n,prefix_succ f n⟩
+
+end
+end TuringRigidity.ArithmeticTree
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticTruthRequirements.lean

@@ -0,0 +1,133 @@
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticPrefixFamilies
+
+namespace OAI
+
+
+namespace TuringRigidity.ArithmeticTruthRequirements
+open UniformArithmetic ArithmeticPrefixForcing ArithmeticPrefixFamilies
+open ArithmeticGenericTruth FiniteShuffle ShuffleRequirements
+open EncodedForcing (word word_primrec)
+
+theorem arithmetic_truth_requirements {P : Predicate} (hP : Arith P) :
+    ∃ Q D : PrefixPredicate, ArithmeticPrefix Q ∧ ArithmeticPrefix D ∧
+      (∀ O v, Upward (Q O v)) ∧
+      (∀ O v n, DenseOpen (D O (Nat.pair v n))) ∧
+      ∀ O v G, GenericFor (fun n => D O (Nat.pair v n)) G →
+        (P (Function.update O 0 G) v ↔ G ∈ OpenSet (Q O v)) := by
+  have htrue : ArithmeticPrefix (fun _ _ _ => True) :=
+    (equal (Primrec.const 0) (Primrec.const 0)).congr (fun _ _ => by simp)
+  induction hP with
+  | pure P hP =>
+    refine ⟨fun _ v _ => P v, fun _ _ _ => True, .pure _ (hP.comp left_primrec), htrue,
+      fun _ _ _ _ _ h => h, fun _ _ _ => dense_true, ?_⟩
+    intro O v G _
+    exact (open_constant _ _).symm
+  | query i =>
+    by_cases hi : i = 0
+    · subst i
+      let Q : PrefixPredicate := fun _ v s => v < s.length ∧ s.getD v false = true
+      have hQ : ArithmeticPrefix Q :=
+        (less left_primrec (Primrec.list_length.comp (word_primrec.comp right_primrec))).and
+          (.pure _ (Primrec.eq.comp ((Primrec.list_getD false).comp
+            (word_primrec.comp right_primrec) left_primrec) (Primrec.const true)))
+      refine ⟨Q,fun _ _ _ => True,hQ,htrue,?_,fun _ _ _ => dense_true,?_⟩
+      · intro O v s t hst hs
+        exact ⟨lt_of_lt_of_le hs.1 hst.length_le,
+          (getD_of_prefix hst v hs.1).symm.trans hs.2⟩
+      · intro O v G _
+        simp only [Function.update_self]
+        constructor
+        · intro hv
+          refine ⟨initial G (v+1),⟨?_,?_⟩,
+            (realizes_initial _ _ _).mpr (fun _ _ => rfl)⟩
+          · simp
+          · exact (prefix_getD G _ v (by omega)).trans hv
+        · rintro ⟨s,hs,hGs⟩
+          exact (hGs v hs.1).symm.trans hs.2
+    · refine ⟨fun O v _ => O i v = true, fun _ _ _ => True, (Arith.query i).comp _ left_primrec, htrue,
+        fun _ _ _ _ _ h => h, fun _ _ _ => dense_true, ?_⟩
+      intro O v G _
+      simpa only [Function.update_of_ne hi] using (open_constant (O i v = true) G).symm
+  | neg h ih =>
+    obtain ⟨Q,D,hQ,hD,hup,hden,ht⟩ := ih
+    let E : PrefixPredicate := fun O v s => D O v s ∧ Decides (Q O (left v)) s
+    have hE : ArithmeticPrefix E := hD.and (prefix_comp (decides_arith hQ) left_primrec)
+    refine ⟨fun O v => Avoid (Q O v),E,avoids_arith hQ,hE,
+      fun O v => avoids_upward _,?_,?_⟩
+    · intro O v n
+      simpa only [E,left,Nat.unpair_pair] using
+        dense_and (hden O v n) (decides_dense (Q O v) (hup O v))
+    · intro O v G hG
+      have hGD : GenericFor (fun n => D O (Nat.pair v n)) G := by
+        intro n
+        obtain ⟨s,hs,hGs⟩ := hG n
+        exact ⟨s,hs.1,hGs⟩
+      have hdec : G ∈ OpenSet (Decides (Q O v)) := by
+        obtain ⟨s,hs,hGs⟩ := hG 0
+        exact ⟨s,by simpa only [left,Nat.unpair_pair] using hs.2,hGs⟩
+      exact (not_congr (ht O v G hGD)).trans
+        (avoid_truth_of_decides (Q O v) (hup O v) G hdec).symm
+  | and h k ih ik =>
+    obtain ⟨Q,D,hQ,hD,hQu,hDd,hQt⟩ := ih
+    obtain ⟨R,E,hR,hE,hRu,hEd,hRt⟩ := ik
+    let F : PrefixPredicate := fun O v s =>
+      D O (Nat.pair (left v) (left (right v))) s ∧
+      E O (Nat.pair (left v) (right (right v))) s
+    have hF : ArithmeticPrefix F :=
+      (prefix_comp hD (Primrec₂.natPair.comp left_primrec (left_primrec.comp right_primrec))).and
+      (prefix_comp hE (Primrec₂.natPair.comp left_primrec (right_primrec.comp right_primrec)))
+    refine ⟨fun O v s => Q O v s ∧ R O v s,F,hQ.and hR,hF,
+      fun O v s t hst hs => ⟨hQu O v s t hst hs.1,hRu O v s t hst hs.2⟩,?_,?_⟩
+    · intro O v n
+      simpa only [F,left,right,Nat.unpair_pair] using
+        dense_and (hDd O v (left n)) (hEd O v (right n))
+    · intro O v G hG
+      have hGD : GenericFor (fun n => D O (Nat.pair v n)) G := by
+        intro n
+        obtain ⟨s,hs,hGs⟩ := hG (Nat.pair n 0)
+        exact ⟨s,by simpa only [left,right,Nat.unpair_pair] using hs.1,hGs⟩
+      have hGE : GenericFor (fun n => E O (Nat.pair v n)) G := by
+        intro n
+        obtain ⟨s,hs,hGs⟩ := hG (Nat.pair 0 n)
+        exact ⟨s,by simpa only [left,right,Nat.unpair_pair] using hs.2,hGs⟩
+      exact (and_congr (hQt O v G hGD) (hRt O v G hGE)).trans
+        (open_and (Q O v) (R O v) (hQu O v) (hRu O v) G).symm
+  | ex h ih =>
+    obtain ⟨Q,D,hQ,hD,hup,hden,ht⟩ := ih
+    let E : PrefixPredicate := fun O v =>
+      D O (Nat.pair (Nat.pair (left v) (left (right v))) (right (right v)))
+    have hE : ArithmeticPrefix E := prefix_comp hD
+      (Primrec₂.natPair.comp
+        (Primrec₂.natPair.comp left_primrec (left_primrec.comp right_primrec))
+        (right_primrec.comp right_primrec))
+    refine ⟨fun O v s => ∃ n, Q O (Nat.pair v n) s,E,prefix_exists hQ,hE,?_,?_,?_⟩
+    · rintro O v s t hst ⟨n,hn⟩
+      exact ⟨n,hup O _ s t hst hn⟩
+    · intro O v n
+      simpa only [E,left,right,Nat.unpair_pair] using
+        hden O (Nat.pair v (left n)) (right n)
+    · intro O v G hG
+      have hGD (n : ℕ) : GenericFor (fun k => D O (Nat.pair (Nat.pair v n) k)) G := by
+        intro k
+        simpa only [E,left,right,Nat.unpair_pair] using hG (Nat.pair n k)
+      constructor
+      · rintro ⟨n,hn⟩
+        obtain ⟨s,hs,hGs⟩ := (ht O _ G (hGD n)).mp hn
+        exact ⟨s,⟨n,hs⟩,hGs⟩
+      · rintro ⟨s,⟨n,hs⟩,hGs⟩
+        exact ⟨n,(ht O _ G (hGD n)).mpr ⟨s,hs,hGs⟩⟩
+  | comp f h hf ih =>
+    obtain ⟨Q,D,hQ,hD,hup,hden,ht⟩ := ih
+    let E : PrefixPredicate := fun O v => D O (Nat.pair (f (left v)) (right v))
+    refine ⟨fun O v => Q O (f v),E,prefix_comp hQ hf,
+      prefix_comp hD (Primrec₂.natPair.comp (hf.comp left_primrec) right_primrec),
+      fun O v => hup O (f v),?_,?_⟩
+    · intro O v n
+      simpa only [E,left,right,Nat.unpair_pair] using hden O (f v) n
+    · intro O v G hG
+      apply ht O (f v) G
+      simpa only [E,left,right,Nat.unpair_pair] using hG
+
+end TuringRigidity.ArithmeticTruthRequirements
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ArithmeticWitnessTree.lean

@@ -0,0 +1,127 @@
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticTestApproximation
+import Mathlib.SetTheory.Descriptive.Tree
+import Mathlib.Order.WellFounded
+
+namespace OAI
+
+namespace TuringRigidity.ArithmeticTree
+open UniformArithmetic
+noncomputable section
+attribute [local instance] Classical.propDecidable
+
+abbrev listApprox (s : List ℕ) : Approx := fun i => s[i]?
+
+theorem listApprox_append (s t : List ℕ) : Extends (listApprox s) (listApprox (s ++ t)) := by
+  intro i a ha
+  obtain ⟨hi,_⟩ := List.getElem?_eq_some_iff.mp ha
+  simpa only [listApprox,List.getElem?_append_left hi] using ha
+
+def initialSegment (f : ℕ → ℕ) (n : ℕ) : List ℕ := List.ofFn (fun i : Fin n => f i.val)
+
+@[simp] theorem prefix_length (f : ℕ → ℕ) (n : ℕ) : (initialSegment f n).length = n := by
+  simp [initialSegment]
+
+theorem prefix_succ (f : ℕ → ℕ) (n : ℕ) : initialSegment f (n+1) = initialSegment f n ++ [f n] := by
+  unfold initialSegment
+  rw [List.ofFn_succ_last]
+  rfl
+
+theorem prefix_captures (f : ℕ → ℕ) (n : ℕ) : Captures (listApprox (initialSegment f n)) f n := by
+  intro i hi
+  simp [listApprox,initialSegment,hi]
+
+theorem prefix_extends (f : ℕ → ℕ) (n : ℕ) :
+    Extends (listApprox (initialSegment f n)) (fun i => some (f i)) := by
+  intro i a ha
+  obtain ⟨hi,he⟩ := List.getElem?_eq_some_iff.mp ha
+  simp only [prefix_length] at hi
+  have hb := prefix_captures f n i hi
+  exact hb.symm.trans ha
+
+namespace Test
+
+def accepts (t : Test) (O : Oracles) (v : ℕ) (s : List ℕ) : Prop :=
+  ∀ n < s.length, t.approx O (listApprox s) (Nat.pair v n) ≠ some false
+
+def tree (t : Test) (O : Oracles) (v : ℕ) : Descriptive.tree ℕ :=
+  ⟨{s | t.accepts O v s},by
+    intro s a h n hn he
+    exact h n (by simp; omega) (t.rejection_mono O (listApprox_append s [a]) _ he)⟩
+
+theorem branch_iff (t : Test) (O : Oracles) (v : ℕ) (f : ℕ → ℕ) :
+    (∀ N, initialSegment f N ∈ t.tree O v) ↔ ∀ n, t.eval O f (Nat.pair v n) := by
+  constructor
+  · intro h n
+    obtain ⟨N,hN⟩ := t.approx_complete O f (Nat.pair v n)
+    let K := max N (n+1)
+    have he := hN (listApprox (initialSegment f K)) ((prefix_captures f K).mono (le_max_left _ _))
+    have hn : n < (initialSegment f K).length := by simp [K]
+    have hh := h K n hn
+    by_contra hp
+    exact hh (he.trans (by simp [hp]))
+  · intro h N n hn he
+    have ha := (t.approx_sound O (prefix_extends f N) _ false he).mp (h n)
+    exact Bool.false_ne_true ha
+
+def Child (t : Test) (O : Oracles) (v : ℕ) (s r : t.tree O v) : Prop :=
+  ∃ a, s.val = r.val ++ [a]
+
+private theorem chain_extends (s : ℕ → List ℕ)
+    (h : ∀ n, ∃ a, s (n+1) = s n ++ [a]) {i j : ℕ} (hij : i ≤ j) :
+    Extends (listApprox (s i)) (listApprox (s j)) := by
+  induction j, hij using Nat.le_induction with
+  | base => exact fun _ _ h => h
+  | succ j hj ih =>
+    obtain ⟨a,ha⟩ := h j
+    intro k b hb
+    rw [ha]
+    exact listApprox_append _ _ k b (ih k b hb)
+
+private theorem chain_length (s : ℕ → List ℕ)
+    (h : ∀ n, ∃ a, s (n+1) = s n ++ [a]) (n : ℕ) : n ≤ (s n).length := by
+  induction n with
+  | zero => omega
+  | succ n ih =>
+    obtain ⟨a,ha⟩ := h n
+    simp only [ha,List.length_append,List.length_singleton]
+    omega
+
+private theorem chain_union (s : ℕ → List ℕ)
+    (h : ∀ n, ∃ a, s (n+1) = s n ++ [a]) :
+    ∃ f : ℕ → ℕ, ∀ n, Captures (listApprox (s n)) f n := by
+  have hex : ∀ i, ∃ a, (s (i+1))[i]? = some a := by
+    intro i
+    have hi : i < (s (i+1)).length := lt_of_lt_of_le (Nat.lt_succ_self _) (chain_length s h _)
+    exact ⟨(s (i+1))[i],List.getElem?_eq_some_iff.mpr ⟨hi,rfl⟩⟩
+  choose f hf using hex
+  refine ⟨f,fun n i hi => ?_⟩
+  exact chain_extends s h (Nat.succ_le_of_lt hi) i (f i) (hf i)
+
+theorem wellFounded_iff (t : Test) (O : Oracles) (v : ℕ) :
+    WellFounded (t.Child O v) ↔ ¬ ∃ f : ℕ → ℕ, ∀ n, t.eval O f (Nat.pair v n) := by
+  rw [wellFounded_iff_isEmpty_descending_chain]
+  constructor
+  · intro hw ⟨f,hf⟩
+    let nodes : ℕ → t.tree O v := fun n => ⟨initialSegment f n,(t.branch_iff O v f).mpr hf n⟩
+    exact hw.false ⟨nodes,fun n => ⟨f n,prefix_succ f n⟩⟩
+  · intro h
+    refine ⟨fun ⟨nodes,hn⟩ => ?_⟩
+    let s : ℕ → List ℕ := fun n => (nodes n).val
+    have hs : ∀ n, ∃ a, s (n+1) = s n ++ [a] := hn
+    obtain ⟨f,hf⟩ := chain_union s hs
+    apply h
+    refine ⟨f,fun n => ?_⟩
+    obtain ⟨N,hN⟩ := t.approx_complete O f (Nat.pair v n)
+    let K := max N (n+1)
+    have he := hN (listApprox (s K)) ((hf K).mono (le_max_left _ _))
+    have hnK : n < (s K).length :=
+      lt_of_lt_of_le (lt_of_lt_of_le (Nat.lt_succ_self _) (le_max_right _ _)) (chain_length s hs K)
+    have hh := (nodes K).property n hnK
+    by_contra hp
+    exact hh (he.trans (by simp [hp]))
+end Test
+
+end
+end TuringRigidity.ArithmeticTree
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/BinaryCut.lean

@@ -0,0 +1,99 @@
+import OAI.Computability.DegreeRigidity.Computability.BinaryMachine
+
+namespace OAI
+
+namespace TuringRigidity.BinarySeries
+open UniformOracle RationalCoding Encodable Filter
+
+def approxDecision (z : ℕ × ℕ × ℕ) : Option ℕ :=
+  if fracLeft (z.1,z.2.2,2^z.2.1) < fracRight (z.1,z.2.2,2^z.2.1) then some 1
+  else if fracRight (z.1,z.2.2+1,2^z.2.1) < fracLeft (z.1,z.2.2+1,2^z.2.1) then some 0
+  else none
+
+theorem approxDecision_primrec : Primrec approxDecision := by
+  have hD : Primrec (fun z : ℕ × ℕ × ℕ => 2^z.2.1) := powTwo_primrec.comp (Primrec.fst.comp Primrec.snd)
+  have hlo := Primrec.fst.pair ((Primrec.snd.comp Primrec.snd).pair hD)
+  have hhi := Primrec.fst.pair ((Primrec.succ.comp (Primrec.snd.comp Primrec.snd)).pair hD)
+  exact Primrec.ite (Primrec.nat_lt.comp (fracLeft_primrec.comp hlo) (fracRight_primrec.comp hlo))
+    (Primrec.const (some 1))
+    (Primrec.ite (Primrec.nat_lt.comp (fracRight_primrec.comp hhi) (fracLeft_primrec.comp hhi))
+      (Primrec.const (some 0)) (Primrec.const none))
+
+def approxTrial (B : Oracle) (q n : ℕ) : Option ℕ := approxDecision (q,n,numeral B n)
+
+theorem approxTrial_recursive (B : Oracle) :
+    Nat.RecursiveIn {oracleFunction B}
+      (fun z => Part.some (encode (approxTrial B (Nat.unpair z).1 (Nat.unpair z).2))) := by
+  have hq := total_primrec (O := {oracleFunction B}) (Primrec.fst.comp Primrec.unpair)
+  have hn := total_primrec (O := {oracleFunction B}) (Primrec.snd.comp Primrec.unpair)
+  have hk := total_comp (numeral_recursive B) hn
+  have hdec := Primrec.encode.comp (approxDecision_primrec.comp
+    ((Primrec.fst.comp Primrec.unpair).pair (Primrec.unpair.comp (Primrec.snd.comp Primrec.unpair))))
+  exact (total_comp (total_primrec hdec) (total_pair hq (total_pair hn hk))).of_eq
+    (fun z => by simp [approxTrial])
+
+theorem approxTrial_sound (B : Oracle) (q n a : ℕ) (ha : a ∈ approxTrial B q n) :
+    a = if cut (value B) q then 1 else 0 := by
+  have hb := bracket B n
+  unfold approxTrial approxDecision at ha
+  split at ha
+  · rename_i h
+    have hq := (frac_lt_iff q (numeral B n) (2^n) (by positivity)).mp h
+    have hc : cut (value B) q = true := (cut_eq_true _ _).mpr (lt_of_lt_of_le (by simpa using hq) hb.1)
+    simpa [hc] using (Option.mem_def.mp ha).symm
+  · split at ha
+    · rename_i h
+      have hq := (lt_frac_iff q (numeral B n+1) (2^n) (by positivity)).mp h
+      have hc : cut (value B) q = false := Bool.eq_false_iff.mpr (fun hc => by
+        have hh := (cut_eq_true _ _).mp hc
+        push_cast at hq
+        linarith)
+      simpa [hc] using (Option.mem_def.mp ha).symm
+    · simp at ha
+
+theorem small_width (ε : ℝ) (hε : 0 < ε) : ∃ n : ℕ, (2^n : ℝ)⁻¹ < ε := by
+  have ht : Tendsto (fun n : ℕ => (2^n : ℝ)⁻¹) atTop (nhds 0) := by
+    simpa only [inv_pow] using
+      (tendsto_pow_atTop_nhds_zero_of_abs_lt_one (by norm_num : |(2:ℝ)⁻¹| < 1))
+  exact (ht.eventually (eventually_lt_nhds hε)).exists
+
+theorem approxTrial_complete (B : Oracle) (hi : Irrational (value B)) (q : ℕ) :
+    ∃ n a, a ∈ approxTrial B q n := by
+  have hne : (rationalEnumeration q : ℝ) ≠ value B := fun h => hi ⟨_,h⟩
+  rcases lt_or_gt_of_ne hne with hq | hq
+  · obtain ⟨n,hn⟩ := small_width (value B - rationalEnumeration q) (by linarith)
+    have hb := bracket B n
+    have hl : (rationalEnumeration q : ℝ) < (numeral B n : ℝ)/(2^n : ℕ) := by
+      push_cast
+      rw [add_div] at hb
+      simp only [one_div] at hb
+      linarith
+    have hd := (frac_lt_iff q (numeral B n) (2^n) (by positivity)).mpr hl
+    exact ⟨n,1,by simp [approxTrial,approxDecision,hd]⟩
+  · obtain ⟨n,hn⟩ := small_width (rationalEnumeration q - value B) (by linarith)
+    have hb := bracket B n
+    have hu : ((numeral B n+1 : ℕ) : ℝ)/(2^n : ℕ) < rationalEnumeration q := by
+      push_cast
+      rw [add_div]
+      simp only [one_div]
+      linarith
+    have hd := (lt_frac_iff q (numeral B n+1) (2^n) (by positivity)).mpr hu
+    have hl : ¬ fracLeft (q,numeral B n,2^n) < fracRight (q,numeral B n,2^n) := by
+      intro hh
+      have hh' := (frac_lt_iff q (numeral B n) (2^n) (by positivity)).mp hh
+      push_cast at hh'
+      linarith [hb.1]
+    exact ⟨n,0,by simp [approxTrial,approxDecision,hl,hd]⟩
+
+theorem cut_reduces (B : Oracle) (hi : Irrational (value B)) : Reduces (cut (value B)) B := by
+  apply RecursiveIn.iff_nat.mpr
+  exact total_search (approxTrial_recursive B) _ (approxTrial_sound B) (approxTrial_complete B hi)
+
+theorem cut_single_program (B : Oracle) (hi : Irrational (value B)) :
+    ∃ p : OracleCode, ∀ q, OracleCode.eval (oracleFunction B) p q = oracleFunction (cut (value B)) q := by
+  obtain ⟨p,hp⟩ := (OracleCode.turingReducible_iff_exists_code _ _).mp (cut_reduces B hi)
+  exact ⟨p,fun q => congrFun hp q⟩
+
+end TuringRigidity.BinarySeries
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/BinaryMachine.lean

@@ -0,0 +1,110 @@
+import OAI.Computability.DegreeRigidity.Computability.BinarySeries
+import OAI.Computability.DegreeRigidity.Computability.RationalCut
+
+namespace OAI
+
+namespace TuringRigidity.BinarySeries
+open UniformOracle RationalCoding Encodable
+
+theorem eventually_constant_reduces (B A : Oracle) (b : Bool) (N : ℕ)
+    (h : ∀ n, N ≤ n → B n = b) : Reduces B A := by
+  let L := (List.range N).map (bit B)
+  let d : ℕ := if b then 1 else 0
+  have hp : Primrec (fun n => L.getD n d) := (Primrec.list_getD d).comp (Primrec.const L) Primrec.id
+  have he (n : ℕ) : L.getD n d = bit B n := by
+    by_cases hn : n < N
+    · simp [L, List.getD, List.getElem?_map, List.getElem?_range hn]
+    · have hb := h n (by omega)
+      have hz : (List.range N)[n]? = none := List.getElem?_eq_none (by simp; omega)
+      simp [L, List.getD, hz, bit, hb, d]
+  apply RecursiveIn.iff_nat.mpr
+  exact total_primrec (hp.of_eq he)
+
+theorem mixed_of_noncomputable (B : Oracle) (h : ¬ Reduces B (fun _ => false)) : Mixed B := by
+  intro N
+  constructor
+  · by_contra hn
+    push Not at hn
+    apply h
+    exact eventually_constant_reduces B _ false N (fun n hN => Bool.eq_false_iff.mpr (hn n hN))
+  · by_contra hn
+    push Not at hn
+    apply h
+    exact eventually_constant_reduces B _ true N (fun n hN => Bool.eq_true_of_not_eq_false (hn n hN))
+
+def foldNumeral (L : List ℕ) : ℕ := L.foldl (fun a b => 2*a+b) 0
+
+theorem foldNumeral_primrec : Primrec foldNumeral :=
+  Primrec.list_foldl Primrec.id (Primrec.const 0)
+    ((Primrec.nat_add.comp (Primrec.nat_mul.comp (Primrec.const 2) Primrec.fst) Primrec.snd).comp Primrec.snd).to₂
+
+theorem foldNumeral_prefix (B : Oracle) (n : ℕ) :
+    foldNumeral (oraclePrefix (bit B) n) = numeral B n := by
+  induction n with
+  | zero => rfl
+  | succ n ih =>
+    simpa [foldNumeral, oraclePrefix, List.range_succ, List.foldl_append, numeral] using
+      congrArg (fun a => 2*a+bit B n) ih
+
+theorem numeral_recursive (B : Oracle) :
+    Nat.RecursiveIn {oracleFunction B} (fun n => Part.some (numeral B n)) := by
+  have hf := total_comp (total_primrec (foldNumeral_primrec.comp
+      (Primrec.option_getD_default.comp Primrec.decode))) (prefix_recursive (bit B))
+  exact hf.of_eq (fun n => by simp only [encodek, Option.getD_some, foldNumeral_prefix])
+
+theorem powTwo_primrec : Primrec (fun n : ℕ => 2^n) := by
+  have hp : Primrec (fun n : ℕ => (List.range n).foldl (fun a _ => 2*a) 1) :=
+    Primrec.list_foldl Primrec.list_range (Primrec.const 1)
+      ((Primrec.nat_mul.comp (Primrec.const 2) Primrec.fst).comp Primrec.snd).to₂
+  apply hp.of_eq
+  intro n
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    simp only [List.range_succ, List.foldl_append, List.foldl_cons, List.foldl_nil]
+    rw [ih, pow_succ, Nat.mul_comm]
+
+def fracLeft (z : ℕ × ℕ × ℕ) : ℕ := positiveNumerator z.1 * z.2.2
+def fracRight (z : ℕ × ℕ × ℕ) : ℕ := z.2.1 * denominator z.1 + negativeNumerator z.1 * z.2.2
+
+theorem fracLeft_primrec : Primrec fracLeft := Primrec.nat_mul.comp
+  (positiveNumerator_primrec.comp Primrec.fst) (Primrec.snd.comp Primrec.snd)
+theorem fracRight_primrec : Primrec fracRight := Primrec.nat_add.comp
+  (Primrec.nat_mul.comp (Primrec.fst.comp Primrec.snd) (denominator_primrec.comp Primrec.fst))
+  (Primrec.nat_mul.comp (negativeNumerator_primrec.comp Primrec.fst) (Primrec.snd.comp Primrec.snd))
+
+theorem frac_lt_iff (q k D : ℕ) (hD : 0 < D) :
+    fracLeft (q,k,D) < fracRight (q,k,D) ↔ (rationalEnumeration q : ℝ) < (k : ℝ)/D := by
+  rw [signed_query_value, div_lt_div_iff₀ (by exact_mod_cast denominator_pos q) (by exact_mod_cast hD)]
+  unfold fracLeft fracRight
+  constructor <;> intro h
+  · have hh : (positiveNumerator q : ℝ)*D < k*denominator q + negativeNumerator q*D := by exact_mod_cast h
+    nlinarith
+  · have hh : (positiveNumerator q : ℝ)*D < k*denominator q + negativeNumerator q*D := by nlinarith
+    exact_mod_cast hh
+
+theorem lt_frac_iff (q k D : ℕ) (hD : 0 < D) :
+    fracRight (q,k,D) < fracLeft (q,k,D) ↔ (k : ℝ)/D < (rationalEnumeration q : ℝ) := by
+  rw [signed_query_value, div_lt_div_iff₀ (by exact_mod_cast hD) (by exact_mod_cast denominator_pos q)]
+  unfold fracLeft fracRight
+  constructor <;> intro h
+  · have hh : k* (denominator q : ℝ) + negativeNumerator q*D < positiveNumerator q*D := by exact_mod_cast h
+    nlinarith
+  · have hh : k* (denominator q : ℝ) + negativeNumerator q*D < positiveNumerator q*D := by nlinarith
+    exact_mod_cast hh
+
+theorem frac_eq_iff (q k D : ℕ) (hD : 0 < D) :
+    fracLeft (q,k,D) = fracRight (q,k,D) ↔ (rationalEnumeration q : ℝ) = (k : ℝ)/D := by
+  constructor
+  · intro he
+    apply le_antisymm
+    · exact le_of_not_gt (fun h => by have := (lt_frac_iff q k D hD).mpr h; omega)
+    · exact le_of_not_gt (fun h => by have := (frac_lt_iff q k D hD).mpr h; omega)
+  · intro he
+    apply Nat.le_antisymm
+    · exact Nat.le_of_not_gt (fun h => by have := (lt_frac_iff q k D hD).mp h; linarith)
+    · exact Nat.le_of_not_gt (fun h => by have := (frac_lt_iff q k D hD).mp h; linarith)
+
+end TuringRigidity.BinarySeries
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/BinaryRecovery.lean

@@ -0,0 +1,131 @@
+import OAI.Computability.DegreeRigidity.Computability.BinaryMachine
+
+namespace OAI
+
+namespace TuringRigidity.BinarySeries
+open UniformOracle RationalCoding Encodable
+
+def recoverGuard (z : ℕ × ℕ × ℕ × ℕ) : Prop :=
+  fracLeft (z.2.2.1,z.2.1,2^(z.1+1)) = fracRight (z.2.2.1,z.2.1,2^(z.1+1)) ∧
+  fracLeft (z.2.2.2,z.2.1+1,2^(z.1+1)) = fracRight (z.2.2.2,z.2.1+1,2^(z.1+1))
+instance (z : ℕ × ℕ × ℕ × ℕ) : Decidable (recoverGuard z) := inferInstanceAs (Decidable (_ ∧ _))
+
+theorem recoverGuard_primrec : PrimrecPred recoverGuard := by
+  have hn : Primrec (fun z : ℕ × ℕ × ℕ × ℕ => 2^(z.1+1)) :=
+    powTwo_primrec.comp (Primrec.succ.comp Primrec.fst)
+  have hk : Primrec (fun z : ℕ × ℕ × ℕ × ℕ => z.2.1) := Primrec.fst.comp Primrec.snd
+  have hi : Primrec (fun z : ℕ × ℕ × ℕ × ℕ => z.2.2.1) := Primrec.fst.comp (Primrec.snd.comp Primrec.snd)
+  have hj : Primrec (fun z : ℕ × ℕ × ℕ × ℕ => z.2.2.2) := Primrec.snd.comp (Primrec.snd.comp Primrec.snd)
+  exact (Primrec.eq.comp (fracLeft_primrec.comp (hi.pair (hk.pair hn)))
+    (fracRight_primrec.comp (hi.pair (hk.pair hn)))).and
+    (Primrec.eq.comp (fracLeft_primrec.comp (hj.pair ((Primrec.succ.comp hk).pair hn)))
+      (fracRight_primrec.comp (hj.pair ((Primrec.succ.comp hk).pair hn))))
+
+def recoverDecision (z : (ℕ × ℕ × ℕ × ℕ) × (ℕ × ℕ)) : Option ℕ :=
+  if recoverGuard z.1 ∧ z.2.1=1 ∧ z.2.2=0 then some (z.1.2.1%2) else none
+
+theorem recoverDecision_primrec : Primrec recoverDecision :=
+  Primrec.ite ((recoverGuard_primrec.comp Primrec.fst).and
+    ((Primrec.eq.comp (Primrec.fst.comp Primrec.snd) (Primrec.const 1)).and
+      (Primrec.eq.comp (Primrec.snd.comp Primrec.snd) (Primrec.const 0))))
+    (Primrec.option_some.comp (Primrec.nat_mod.comp
+      (Primrec.fst.comp (Primrec.snd.comp Primrec.fst)) (Primrec.const 2))) (Primrec.const none)
+
+noncomputable def recoverTrial (B : Oracle) (n m : ℕ) : Option ℕ :=
+  let k := (Nat.unpair m).1
+  let i := (Nat.unpair (Nat.unpair m).2).1
+  let j := (Nat.unpair (Nat.unpair m).2).2
+  recoverDecision ((n,k,i,j),(bit (cut (value B)) i,bit (cut (value B)) j))
+
+theorem recoverTrial_recursive (B : Oracle) :
+    Nat.RecursiveIn {oracleFunction (cut (value B))}
+      (fun z => Part.some (encode (recoverTrial B (Nat.unpair z).1 (Nat.unpair z).2))) := by
+  let O : Set (ℕ →. ℕ) := {oracleFunction (cut (value B))}
+  have hn := total_primrec (O := O) (Primrec.fst.comp Primrec.unpair)
+  have hm := total_primrec (O := O) (Primrec.snd.comp Primrec.unpair)
+  have hk := total_comp (total_primrec (Primrec.fst.comp Primrec.unpair)) hm
+  have hi := total_comp (total_primrec (Primrec.fst.comp (Primrec.unpair.comp (Primrec.snd.comp Primrec.unpair)))) hm
+  have hj := total_comp (total_primrec (Primrec.snd.comp (Primrec.unpair.comp (Primrec.snd.comp Primrec.unpair)))) hm
+  have hg : Nat.RecursiveIn O (oracleFunction (cut (value B))) := .oracle _ (Set.mem_singleton _)
+  have hmeta := total_pair hn (total_pair hk (total_pair hi hj))
+  have hbits := total_pair (total_comp hg hi) (total_comp hg hj)
+  have hdecode : Primrec (fun z : ℕ =>
+      (((Nat.unpair (Nat.unpair z).1).1,
+        (Nat.unpair (Nat.unpair (Nat.unpair z).1).2).1,
+        Nat.unpair (Nat.unpair (Nat.unpair (Nat.unpair z).1).2).2),Nat.unpair (Nat.unpair z).2)) := by
+    exact (((Primrec.fst.comp Primrec.unpair).pair
+      (((Primrec.fst.comp Primrec.unpair).pair (Primrec.unpair.comp (Primrec.snd.comp Primrec.unpair))).comp
+        (Primrec.snd.comp Primrec.unpair))).comp (Primrec.fst.comp Primrec.unpair)).pair
+      (Primrec.unpair.comp (Primrec.snd.comp Primrec.unpair))
+  exact (total_comp (total_primrec (Primrec.encode.comp (recoverDecision_primrec.comp hdecode)))
+    (total_pair hmeta hbits)).of_eq (fun z => by simp [recoverTrial,bit])
+
+theorem recoverTrial_sound (B : Oracle) (hB : Mixed B) (n m a : ℕ)
+    (ha : a ∈ recoverTrial B n m) : a = bit B n := by
+  let k := (Nat.unpair m).1
+  let i := (Nat.unpair (Nat.unpair m).2).1
+  let j := (Nat.unpair (Nat.unpair m).2).2
+  change a ∈ recoverDecision ((n,k,i,j),(bit (cut (value B)) i,bit (cut (value B)) j)) at ha
+  unfold recoverDecision at ha
+  split at ha
+  · rename_i h
+    have hai : a=k%2 := by simpa using (Option.mem_def.mp ha).symm
+    have hi := (frac_eq_iff i k (2^(n+1)) (by positivity)).mp h.1.1
+    have hj := (frac_eq_iff j (k+1) (2^(n+1)) (by positivity)).mp h.1.2
+    have hci : cut (value B) i=true := by cases hh : cut (value B) i <;> simp_all [bit]
+    have hcj : cut (value B) j=false := by cases hh : cut (value B) j <;> simp_all [bit]
+    have hlo := (cut_eq_true _ _).mp hci
+    have hup : value B ≤ (rationalEnumeration j : ℝ) := le_of_not_gt (fun hh => by
+      have := (cut_eq_true _ _).mpr hh; simp_all)
+    rw [hi] at hlo
+    rw [hj] at hup
+    have hb := strict_bracket B hB (n+1)
+    have hD : (0 : ℝ) < (2^(n+1) : ℝ) := by positivity
+    have hk1 : (k : ℝ) < numeral B (n+1)+1 := by
+      have hh := lt_trans hlo hb.2
+      push_cast at hh
+      exact (div_lt_div_iff_of_pos_right hD).mp hh
+    have hk2 : (numeral B (n+1) : ℝ) < k+1 := by
+      have hh := lt_of_lt_of_le hb.1 hup
+      push_cast at hh
+      exact (div_lt_div_iff_of_pos_right hD).mp hh
+    have hk : k = numeral B (n+1) := by
+      have h1 : k < numeral B (n+1)+1 := by exact_mod_cast hk1
+      have h2 : numeral B (n+1) < k+1 := by exact_mod_cast hk2
+      omega
+    rw [hai,hk,numeral]
+    unfold bit
+    split <;> omega
+  · simp at ha
+
+theorem recoverTrial_complete (B : Oracle) (hB : Mixed B) (n : ℕ) :
+    ∃ m a, a ∈ recoverTrial B n m := by
+  let k := numeral B (n+1)
+  let i := encode ((k : ℚ)/2^(n+1))
+  let j := encode (((k+1 : ℕ) : ℚ)/2^(n+1))
+  have hi : (rationalEnumeration i : ℝ) = (k : ℝ)/(2^(n+1) : ℕ) := by simp [i,rationalEnumeration]
+  have hj : (rationalEnumeration j : ℝ) = ((k+1 : ℕ) : ℝ)/(2^(n+1) : ℕ) := by simp [j,rationalEnumeration]
+  have hg : recoverGuard (n,k,i,j) := ⟨(frac_eq_iff _ _ _ (by positivity)).mpr hi,
+    (frac_eq_iff _ _ _ (by positivity)).mpr hj⟩
+  have hb := strict_bracket B hB (n+1)
+  have hci : cut (value B) i=true := (cut_eq_true _ _).mpr (by simpa [hi,k] using hb.1)
+  have hcj : cut (value B) j=false := Bool.eq_false_iff.mpr (fun hh => by
+    have hh' := (cut_eq_true _ _).mp hh
+    rw [hj] at hh'
+    push_cast at hh'
+    dsimp only [k] at hh'
+    linarith [hb.2])
+  exact ⟨Nat.pair k (Nat.pair i j),k%2,by simp [recoverTrial,recoverDecision,bit,hci,hcj,hg]⟩
+
+theorem set_reduces_cut (B : Oracle) (hB : Mixed B) : Reduces B (cut (value B)) := by
+  apply RecursiveIn.iff_nat.mpr
+  exact total_search (recoverTrial_recursive B) _ (recoverTrial_sound B hB) (recoverTrial_complete B hB)
+
+theorem set_single_program (B : Oracle) (hB : Mixed B) :
+    ∃ p : OracleCode, ∀ n, OracleCode.eval (oracleFunction (cut (value B))) p n = oracleFunction B n := by
+  obtain ⟨p,hp⟩ := (OracleCode.turingReducible_iff_exists_code _ _).mp (set_reduces_cut B hB)
+  exact ⟨p,fun n => congrFun hp n⟩
+
+end TuringRigidity.BinarySeries
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/BinarySeries.lean

@@ -0,0 +1,91 @@
+import OAI.Computability.DegreeRigidity.Computability.Cuts
+import Mathlib.Analysis.Real.OfDigits
+
+namespace OAI
+
+namespace TuringRigidity.BinarySeries
+
+def bit (B : Oracle) (n : ℕ) : ℕ := if B n then 1 else 0
+
+def digits (B : Oracle) (n : ℕ) : Fin 2 := ⟨bit B n, by unfold bit; split <;> omega⟩
+
+noncomputable def value (B : Oracle) : ℝ := Real.ofDigits (digits B)
+
+def numeral (B : Oracle) : ℕ → ℕ
+  | 0 => 0
+  | n+1 => 2 * numeral B n + bit B n
+
+theorem numeral_sum (B : Oracle) (n : ℕ) :
+    (∑ i ∈ Finset.range n, Real.ofDigitsTerm (digits B) i) =
+      (numeral B n : ℝ) / 2^n := by
+  induction n with
+  | zero => simp [numeral]
+  | succ n ih =>
+    rw [Finset.sum_range_succ, ih]
+    simp only [numeral, Nat.cast_add, Nat.cast_mul, Nat.cast_ofNat,
+      Real.ofDigitsTerm, digits, pow_succ]
+    field_simp
+
+theorem split_value (B : Oracle) (n : ℕ) :
+    value B = (numeral B n : ℝ)/2^n + (2^n : ℝ)⁻¹ * value (fun i => B (i+n)) := by
+  exact (Real.ofDigits_eq_sum_add_ofDigits (digits B) n).trans (by rw [numeral_sum]; rfl)
+
+theorem nonneg (B : Oracle) : 0 ≤ value B := Real.ofDigits_nonneg _
+theorem le_one (B : Oracle) : value B ≤ 1 := Real.ofDigits_le_one _
+
+theorem positive (B : Oracle) (h : ∃ n, B n = true) : 0 < value B := by
+  obtain ⟨n, hn⟩ := h
+  have ht : 0 < Real.ofDigitsTerm (digits B) n := by
+    simp [Real.ofDigitsTerm, digits, bit, hn]
+  exact lt_of_lt_of_le ht (Summable.le_tsum Real.summable_ofDigitsTerm n
+    (fun _ _ => Real.ofDigitsTerm_nonneg))
+
+theorem complement (B : Oracle) : value B + value (fun n => !(B n)) = 1 := by
+  rw [value, value, Real.ofDigits, Real.ofDigits, ← Summable.tsum_add
+    Real.summable_ofDigitsTerm Real.summable_ofDigitsTerm]
+  have he : (fun n => Real.ofDigitsTerm (digits B) n +
+      Real.ofDigitsTerm (digits (fun n => !(B n))) n) =
+      Real.ofDigitsTerm (fun _ => (⟨1, by omega⟩ : Fin 2)) := by
+    funext n
+    cases h : B n <;> simp [Real.ofDigitsTerm, digits, bit, h]
+  rw [he]
+  exact Real.ofDigits_const_last_eq_one' (by omega : 1 < 2)
+
+theorem lt_one (B : Oracle) (h : ∃ n, B n = false) : value B < 1 := by
+  have hp := positive (fun n => !(B n)) (by obtain ⟨n, hn⟩ := h; exact ⟨n, by simp [hn]⟩)
+  have hc := complement B
+  linarith
+
+def Mixed (B : Oracle) : Prop := ∀ N, (∃ n, N ≤ n ∧ B n = true) ∧ (∃ n, N ≤ n ∧ B n = false)
+
+theorem strict_bracket (B : Oracle) (h : Mixed B) (n : ℕ) :
+    (numeral B n : ℝ)/2^n < value B ∧ value B < (numeral B n + 1 : ℝ)/2^n := by
+  have hp : 0 < value (fun i => B (i+n)) := by
+    apply positive
+    obtain ⟨k,hk,hb⟩ := (h n).1
+    exact ⟨k-n, by simpa [Nat.sub_add_cancel hk] using hb⟩
+  have hu : value (fun i => B (i+n)) < 1 := by
+    apply lt_one
+    obtain ⟨k,hk,hb⟩ := (h n).2
+    exact ⟨k-n, by simpa [Nat.sub_add_cancel hk] using hb⟩
+  rw [split_value B n]
+  have hd : (0 : ℝ) < (2^n : ℝ)⁻¹ := by positivity
+  constructor
+  · nlinarith
+  · rw [add_div]
+    simp only [one_div]
+    nlinarith
+
+theorem bracket (B : Oracle) (n : ℕ) :
+    (numeral B n : ℝ)/2^n ≤ value B ∧ value B ≤ (numeral B n + 1 : ℝ)/2^n := by
+  rw [split_value B n]
+  have hp := nonneg (fun i => B (i+n))
+  have hu := le_one (fun i => B (i+n))
+  have hd : (0 : ℝ) < (2^n : ℝ)⁻¹ := by positivity
+  constructor
+  · nlinarith
+  · rw [add_div]; simp only [one_div]; nlinarith
+
+end TuringRigidity.BinarySeries
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/BranchFrequency.lean

@@ -0,0 +1,71 @@
+import OAI.Computability.DegreeRigidity.Computability.BranchRecovery
+
+namespace OAI
+
+namespace TuringRigidity
+
+namespace UniformOracle
+
+def runningSum (f : ℕ → ℕ) : ℕ → ℕ
+  | 0 => 0
+  | n+1 => runningSum f n + f n
+
+theorem runningSum_recursive {O : Set (ℕ →. ℕ)} {f : ℕ → ℕ}
+    (hf : Nat.RecursiveIn O (fun n => Part.some (f n))) :
+    Nat.RecursiveIn O (fun n => Part.some (runningSum f n)) := by
+  have hy := total_primrec (O := O) (Primrec.fst.comp (Primrec.unpair.comp
+    (Primrec.snd.comp Primrec.unpair)))
+  have hi := total_primrec (O := O) (Primrec.snd.comp (Primrec.unpair.comp
+    (Primrec.snd.comp Primrec.unpair)))
+  have hs := total_comp (total_primrec (Primrec.nat_add.comp
+    (Primrec.fst.comp Primrec.unpair) (Primrec.snd.comp Primrec.unpair)))
+    (total_pair hi (total_comp hf hy))
+  have hp := Nat.RecursiveIn.prec (total_primrec (Primrec.const 0)) hs
+  have hh := Nat.RecursiveIn.comp hp
+    (total_pair (total_primrec (Primrec.const 0)) (total_primrec Primrec.id))
+  apply hh.of_eq
+  intro n
+  change (Part.some (Nat.pair 0 n)).bind _ = _
+  rw [Part.bind_some]
+  simp only [Nat.unpair_pair]
+  induction n with
+  | zero => rfl
+  | succ n ih =>
+    simp only [ih]
+    change (Part.some (runningSum f n)).bind _ = _
+    rw [Part.bind_some]
+    rfl
+end UniformOracle
+
+namespace RecoveryData
+variable {F : ℝ → Oracle} {t u v : ℝ}
+
+def count (d : RecoveryData F t u v) : ℕ → ℕ :=
+  UniformOracle.runningSum (fun n => if d.branchOracle n then 1 else 0)
+
+theorem count_eq_sum (d : RecoveryData F t u v) (n : ℕ) :
+    (d.count n : ℝ) = ∑ k ∈ Finset.range n, branch d.test (d.delta : ℝ) t k := by
+  induction n with
+  | zero => simp [count,UniformOracle.runningSum]
+  | succ n ih =>
+    simp only [count,UniformOracle.runningSum,Finset.sum_range_succ,Nat.cast_add]
+    rw [show (UniformOracle.runningSum (fun n => if d.branchOracle n then 1 else 0) n : ℝ) =
+      ∑ k ∈ Finset.range n, branch d.test (d.delta : ℝ) t k from ih]
+    congr 1
+    cases hb : d.branchOracle n <;> simp [branch,choiceBit,branchOracle] at hb ⊢ <;> simp [hb]
+
+theorem count_recursive (d : RecoveryData F t u v) (ht0 : 0 < t) (ht1 : t < 1) :
+    Nat.RecursiveIn {oracleFunction (fourTuple F t u v d.delta)}
+      (fun n => Part.some (d.count n)) := by
+  exact UniformOracle.runningSum_recursive (RecursiveIn.iff_nat.mp (d.branch_reduces ht0 ht1))
+
+theorem count_frequency_bound (d : RecoveryData F t u v) (ht0 : 0 < t) (ht1 : t < 1)
+    (n : ℕ) (hn : 0 < n) :
+    |t - (d.count n : ℝ)/(n : ℝ)| < 1/((n : ℝ)*(d.delta : ℝ)) := by
+  rw [count_eq_sum]
+  exact d.frequency_bound ht0 ht1 n hn
+
+end RecoveryData
+end TuringRigidity
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/BranchMachine.lean

@@ -0,0 +1,143 @@
+import OAI.Computability.DegreeRigidity.Effective.PartialComputability
+import OAI.Computability.DegreeRigidity.SetModels.ParametricEval
+import OAI.Computability.DegreeRigidity.Effective.FiniteApproximation
+
+namespace OAI
+
+namespace TuringRigidity
+open Computable
+
+def partialJoin (f g : ℕ →. ℕ) (k : ℕ) : Part ℕ :=
+  if k.bodd then g (k/2) else f (k/2)
+
+namespace BranchMachine
+
+def initial (g : ℕ →. ℕ) (k : ℕ) : Part ℕ := g (8*k)
+def anchor (g : ℕ →. ℕ) (k : ℕ) : Part ℕ := g (8*k+4)
+def increment (g : ℕ →. ℕ) (h b k : ℕ) : Part ℕ :=
+  g (if b = h then 2*k+1 else 4*k+2)
+
+def step (p q : OracleCode) (j h : ℕ) (g old : ℕ →. ℕ) (k : ℕ) : Part ℕ :=
+  old j >>= fun b =>
+    OracleCode.eval
+      (partialJoin (OracleCode.eval (partialJoin old (increment g h b)) p) (anchor g)) q k
+
+def stage (p q : OracleCode) (j h : ℕ) (g : ℕ →. ℕ) : ℕ → ℕ →. ℕ
+  | 0 => initial g
+  | n+1 => step p q j h g (stage p q j h g n)
+
+theorem partialJoin_approximates {f g : ℕ →. ℕ} {fs gs : ℕ → ℕ →. ℕ}
+    (hf : ∀ k, Approximates (f k) (fun m => fs m k))
+    (hg : ∀ k, Approximates (g k) (fun m => gs m k)) (k : ℕ) :
+    Approximates (partialJoin f g k) (fun m => partialJoin (fs m) (gs m) k) := by
+  simp only [partialJoin]
+  split
+  · exact hg _
+  · exact hf _
+
+theorem stage_approximates (p q : OracleCode) (j h : ℕ)
+    {g : ℕ →. ℕ} {gs : ℕ → ℕ →. ℕ}
+    (hg : ∀ k, Approximates (g k) (fun m => gs m k)) :
+    ∀ n k, Approximates (stage p q j h g n k)
+      (fun m => stage p q j h (gs m) n k) := by
+  intro n
+  induction n with
+  | zero => intro k; exact hg _
+  | succ n ih =>
+    intro k
+    apply (ih j).bind
+    intro b
+    apply OracleCode.eval_approximates _ q k
+    intro x
+    apply partialJoin_approximates
+    · exact OracleCode.eval_approximates
+        (fun x => partialJoin_approximates ih (fun k => hg _) x) p
+    · intro x; exact hg _
+
+variable {α : Type*} [Primcodable α]
+
+theorem partialJoin_partrec {f g : α → ℕ →. ℕ} (hf : Partrec₂ f) (hg : Partrec₂ g) :
+    Partrec₂ (fun a k => partialJoin (f a) (g a) k) := by
+  apply partrec_cond (Computable.nat_bodd.comp snd)
+  · exact hg.comp fst ((Primrec.nat_div.comp Primrec.id (Primrec.const 2)).to_comp.comp snd)
+  · exact hf.comp fst ((Primrec.nat_div.comp Primrec.id (Primrec.const 2)).to_comp.comp snd)
+
+theorem increment_index_computable (h : ℕ) :
+    Computable₂ (fun b k : ℕ => if b = h then 2*k+1 else 4*k+2) := by
+  apply (Computable.cond ((Primrec.beq.comp Primrec.fst (Primrec.const h)).to_comp)
+    ((Primrec.nat_add.comp (Primrec.nat_mul.comp (Primrec.const 2) Primrec.snd)
+      (Primrec.const 1)).to_comp)
+    ((Primrec.nat_add.comp (Primrec.nat_mul.comp (Primrec.const 4) Primrec.snd)
+      (Primrec.const 2)).to_comp)).of_eq
+  intro z
+  by_cases hh : z.1 = h
+  · simp [hh]
+  · have he : (z.1 == h) = false := Bool.eq_false_iff.mpr (fun he => hh (beq_iff_eq.mp he))
+    simp [hh,he]
+
+theorem step_partrec (p q : OracleCode) (j h : ℕ)
+    {g old : α → ℕ →. ℕ} (hg : Partrec₂ g) (ho : Partrec₂ old) :
+    Partrec₂ (fun a k => step p q j h (g a) (old a) k) := by
+  change Partrec (fun z : α × ℕ => (old z.1 j).bind _)
+  apply Partrec.bind (ho.comp fst (Computable.const j))
+  let β := (α × ℕ) × ℕ
+  have hleft : Partrec₂ (fun z : β => old z.1.1) :=
+    ho.comp (fst.comp (fst.comp fst)) snd
+  have hinc : Partrec₂ (fun z : β => increment (g z.1.1) h z.2) :=
+    hg.comp (fst.comp (fst.comp fst))
+      ((increment_index_computable h).comp (snd.comp fst) snd)
+  have hforward := OracleCode.eval_partrec (partialJoin_partrec hleft hinc) p
+  have hanchor : Partrec₂ (fun z : β => anchor (g z.1.1)) :=
+    hg.comp (fst.comp (fst.comp fst))
+      ((Primrec.nat_add.comp (Primrec.nat_mul.comp (Primrec.const 8) Primrec.snd)
+        (Primrec.const 4)).to_comp)
+  exact (OracleCode.eval_partrec (partialJoin_partrec hforward hanchor) q).comp
+    Computable.id (snd.comp fst)
+
+def lookup (L : List ℕ) (k : ℕ) : Part ℕ := (L[k]? : Part ℕ)
+
+theorem lookup_partrec : Partrec₂ lookup :=
+  Computable.ofOption Primrec.list_getElem?.to_comp
+
+theorem stage_finite_partrec (p q : OracleCode) (j h : ℕ) :
+    Partrec (fun z : List ℕ × ℕ × ℕ => stage p q j h (lookup z.1) z.2.1 z.2.2) := by
+  let α := List ℕ × ℕ × ℕ
+  let body (c : Nat.Partrec.Code) (z : α) : Part ℕ :=
+    if z.2.1 == 0 then initial (lookup z.1) z.2.2 else
+      step p q j h (lookup z.1)
+        (fun k => c.eval (Encodable.encode (z.1, z.2.1-1, k))) z.2.2
+  have hb : Partrec₂ body := by
+    apply partrec_cond ((Primrec.beq.comp
+      (Primrec.fst.comp (Primrec.snd.comp Primrec.snd)) (Primrec.const 0)).to_comp)
+    · exact lookup_partrec.comp (fst.comp snd)
+        ((Primrec.nat_mul.comp (Primrec.const 8)
+          (Primrec.snd.comp (Primrec.snd.comp Primrec.snd))).to_comp)
+    · have hg : Partrec₂ (fun z : Nat.Partrec.Code × α => lookup z.2.1) :=
+        lookup_partrec.comp (fst.comp (snd.comp fst)) snd
+      have ho : Partrec₂ (fun z : Nat.Partrec.Code × α =>
+          fun k => z.1.eval (Encodable.encode (z.2.1,z.2.2.1-1,k))) :=
+        Nat.Partrec.Code.eval_part.comp (fst.comp fst)
+          ((Computable.encode (α := List ℕ × ℕ × ℕ)).comp ((fst.comp (snd.comp fst)).pair
+            ((Computable.pred.comp (fst.comp (snd.comp (snd.comp fst)))).pair snd)))
+      exact (step_partrec p q j h hg ho).comp Computable.id (snd.comp (snd.comp snd))
+  obtain ⟨c,hc⟩ := partrec_fixed_point hb
+  have heq : ∀ n L k, c.eval (Encodable.encode (L,n,k)) = stage p q j h (lookup L) n k := by
+    intro n
+    induction n with
+    | zero => intro L k; rw [hc]; rfl
+    | succ n ih =>
+      intro L k
+      rw [hc]
+      have hn0 : (n+1 == 0) = false := rfl
+      simp only [body, hn0,
+        Bool.false_eq_true, ↓reduceIte, Nat.add_sub_cancel, stage]
+      congr 1
+      funext i
+      exact ih L i
+  exact (Nat.Partrec.Code.eval_part.comp (Computable.const c) Computable.encode).of_eq
+    (fun z => heq z.2.1 z.1 z.2.2)
+
+end BranchMachine
+end TuringRigidity
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/BranchRecovery.lean

@@ -0,0 +1,156 @@
+import OAI.Computability.DegreeRigidity.Effective.UniformOracle
+import OAI.Computability.DegreeRigidity.Computability.RecoverySetup
+import OAI.Computability.DegreeRigidity.Representation.Assembly
+
+namespace OAI
+
+namespace TuringRigidity
+
+@[simp] theorem partialJoin_oracle (A B : Oracle) :
+    partialJoin (oracleFunction A) (oracleFunction B) = oracleFunction (join A B) := by
+  funext k
+  cases hk : k.bodd <;> simp [partialJoin, oracleFunction, join, hk]
+
+namespace RecoveryData
+variable {F : ℝ → Oracle} {t u v : ℝ}
+
+def highBit (d : RecoveryData F t u v) : ℕ := if F (u+d.hi) d.bit then 1 else 0
+
+def branchOracle (d : RecoveryData F t u v) : Oracle :=
+  fun n => d.test (state d.test (d.delta : ℝ) t n)
+
+private theorem tuple_initial (d : RecoveryData F t u v) :
+    BranchMachine.initial (oracleFunction (fourTuple F t u v d.delta)) = oracleFunction (F u) := by
+  funext k
+  change oracleFunction (fourTuple F t u v d.delta) (8*k) = _
+  rw [show 8*k = 2*(2*(2*k)) by omega]
+  simp [oracleFunction, fourTuple]
+
+private theorem tuple_anchor (d : RecoveryData F t u v) :
+    BranchMachine.anchor (oracleFunction (fourTuple F t u v d.delta)) = oracleFunction (F (u-v)) := by
+  funext k
+  change oracleFunction (fourTuple F t u v d.delta) (8*k+4) = _
+  rw [show 8*k+4 = 2*(2*(2*k+1)) by omega]
+  simp [oracleFunction, fourTuple]
+
+private theorem tuple_increment (d : RecoveryData F t u v) (s : ℝ) :
+    BranchMachine.increment (oracleFunction (fourTuple F t u v d.delta)) d.highBit
+      (if F (u+s) d.bit then 1 else 0) =
+    oracleFunction (F (v-u+(d.delta : ℝ)*(t-choiceBit d.test s))) := by
+  funext k
+  have h3 : oracleFunction (fourTuple F t u v d.delta) (4*k+2) =
+      oracleFunction (F (v-u+(d.delta : ℝ)*t)) k := by
+    rw [show 4*k+2 = 2*(2*k+1) by omega]
+    simp [oracleFunction, fourTuple]
+  have h4 : oracleFunction (fourTuple F t u v d.delta) (2*k+1) =
+      oracleFunction (F (v-u+(d.delta : ℝ)*(t-1))) k := by
+    simp [oracleFunction, fourTuple]
+  cases hb : F (u+s) d.bit <;> cases hh : F (u+d.hi) d.bit <;>
+    simp [BranchMachine.increment, highBit, choiceBit, test, hb, hh, h3, h4]
+
+private theorem increment_span (d : RecoveryData F t u v) (s : ℝ) :
+    (d.delta : ℝ)*(t-choiceBit d.test s) ∈ rationalSpan t := by
+  cases hb : d.test s
+  · exact ⟨0,d.delta,by simp [choiceBit,hb]⟩
+  · refine ⟨-d.delta,d.delta,?_⟩
+    simp only [choiceBit,hb,↓reduceIte,Rat.cast_neg]
+    ring
+
+private theorem increment_abs (d : RecoveryData F t u v) (ht0 : 0 < t) (ht1 : t < 1)
+    (s : ℝ) : |(d.delta : ℝ)*(t-choiceBit d.test s)| < d.radius := by
+  have hd : (0 : ℝ) < d.delta := by exact_mod_cast d.delta_pos
+  have hδ := d.delta_lt
+  apply abs_lt.mpr
+  cases hb : d.test s <;> simp only [choiceBit,hb,Bool.false_eq_true,↓reduceIte,sub_zero] <;>
+    constructor <;> nlinarith
+
+theorem stage_correct (d : RecoveryData F t u v) (ht0 : 0 < t) (ht1 : t < 1) :
+    ∀ n, BranchMachine.stage (codeEnumeration d.forward) (codeEnumeration d.backward)
+      d.bit d.highBit (oracleFunction (fourTuple F t u v d.delta)) n =
+        oracleFunction (F (u+state d.test (d.delta : ℝ) t n)) := by
+  intro n
+  induction n with
+  | zero =>
+    funext input
+    simpa [BranchMachine.stage,state] using congrFun (tuple_initial d) input
+  | succ n ih =>
+    let s := state d.test (d.delta : ℝ) t n
+    let a := (d.delta : ℝ)*(t-choiceBit d.test s)
+    have hsa : s+a = state d.test (d.delta : ℝ) t (n+1) := rfl
+    have hp := d.forward_correct s (state_mem_rationalSpan d.test d.delta t n)
+      a (increment_span d s) (d.abs_state_lt ht0 ht1 n) (increment_abs d ht0 ht1 s)
+    have hq := d.backward_correct (s+a) (by rw [hsa]; exact state_mem_rationalSpan _ _ _ _)
+      (by rw [hsa]; exact d.abs_state_lt ht0 ht1 (n+1))
+    funext k
+    simp only [BranchMachine.stage,BranchMachine.step,ih,oracleFunction]
+    change (Part.some _).bind _ = _
+    rw [Part.bind_some]
+    change OracleCode.eval
+      (partialJoin (OracleCode.eval
+        (partialJoin (oracleFunction (F (u+s)))
+          (BranchMachine.increment (oracleFunction (fourTuple F t u v d.delta)) d.highBit
+            (if F (u+s) d.bit then 1 else 0))) (codeEnumeration d.forward))
+        (BranchMachine.anchor (oracleFunction (fourTuple F t u v d.delta))))
+      (codeEnumeration d.backward) k = _
+    rw [tuple_increment,tuple_anchor,partialJoin_oracle,hp]
+    rw [show v+s+a = v+(s+a) by ring,partialJoin_oracle,hq]
+    rfl
+
+theorem stage_single_program (d : RecoveryData F t u v) (ht0 : 0 < t) (ht1 : t < 1) :
+    ∃ c : OracleCode, ∀ n k,
+      OracleCode.eval (oracleFunction (fourTuple F t u v d.delta)) c (Nat.pair n k) =
+        oracleFunction (F (u+state d.test (d.delta : ℝ) t n)) k := by
+  let T := fourTuple F t u v d.delta
+  let g : ℕ → ℕ := fun k => if T k then 1 else 0
+  let f : ℕ → ℕ := fun z => if F (u+state d.test (d.delta : ℝ) t (Nat.unpair z).1)
+      (Nat.unpair z).2 then 1 else 0
+  have hg : (fun x => Part.some (g x)) = oracleFunction (fourTuple F t u v d.delta) := rfl
+  have hf := UniformOracle.stage_recursive (codeEnumeration d.forward) (codeEnumeration d.backward)
+    d.bit d.highBit g f (by
+      intro n k
+      rw [hg]
+      have hs := congrFun (d.stage_correct ht0 ht1 n) k
+      apply hs.trans
+      simp only [f,Nat.unpair_pair]
+      rfl)
+  obtain ⟨c,hc⟩ := OracleCode.exists_code hf
+  rw [hg] at hc
+  refine ⟨c,fun n k => (congrFun hc (Nat.pair n k)).trans ?_⟩
+  simp only [f,Nat.unpair_pair]
+  rfl
+
+theorem branch_reduces (d : RecoveryData F t u v) (ht0 : 0 < t) (ht1 : t < 1) :
+    Reduces d.branchOracle (fourTuple F t u v d.delta) := by
+  obtain ⟨c,hc⟩ := d.stage_single_program ht0 ht1
+  have he := OracleCode.eval_recursiveIn (oracleFunction (fourTuple F t u v d.delta)) c
+  have hp := UniformOracle.total_primrec (O := {oracleFunction (fourTuple F t u v d.delta)})
+    (Primrec₂.natPair.comp Primrec.id (Primrec.const d.bit))
+  have hbits : Nat.RecursiveIn {oracleFunction (fourTuple F t u v d.delta)}
+      (fun input => oracleFunction (F (u+state d.test (d.delta : ℝ) t input)) d.bit) :=
+    (Nat.RecursiveIn.comp he hp).of_eq (fun n => by
+    change (Part.some (Nat.pair n d.bit)).bind
+      (fun input => OracleCode.eval (oracleFunction (fourTuple F t u v d.delta)) c input) = _
+    rw [Part.bind_some,hc])
+  have hcmp : Primrec (fun b : ℕ => if b = d.highBit then 1 else 0) :=
+    Primrec.ite (Primrec.eq.comp Primrec.id (Primrec.const d.highBit))
+      (Primrec.const 1) (Primrec.const 0)
+  apply RecursiveIn.iff_nat.mpr
+  apply (Nat.RecursiveIn.comp (UniformOracle.total_primrec hcmp) hbits).of_eq
+  intro n
+  simp only [oracleFunction]
+  change (Part.some _).bind _ = _
+  rw [Part.bind_some]
+  cases hb : F (u+state d.test (d.delta : ℝ) t n) d.bit <;>
+    cases hh : F (u+d.hi) d.bit <;>
+    simp [branchOracle,test,highBit,hb,hh]
+
+theorem branch_single_program (d : RecoveryData F t u v) (ht0 : 0 < t) (ht1 : t < 1) :
+    ∃ c : OracleCode,
+      OracleCode.eval (oracleFunction (fourTuple F t u v d.delta)) c =
+        oracleFunction d.branchOracle :=
+  (OracleCode.turingReducible_iff_exists_code _ _).mp (d.branch_reduces ht0 ht1)
+
+end RecoveryData
+end TuringRigidity
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/CutAddition.lean

@@ -0,0 +1,140 @@
+import OAI.Computability.DegreeRigidity.OrdinalCodes.SumComparison
+import OAI.Computability.DegreeRigidity.Computability.Joins
+
+namespace OAI
+
+namespace TuringRigidity
+namespace CutAddition
+open RationalCoding UniformOracle
+
+def decision (z : ℕ × (ℕ × ℕ) × (ℕ × ℕ)) : Option ℕ :=
+  if z.2.2.1=1 ∧ z.2.2.2=1 ∧ sumLeft (z.1,z.2.1.1,z.2.1.2)<sumRight (z.1,z.2.1.1,z.2.1.2)
+    then some 1 else
+  if z.2.2.1=0 ∧ z.2.2.2=0 ∧ sumRight (z.1,z.2.1.1,z.2.1.2)<sumLeft (z.1,z.2.1.1,z.2.1.2)
+    then some 0 else none
+
+theorem decision_primrec : Primrec decision := by
+  let hargs := Primrec.fst.pair (Primrec.fst.comp Primrec.snd)
+    (α := ℕ × (ℕ × ℕ) × (ℕ × ℕ))
+  let hfirst := Primrec.fst.comp (Primrec.snd.comp Primrec.snd)
+    (α := ℕ × (ℕ × ℕ) × (ℕ × ℕ))
+  let hsecond := Primrec.snd.comp (Primrec.snd.comp Primrec.snd)
+    (α := ℕ × (ℕ × ℕ) × (ℕ × ℕ))
+  exact Primrec.ite ((Primrec.eq.comp hfirst (Primrec.const 1)).and
+    ((Primrec.eq.comp hsecond (Primrec.const 1)).and
+      (Primrec.nat_lt.comp (sumLeft_primrec.comp hargs) (sumRight_primrec.comp hargs))))
+    (Primrec.const (some 1))
+    (Primrec.ite ((Primrec.eq.comp hfirst (Primrec.const 0)).and
+      ((Primrec.eq.comp hsecond (Primrec.const 0)).and
+        (Primrec.nat_lt.comp (sumRight_primrec.comp hargs) (sumLeft_primrec.comp hargs))))
+      (Primrec.const (some 0)) (Primrec.const none))
+
+noncomputable def trial (x y : ℝ) (n m : ℕ) : Option ℕ :=
+  decision (n,Nat.unpair m,
+    (if cut x (Nat.unpair m).1 then 1 else 0,if cut y (Nat.unpair m).2 then 1 else 0))
+
+theorem trial_recursive (x y : ℝ) :
+    Nat.RecursiveIn {oracleFunction (join (cut x) (cut y))}
+      (fun z => Part.some (Encodable.encode (trial x y (Nat.unpair z).1 (Nat.unpair z).2))) := by
+  let O : Set (ℕ →. ℕ) := {oracleFunction (join (cut x) (cut y))}
+  have hq := total_primrec (O := O) (Primrec.fst.comp Primrec.unpair)
+  have hi := total_primrec (O := O) (Primrec.fst.comp (Primrec.unpair.comp (Primrec.snd.comp Primrec.unpair)))
+  have hj := total_primrec (O := O) (Primrec.snd.comp (Primrec.unpair.comp (Primrec.snd.comp Primrec.unpair)))
+  have hg : Nat.RecursiveIn O (oracleFunction (join (cut x) (cut y))) := .oracle _ (Set.mem_singleton _)
+  have hbi := total_comp hg (total_comp
+    (total_primrec (Primrec.nat_mul.comp (Primrec.const 2) Primrec.id)) hi)
+  have hbj := total_comp hg (total_comp
+    (total_primrec (Primrec.nat_add.comp (Primrec.nat_mul.comp (Primrec.const 2) Primrec.id)
+      (Primrec.const 1))) hj)
+  have hdec : Primrec (fun z : ℕ => Encodable.encode (decision
+      ((Nat.unpair z).1,Nat.unpair (Nat.unpair (Nat.unpair z).2).1,
+        Nat.unpair (Nat.unpair (Nat.unpair z).2).2))) :=
+    Primrec.encode.comp (decision_primrec.comp
+      ((Primrec.fst.comp Primrec.unpair).pair
+        ((Primrec.unpair.comp (Primrec.fst.comp (Primrec.unpair.comp (Primrec.snd.comp Primrec.unpair)))).pair
+          (Primrec.unpair.comp (Primrec.snd.comp (Primrec.unpair.comp (Primrec.snd.comp Primrec.unpair)))))))
+  exact (total_comp (total_primrec hdec)
+    (total_pair hq (total_pair (total_pair hi hj) (total_pair hbi hbj)))).of_eq
+      (fun z => by simp [trial])
+
+private theorem bit_one (b : Bool) (h : (if b then (1 : ℕ) else 0)=1) : b=true := by
+  cases b <;> simp_all
+private theorem bit_zero (b : Bool) (h : (if b then (1 : ℕ) else 0)=0) : b=false := by
+  cases b <;> simp_all
+
+theorem trial_sound (x y : ℝ) (n m r : ℕ) (hr : r ∈ trial x y n m) :
+    r = if cut (x+y) n then 1 else 0 := by
+  let i := (Nat.unpair m).1
+  let j := (Nat.unpair m).2
+  change r ∈ decision (n,(i,j),(if cut x i then 1 else 0,if cut y j then 1 else 0)) at hr
+  generalize hbi : (if cut x i then (1 : ℕ) else 0) = bi at hr
+  generalize hbj : (if cut y j then (1 : ℕ) else 0) = bj at hr
+  unfold decision at hr
+  split at hr
+  · rename_i h
+    have hr' : r=1 := by symm; simpa using hr
+    subst r
+    have hx := (cut_eq_true x i).mp (bit_one _ (hbi.trans h.1))
+    have hy := (cut_eq_true y j).mp (bit_one _ (hbj.trans h.2.1))
+    have hq := (lt_sum_iff n i j).mp h.2.2
+    have hc : cut (x+y) n=true := (cut_eq_true _ _).mpr (by linarith)
+    simp [hc]
+  · split at hr
+    · rename_i h
+      have hr' : r=0 := by symm; simpa using hr
+      subst r
+      have hx : x ≤ (rationalEnumeration i : ℝ) := le_of_not_gt
+        (fun hx => Bool.noConfusion ((bit_zero _ (hbi.trans h.1)).symm.trans ((cut_eq_true x i).mpr hx)))
+      have hy : y ≤ (rationalEnumeration j : ℝ) := le_of_not_gt
+        (fun hy => Bool.noConfusion ((bit_zero _ (hbj.trans h.2.1)).symm.trans ((cut_eq_true y j).mpr hy)))
+      have hq := (sum_lt_iff n i j).mp h.2.2
+      have hnot : ¬(rationalEnumeration n : ℝ)<x+y := by linarith
+      have hc : cut (x+y) n=false := Bool.eq_false_iff.mpr
+        (fun hc => hnot ((cut_eq_true _ _).mp hc))
+      simp [hc]
+    · simp at hr
+
+theorem trial_complete (x y : ℝ) (hxy : Irrational (x+y)) (n : ℕ) :
+    ∃ m r, r ∈ trial x y n m := by
+  have hne : (rationalEnumeration n : ℝ) ≠ x+y := fun h => hxy ⟨rationalEnumeration n,h⟩
+  rcases lt_or_gt_of_ne hne with h | h
+  · obtain ⟨a,ha,hax⟩ := exists_rat_btwn (show (rationalEnumeration n : ℝ)-y<x by linarith)
+    obtain ⟨b,hb,hby⟩ := exists_rat_btwn (show (rationalEnumeration n : ℝ)-(a : ℝ)<y by linarith)
+    obtain ⟨i,hi⟩ := rationalEnumeration_surjective a
+    obtain ⟨j,hj⟩ := rationalEnumeration_surjective b
+    have hci : cut x i=true := (cut_eq_true x i).mpr (by simpa only [hi] using hax)
+    have hcj : cut y j=true := (cut_eq_true y j).mpr (by simpa only [hj] using hby)
+    have hl : sumLeft (n,i,j)<sumRight (n,i,j) := (lt_sum_iff n i j).mpr (by rw [hi,hj]; linarith)
+    exact ⟨Nat.pair i j,1,by simp [trial,decision,hci,hcj,hl]⟩
+  · obtain ⟨a,hxa,ha⟩ := exists_rat_btwn (show x<(rationalEnumeration n : ℝ)-y by linarith)
+    obtain ⟨b,hyb,hb⟩ := exists_rat_btwn (show y<(rationalEnumeration n : ℝ)-(a : ℝ) by linarith)
+    obtain ⟨i,hi⟩ := rationalEnumeration_surjective a
+    obtain ⟨j,hj⟩ := rationalEnumeration_surjective b
+    have hci : cut x i=false := Bool.eq_false_iff.mpr (fun hc => by
+      have hh := (cut_eq_true x i).mp hc
+      rw [hi] at hh
+      linarith)
+    have hcj : cut y j=false := Bool.eq_false_iff.mpr (fun hc => by
+      have hh := (cut_eq_true y j).mp hc
+      rw [hj] at hh
+      linarith)
+    have hu : sumRight (n,i,j)<sumLeft (n,i,j) := (sum_lt_iff n i j).mpr (by rw [hi,hj]; linarith)
+    exact ⟨Nat.pair i j,0,by simp [trial,decision,hci,hcj,hu]⟩
+
+theorem irrational_add_reduces (x y : ℝ) (hxy : Irrational (x+y)) :
+    Reduces (cut (x+y)) (join (cut x) (cut y)) := by
+  apply RecursiveIn.iff_nat.mpr
+  exact total_search (trial_recursive x y) (fun n => if cut (x+y) n then 1 else 0)
+    (trial_sound x y) (trial_complete x y hxy)
+end CutAddition
+
+theorem cut_add_reduces (x y : ℝ) : Reduces (cut (x+y)) (join (cut x) (cut y)) := by
+  by_cases hxy : Irrational (x+y)
+  · exact CutAddition.irrational_add_reduces x y hxy
+  · obtain ⟨q,hq⟩ := not_not.mp hxy
+    rw [←hq]
+    exact rational_cut_reduces q _
+
+end TuringRigidity
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/CutArithmetic.lean

@@ -0,0 +1,82 @@
+import OAI.Computability.DegreeRigidity.Computability.CutAddition
+import OAI.Computability.DegreeRigidity.Computability.ScalarCoding
+import OAI.Computability.DegreeRigidity.Representation.Assembly
+
+namespace OAI
+
+namespace TuringRigidity
+open RationalCoding UniformOracle
+
+theorem cut_smul_reduces (r : ℚ) (x : ℝ) : Reduces (cut ((r : ℝ)*x)) (cut x) := by
+  by_cases hr : r=0
+  · subst r
+    simpa using rational_cut_reduces (0 : ℚ) (cut x)
+  by_cases ht : Irrational ((r : ℝ)*x)
+  swap
+  · obtain ⟨q,hq⟩ := not_not.mp ht
+    rw [←hq]
+    exact rational_cut_reduces q _
+  have hq : Nat.RecursiveIn {oracleFunction (cut x)} (oracleFunction (cut x)) :=
+    .oracle _ (Set.mem_singleton _)
+  have hread := Nat.RecursiveIn.comp hq (divideIndex_recursive (O := {oracleFunction (cut x)}) r hr)
+  apply RecursiveIn.iff_nat.mpr
+  by_cases hpos : 0<r
+  · have hpos' : (0 : ℝ)<r := by exact_mod_cast hpos
+    apply hread.of_eq
+    intro n
+    change (Part.some (divideIndex r n)).bind
+      (fun input => Part.some (if cut x input then 1 else 0)) =
+      oracleFunction (cut ((r : ℝ)*x)) n
+    rw [Part.bind_some]
+    have hiff : cut x (divideIndex r n)=true ↔ cut ((r : ℝ)*x) n=true := by
+      rw [cut_eq_true,cut_eq_true,divideIndex_value,Rat.cast_div]
+      simpa only [mul_comm] using (div_lt_iff₀ hpos' :
+        (rationalEnumeration n : ℝ)/(r : ℝ)<x ↔ (rationalEnumeration n : ℝ)<x*(r : ℝ))
+    have heq : cut x (divideIndex r n)=cut ((r : ℝ)*x) n := Bool.eq_iff_iff.mpr hiff
+    simp only [oracleFunction,heq]
+  · have hneg : r<0 := (lt_or_gt_of_ne hr).resolve_right hpos
+    have hneg' : (r : ℝ)<0 := by exact_mod_cast hneg
+    have hc : Primrec (fun b : ℕ => if b=0 then 1 else 0) :=
+      Primrec.ite (Primrec.eq.comp Primrec.id (Primrec.const 0)) (Primrec.const 1) (Primrec.const 0)
+    apply (Nat.RecursiveIn.comp (total_primrec hc) hread).of_eq
+    intro n
+    change ((Part.some (divideIndex r n)).bind
+      (fun input => Part.some (if cut x input then 1 else 0))).bind
+      (fun value => Part.some (if value = 0 then 1 else 0)) =
+      oracleFunction (cut ((r : ℝ)*x)) n
+    simp only [Part.bind_some]
+    have hiff : cut x (divideIndex r n)=true ↔ (r : ℝ)*x<(rationalEnumeration n : ℝ) := by
+      rw [cut_eq_true,divideIndex_value,Rat.cast_div]
+      simpa only [mul_comm] using (div_lt_iff_of_neg hneg' :
+        (rationalEnumeration n : ℝ)/(r : ℝ)<x ↔ x*(r : ℝ)<(rationalEnumeration n : ℝ))
+    have hneq : (rationalEnumeration n : ℝ) ≠ (r : ℝ)*x :=
+      fun h => ht ⟨rationalEnumeration n,h⟩
+    by_cases hin : cut x (divideIndex r n)=true
+    · have hout : cut ((r : ℝ)*x) n=false := Bool.eq_false_iff.mpr
+        (fun h => (not_lt_of_gt (hiff.mp hin)) ((cut_eq_true _ _).mp h))
+      simp [hin,hout,oracleFunction]
+    · have hle : (rationalEnumeration n : ℝ) ≤ (r : ℝ)*x :=
+        le_of_not_gt (fun h => hin (hiff.mpr h))
+      have hout : cut ((r : ℝ)*x) n=true := (cut_eq_true _ _).mpr
+        ((lt_or_eq_of_le hle).resolve_right hneq)
+      have hin' := Bool.eq_false_iff.mpr hin
+      simp [hin',hout,oracleFunction]
+
+theorem cut_sub_reduces (x y : ℝ) : Reduces (cut (x-y)) (join (cut x) (cut y)) := by
+  have hy : Reduces (cut (-y)) (cut y) := by simpa using cut_smul_reduces (-1 : ℚ) y
+  have h := reduces_trans (cut_add_reduces x (-y)) (join_mono (reduces_refl (cut x)) hy)
+  simpa only [sub_eq_add_neg] using h
+
+theorem cut_translate_reduces (x : ℝ) (q : ℚ) : Reduces (cut (x+(q : ℝ))) (cut x) :=
+  reduces_trans (cut_add_reduces x q)
+    (join_reduces (reduces_refl (cut x)) (rational_cut_reduces q (cut x)))
+
+theorem cut_arithmetic : CutArithmetic where
+  add := cut_add_reduces
+  sub := cut_sub_reduces
+  smul := cut_smul_reduces
+  translate := cut_translate_reduces
+
+end TuringRigidity
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/CutTranscript.lean

@@ -0,0 +1,102 @@
+import OAI.Computability.DegreeRigidity.Effective.FiniteTranscript
+import OAI.Computability.DegreeRigidity.Computability.Cuts
+import OAI.Computability.DegreeRigidity.Computability.Joins
+
+namespace OAI
+
+open Set
+namespace TuringRigidity
+
+theorem cut_prefix_left (x : ℝ) (m : ℕ) :
+    ∃ l : ℝ, l < x ∧ ∀ y, l < y → y ≤ x → ∀ k, k < m → cut y k = cut x k := by
+  induction m with
+  | zero => exact ⟨x-1, by linarith, by simp⟩
+  | succ m ih =>
+    obtain ⟨l,hl,he⟩ := ih
+    by_cases hq : (rationalEnumeration m : ℝ) < x
+    · refine ⟨max l (rationalEnumeration m), max_lt hl hq, ?_⟩
+      intro y hy hyx k hk
+      rcases Nat.lt_succ_iff_lt_or_eq.mp hk with hk | hk
+      · exact he y ((le_max_left _ _).trans_lt hy) hyx k hk
+      · subst k
+        have hqy := (le_max_right l (rationalEnumeration m : ℝ)).trans_lt hy
+        simp [cut, hq, hqy]
+    · refine ⟨l,hl,?_⟩
+      intro y hy hyx k hk
+      rcases Nat.lt_succ_iff_lt_or_eq.mp hk with hk | hk
+      · exact he y hy hyx k hk
+      · subst k
+        have hqy : ¬ (rationalEnumeration m : ℝ) < y :=
+          not_lt.mpr (hyx.trans (not_lt.mp hq))
+        simp [cut,hq,hqy]
+
+namespace CategorySearch
+
+noncomputable def pairOracle (A : Oracle) (p : ℝ × ℝ) : Oracle := join (join A (cut p.1)) (cut p.2)
+noncomputable def value (A : Oracle) (p : ℝ × ℝ) (k : ℕ) : ℕ := if pairOracle A p k then 1 else 0
+
+theorem value_prefix (A : Oracle) (p q : ℝ × ℝ) (m : ℕ)
+    (h1 : ∀ k, k < m → cut q.1 k = cut p.1 k)
+    (h2 : ∀ k, k < m → cut q.2 k = cut p.2 k) :
+    ∀ k, k < m → value A q k = value A p k := by
+  intro k hk
+  apply congrArg (fun b : Bool => if b then (1 : ℕ) else 0)
+  have hk2 : k/2 < m := by omega
+  have hk4 : k/2/2 < m := by omega
+  simp only [pairOracle,join,h1 _ hk4,h2 _ hk2]
+
+theorem halting_left (A : Oracle) (c : OracleCode) (p : ℝ × ℝ) (n a : ℕ)
+    (ha : a ∈ OracleCode.eval (oracleFunction (pairOracle A p)) c n) :
+    ∃ l : ℝ × ℝ, l.1 < p.1 ∧ l.2 < p.2 ∧
+      ∀ q : ℝ × ℝ, l.1 < q.1 → q.1 ≤ p.1 → l.2 < q.2 → q.2 ≤ p.2 →
+        a ∈ OracleCode.eval (oracleFunction (pairOracle A q)) c n := by
+  obtain ⟨m,hm⟩ := OracleCode.eval_total_stable (value A p) c n a ha
+  obtain ⟨l1,h1,he1⟩ := cut_prefix_left p.1 m
+  obtain ⟨l2,h2,he2⟩ := cut_prefix_left p.2 m
+  refine ⟨(l1,l2),h1,h2,?_⟩
+  intro q hq1 hq1' hq2 hq2'
+  exact hm (value A q) (value_prefix A p q m (he1 _ hq1 hq1') (he2 _ hq2 hq2'))
+
+def rectangle (l r : ℚ × ℚ) : Set (ℝ × ℝ) :=
+  Ioo (l.1 : ℝ) (r.1 : ℝ) ×ˢ Ioo (l.2 : ℝ) (r.2 : ℝ)
+
+def success (A Y : Oracle) (c : OracleCode) : Set (ℝ × ℝ) :=
+  {p | OracleCode.eval (oracleFunction (pairOracle A p)) c = oracleFunction Y}
+
+theorem dense_sound (A Y : Oracle) (c : OracleCode) (l r : ℚ × ℚ)
+    (hd : rectangle l r ⊆ closure (success A Y c)) (p : ℝ × ℝ)
+    (hp : p ∈ rectangle l r) (n a : ℕ)
+    (ha : a ∈ OracleCode.eval (oracleFunction (pairOracle A p)) c n) :
+    a = if Y n then 1 else 0 := by
+  obtain ⟨b,hb1,hb2,he⟩ := halting_left A c p n a ha
+  let U : Set (ℝ × ℝ) := Ioo (max b.1 (l.1 : ℝ)) p.1 ×ˢ Ioo (max b.2 (l.2 : ℝ)) p.2
+  have hU : IsOpen U := isOpen_Ioo.prod isOpen_Ioo
+  have hne : U.Nonempty :=
+    (nonempty_Ioo.mpr (max_lt hb1 hp.1.1)).prod (nonempty_Ioo.mpr (max_lt hb2 hp.2.1))
+  have hsub : U ⊆ rectangle l r := by
+    intro q hq
+    exact ⟨⟨(le_max_right _ _).trans_lt hq.1.1,hq.1.2.trans hp.1.2⟩,
+      ⟨(le_max_right _ _).trans_lt hq.2.1,hq.2.2.trans hp.2.2⟩⟩
+  obtain ⟨q,hq⟩ := hne
+  obtain ⟨z,hzU,hzS⟩ := mem_closure_iff.mp (hd (hsub hq)) U hU hq
+  have hz := he z ((le_max_left _ _).trans_lt hzU.1.1) hzU.1.2.le
+    ((le_max_left _ _).trans_lt hzU.2.1) hzU.2.2.le
+  rw [hzS] at hz
+  exact Part.mem_some_iff.mp hz
+
+theorem rational_halting (A : Oracle) (c : OracleCode) (l r : ℚ × ℚ)
+    (p : ℝ × ℝ) (hp : p ∈ rectangle l r) (n a : ℕ)
+    (ha : a ∈ OracleCode.eval (oracleFunction (pairOracle A p)) c n) :
+    ∃ q : ℚ × ℚ, ((q.1 : ℝ),(q.2 : ℝ)) ∈ rectangle l r ∧
+      a ∈ OracleCode.eval (oracleFunction (pairOracle A ((q.1 : ℝ),(q.2 : ℝ)))) c n := by
+  obtain ⟨b,hb1,hb2,he⟩ := halting_left A c p n a ha
+  obtain ⟨u,hu1,hu2⟩ := exists_rat_btwn (max_lt hb1 hp.1.1)
+  obtain ⟨v,hv1,hv2⟩ := exists_rat_btwn (max_lt hb2 hp.2.1)
+  exact ⟨(u,v),⟨⟨(le_max_right _ _).trans_lt hu1,hu2.trans hp.1.2⟩,
+    ⟨(le_max_right _ _).trans_lt hv1,hv2.trans hp.2.2⟩⟩,
+    he _ ((le_max_left _ _).trans_lt hu1) hu2.le ((le_max_left _ _).trans_lt hv1) hv2.le⟩
+
+end CategorySearch
+end TuringRigidity
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/Cuts.lean

@@ -0,0 +1,63 @@
+import OAI.Computability.DegreeRigidity.Computability.OracleCode
+import OAI.Computability.DegreeRigidity.Representation.Category
+import Mathlib.MeasureTheory.Constructions.BorelSpace.Real
+
+namespace OAI
+
+open Set Filter Topology
+namespace TuringRigidity
+
+def rationalEnumeration (n : ℕ) : ℚ := (Encodable.decode (α := ℚ) n).getD 0
+
+theorem rationalEnumeration_surjective : Function.Surjective rationalEnumeration := by
+  intro q
+  refine ⟨Encodable.encode q, ?_⟩
+  simp [rationalEnumeration]
+
+noncomputable def cut (x : ℝ) : Oracle := fun n => decide ((rationalEnumeration n : ℝ) < x)
+
+@[simp] theorem cut_eq_true (x : ℝ) (n : ℕ) :
+    cut x n = true ↔ (rationalEnumeration n : ℝ) < x := by simp [cut]
+
+theorem cut_injective : Function.Injective cut := by
+  intro x y hxy
+  apply le_antisymm
+  · by_contra h
+    have hyx : y < x := lt_of_not_ge h
+    obtain ⟨q, hyq, hqx⟩ := exists_rat_btwn hyx
+    obtain ⟨n, hn⟩ := rationalEnumeration_surjective q
+    have hc : cut x n = true := (cut_eq_true x n).mpr (by simpa [hn] using hqx)
+    rw [hxy] at hc
+    have hqy := (cut_eq_true y n).mp hc
+    rw [hn] at hqy
+    exact (not_lt_of_gt hyq) hqy
+  · by_contra h
+    have hxy' : x < y := lt_of_not_ge h
+    obtain ⟨q, hxq, hqy⟩ := exists_rat_btwn hxy'
+    obtain ⟨n, hn⟩ := rationalEnumeration_surjective q
+    have hc : cut y n = true := (cut_eq_true y n).mpr (by simpa [hn] using hqy)
+    rw [← hxy] at hc
+    have hqx := (cut_eq_true x n).mp hc
+    rw [hn] at hqx
+    exact (not_lt_of_gt hxq) hqx
+
+theorem cut_measurable : Measurable cut := by
+  apply Measurable.of_eval
+  intro n
+  have h : MeasurableSet {x : ℝ | (rationalEnumeration n : ℝ) < x} := measurableSet_Ioi
+  have hm : Measurable (fun x : ℝ => if (rationalEnumeration n : ℝ) < x then true else false) :=
+    Measurable.ite h measurable_const measurable_const
+  convert hm using 1
+  funext x
+  by_cases hq : (rationalEnumeration n : ℝ) < x <;> simp [cut, hq]
+
+noncomputable def realDegree (x : ℝ) : Degree := degree (cut x)
+
+theorem represented_real_map_countable_fibers (π : Degree ≃o Degree) (F : ℝ → Oracle)
+    (hF : ∀ x, degree (F x) = π (realDegree x)) :
+    ∀ B : Oracle, {x : ℝ | F x = B}.Countable := by
+  exact countable_lift_fiber cut cut_injective π π.injective F hF
+
+end TuringRigidity
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/DegreeCoverage.lean

@@ -0,0 +1,52 @@
+import OAI.Computability.DegreeRigidity.Computability.BinaryCut
+import OAI.Computability.DegreeRigidity.Computability.BinaryRecovery
+import OAI.Computability.DegreeRigidity.Representation.Assembly
+
+namespace OAI
+
+namespace TuringRigidity
+namespace BinarySeries
+
+theorem value_eq_series (B : Oracle) :
+    value B = ∑' n, (bit B n : ℝ) * (2^(n+1) : ℝ)⁻¹ := rfl
+
+theorem irrational_of_noncomputable (B : Oracle) (h : ¬ Reduces B (fun _ => false)) :
+    Irrational (value B) := by
+  intro ⟨q,hq⟩
+  apply h
+  have hr := set_reduces_cut B (mixed_of_noncomputable B h)
+  rw [←hq] at hr
+  exact reduces_trans hr (rational_cut_reduces q _)
+
+theorem rational_series_reduces (B A : Oracle) (q : ℚ) (hq : (q : ℝ) = value B) :
+    Reduces B A := by
+  by_contra h
+  have hn : ¬ Reduces B (fun _ => false) := by
+    intro hh
+    exact h (reduces_trans hh (eventually_constant_reduces (fun _ => false) A false 0 (by simp)))
+  exact irrational_of_noncomputable B hn ⟨q,hq⟩
+
+theorem noncomputable_series (B : Oracle) (h : ¬ Reduces B (fun _ => false)) :
+    Irrational (value B) ∧ 0 < value B ∧ value B < 1 ∧
+      Reduces (cut (value B)) B ∧ Reduces B (cut (value B)) := by
+  have hm := mixed_of_noncomputable B h
+  have hi := irrational_of_noncomputable B h
+  refine ⟨hi,positive B ?_,lt_one B ?_,cut_reduces B hi,set_reduces_cut B hm⟩
+  · obtain ⟨n,_,hn⟩ := (hm 0).1
+    exact ⟨n,hn⟩
+  · obtain ⟨n,_,hn⟩ := (hm 0).2
+    exact ⟨n,hn⟩
+end BinarySeries
+
+theorem irrational_degree_coverage : IrrationalDegreeCoverage := by
+  intro a ha
+  obtain ⟨B,rfl⟩ := degree_surjective a
+  have hn : ¬ Reduces B (fun _ => false) := by
+    intro h
+    exact ha (le_antisymm h bot_le)
+  obtain ⟨hi,h0,h1,hforward,hback⟩ := BinarySeries.noncomputable_series B hn
+  exact ⟨BinarySeries.value B,hi,h0,h1,(degree_eq_iff _ _).mpr ⟨hforward,hback⟩⟩
+
+end TuringRigidity
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/EffectiveRecovery.lean

@@ -0,0 +1,223 @@
+import OAI.Computability.DegreeRigidity.Computability.RationalCoding
+import OAI.Computability.DegreeRigidity.Computability.BranchFrequency
+
+namespace OAI
+
+namespace TuringRigidity
+
+namespace EffectiveRecovery
+open RationalCoding
+
+def window (A B : ℕ) (z : Bool × (ℕ × ℕ) × (ℕ × ℕ)) : Option ℕ :=
+  if z.1 then some 1 else
+  if z.2.1.1*z.2.2.1*A + z.2.1.2*B < z.2.1.2*z.2.2.2*A then some 1 else
+  if z.2.1.2*(z.2.2.2*A+B) < z.2.1.1*z.2.2.1*A then some 0 else none
+
+theorem window_primrec (A B : ℕ) : Primrec (window A B) := by
+  let Q := Primrec.fst.comp (Primrec.fst.comp Primrec.snd) (α := Bool × (ℕ × ℕ) × (ℕ × ℕ))
+  let D := Primrec.snd.comp (Primrec.fst.comp Primrec.snd) (α := Bool × (ℕ × ℕ) × (ℕ × ℕ))
+  let N := Primrec.fst.comp (Primrec.snd.comp Primrec.snd) (α := Bool × (ℕ × ℕ) × (ℕ × ℕ))
+  let S := Primrec.snd.comp (Primrec.snd.comp Primrec.snd) (α := Bool × (ℕ × ℕ) × (ℕ × ℕ))
+  exact Primrec.ite (Primrec.eq.comp Primrec.fst (Primrec.const true)) (Primrec.const (some 1))
+    (Primrec.ite (Primrec.nat_lt.comp
+      (Primrec.nat_add.comp (Primrec.nat_mul.comp (Primrec.nat_mul.comp Q N) (Primrec.const A))
+        (Primrec.nat_mul.comp D (Primrec.const B)))
+      (Primrec.nat_mul.comp (Primrec.nat_mul.comp D S) (Primrec.const A)))
+      (Primrec.const (some 1))
+      (Primrec.ite (Primrec.nat_lt.comp
+        (Primrec.nat_mul.comp D (Primrec.nat_add.comp
+          (Primrec.nat_mul.comp S (Primrec.const A)) (Primrec.const B)))
+        (Primrec.nat_mul.comp (Primrec.nat_mul.comp Q N) (Primrec.const A)))
+        (Primrec.const (some 0)) (Primrec.const none)))
+
+theorem lower_iff (Q D N S A B : ℕ) (hD : 0 < D) (hN : 0 < N) (hA : 0 < A) :
+    (Q : ℝ)/D < (S : ℝ)/N - (B : ℝ)/(N*A) ↔ Q*N*A+D*B < D*S*A := by
+  have hd : (0 : ℝ) < D := by exact_mod_cast hD
+  have hn : (0 : ℝ) < N := by exact_mod_cast hN
+  have ha : (0 : ℝ) < A := by exact_mod_cast hA
+  have hden : (0 : ℝ) < D*N*A := mul_pos (mul_pos hd hn) ha
+  have he : ((S : ℝ)/N - (B : ℝ)/(N*A) - (Q : ℝ)/D) * (D*N*A) =
+      (D : ℝ)*S*A - ((Q : ℝ)*N*A+D*B) := by
+    field_simp
+    ring
+  constructor
+  · intro h
+    have hp := mul_pos (sub_pos.mpr h) hden
+    rw [he] at hp
+    exact_mod_cast sub_pos.mp hp
+  · intro h
+    have hr : (Q : ℝ)*N*A+D*B < (D : ℝ)*S*A := by exact_mod_cast h
+    have hp : 0 < ((S : ℝ)/N - (B : ℝ)/(N*A) - (Q : ℝ)/D) * (D*N*A) := by
+      rw [he]; linarith
+    exact sub_pos.mp ((mul_pos_iff_of_pos_right hden).mp hp)
+
+theorem upper_iff (Q D N S A B : ℕ) (hD : 0 < D) (hN : 0 < N) (hA : 0 < A) :
+    (S : ℝ)/N + (B : ℝ)/(N*A) < (Q : ℝ)/D ↔ D*(S*A+B) < Q*N*A := by
+  have hd : (0 : ℝ) < D := by exact_mod_cast hD
+  have hn : (0 : ℝ) < N := by exact_mod_cast hN
+  have ha : (0 : ℝ) < A := by exact_mod_cast hA
+  have hden : (0 : ℝ) < D*N*A := mul_pos (mul_pos hd hn) ha
+  have he : ((Q : ℝ)/D - ((S : ℝ)/N + (B : ℝ)/(N*A))) * (D*N*A) =
+      (Q : ℝ)*N*A - (D : ℝ)*(S*A+B) := by
+    field_simp
+  constructor
+  · intro h
+    have hp := mul_pos (sub_pos.mpr h) hden
+    rw [he] at hp
+    exact_mod_cast sub_pos.mp hp
+  · intro h
+    have hr : (D : ℝ)*(S*A+B) < (Q : ℝ)*N*A := by exact_mod_cast h
+    have hp : 0 < ((Q : ℝ)/D - ((S : ℝ)/N + (B : ℝ)/(N*A))) * (D*N*A) := by
+      rw [he]; linarith
+    exact sub_pos.mp ((mul_pos_iff_of_pos_right hden).mp hp)
+end EffectiveRecovery
+
+namespace RecoveryData
+open RationalCoding EffectiveRecovery
+variable {F : ℝ → Oracle} {t u v : ℝ}
+
+theorem delta_numerator_pos (d : RecoveryData F t u v) : 0 < d.delta.num.natAbs := by
+  have hn : 0 < d.delta.num := Rat.num_pos.mpr d.delta_pos
+  have he : (d.delta.num.natAbs : ℤ) = d.delta.num := by
+    rw [Int.natCast_natAbs,abs_of_pos hn]
+  rw [←he] at hn
+  exact_mod_cast hn
+
+theorem delta_fraction (d : RecoveryData F t u v) :
+    (d.delta : ℝ) = (d.delta.num.natAbs : ℝ)/(d.delta.den : ℝ) := by
+  have hn : 0 < d.delta.num := Rat.num_pos.mpr d.delta_pos
+  have he : (d.delta.num.natAbs : ℤ) = d.delta.num := by
+    rw [Int.natCast_natAbs,abs_of_pos hn]
+  have he' : (d.delta.num.natAbs : ℝ) = (d.delta.num : ℝ) := by
+    simpa only [Int.cast_natCast] using congrArg (fun z : ℤ => (z : ℝ)) he
+  rw [Rat.cast_def,he']
+
+theorem radius_fraction (d : RecoveryData F t u v) (N : ℕ) (hN : 0 < N) :
+    1/((N : ℝ)*(d.delta : ℝ)) = (d.delta.den : ℝ)/((N : ℝ)*d.delta.num.natAbs) := by
+  have hn : (0 : ℝ) < N := by exact_mod_cast hN
+  have ha : (0 : ℝ) < d.delta.num.natAbs := by exact_mod_cast d.delta_numerator_pos
+  have hb : (0 : ℝ) < d.delta.den := by exact_mod_cast d.delta.den_pos
+  rw [d.delta_fraction]
+  field_simp
+
+def cutTrial (d : RecoveryData F t u v) (i m : ℕ) : Option ℕ :=
+  window d.delta.num.natAbs d.delta.den
+    (negative i,(numeratorMagnitude i,denominator i),(m+1,d.count (m+1)))
+
+theorem cutTrial_recursive (d : RecoveryData F t u v) (ht0 : 0 < t) (ht1 : t < 1) :
+    Nat.RecursiveIn {oracleFunction (fourTuple F t u v d.delta)}
+      (fun z => Part.some (Encodable.encode (d.cutTrial (Nat.unpair z).1 (Nat.unpair z).2))) := by
+  let O : Set (ℕ →. ℕ) := {oracleFunction (fourTuple F t u v d.delta)}
+  have hq := UniformOracle.total_primrec (O := O) (Primrec.fst.comp Primrec.unpair)
+  have hN := UniformOracle.total_primrec (O := O) (Primrec.succ.comp (Primrec.snd.comp Primrec.unpair))
+  have hS := UniformOracle.total_comp (d.count_recursive ht0 ht1) hN
+  have hwindow : Primrec (fun z : ℕ => Encodable.encode
+      (window d.delta.num.natAbs d.delta.den
+        (negative (Nat.unpair z).1,
+          (numeratorMagnitude (Nat.unpair z).1,denominator (Nat.unpair z).1),
+          ((Nat.unpair (Nat.unpair z).2).1,(Nat.unpair (Nat.unpair z).2).2)))) :=
+    Primrec.encode.comp ((window_primrec _ _).comp
+      ((negative_primrec.comp (Primrec.fst.comp Primrec.unpair)).pair
+        (((numeratorMagnitude_primrec.comp (Primrec.fst.comp Primrec.unpair)).pair
+          (denominator_primrec.comp (Primrec.fst.comp Primrec.unpair))).pair
+            (Primrec.unpair.comp (Primrec.snd.comp Primrec.unpair)))))
+  exact (UniformOracle.total_comp (UniformOracle.total_primrec hwindow)
+    (UniformOracle.total_pair hq (UniformOracle.total_pair hN hS))).of_eq
+      (fun z => by simp [cutTrial])
+
+theorem cutTrial_sound (d : RecoveryData F t u v) (ht0 : 0 < t) (ht1 : t < 1)
+    (i m r : ℕ) (hr : r ∈ d.cutTrial i m) : r = if cut t i then 1 else 0 := by
+  have hn : 0 < m+1 := Nat.succ_pos m
+  have he := d.count_frequency_bound ht0 ht1 (m+1) hn
+  rw [d.radius_fraction (m+1) hn] at he
+  unfold cutTrial window at hr
+  split at hr
+  · rename_i hneg
+    have hr' : r=1 := by symm; simpa using hr
+    subst r
+    have hq : (rationalEnumeration i : ℝ) ≤ 0 := by
+      rw [query_value,ite_eq_left hneg]
+      exact div_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr (Nat.cast_nonneg _)) (Nat.cast_nonneg _)
+    have hc : cut t i = true := (cut_eq_true t i).mpr (hq.trans_lt ht0)
+    simp [hc]
+  · rename_i hneg
+    have hq : (rationalEnumeration i : ℝ) = (numeratorMagnitude i : ℝ)/(denominator i : ℝ) := by
+      rw [query_value,ite_eq_right hneg]
+    split at hr
+    · rename_i hl
+      have hr' : r=1 := by symm; simpa using hr
+      subst r
+      have hl' := (lower_iff (numeratorMagnitude i) (denominator i) (m+1) (d.count (m+1))
+        d.delta.num.natAbs d.delta.den (denominator_pos i) hn d.delta_numerator_pos).mpr hl
+      rw [←hq] at hl'
+      have hh := (abs_lt.mp he).1
+      have hc : cut t i = true := (cut_eq_true t i).mpr (by linarith)
+      simp [hc]
+    · split at hr
+      · rename_i hu
+        have hr' : r=0 := by symm; simpa using hr
+        subst r
+        have hu' := (upper_iff (numeratorMagnitude i) (denominator i) (m+1) (d.count (m+1))
+          d.delta.num.natAbs d.delta.den (denominator_pos i) hn d.delta_numerator_pos).mpr hu
+        rw [←hq] at hu'
+        have hh := (abs_lt.mp he).2
+        have htq : t < (rationalEnumeration i : ℝ) := by linarith
+        have hc : cut t i = false := Bool.eq_false_iff.mpr
+          (fun h => (not_lt_of_gt htq) ((cut_eq_true t i).mp h))
+        simp [hc]
+      · simp at hr
+
+theorem cutTrial_complete (d : RecoveryData F t u v) (ht : Irrational t)
+    (ht0 : 0 < t) (ht1 : t < 1) (i : ℕ) : ∃ m r, r ∈ d.cutTrial i m := by
+  by_cases hneg : negative i = true
+  · exact ⟨0,1,by simp [cutTrial,window,hneg]⟩
+  · have hq : (rationalEnumeration i : ℝ) = (numeratorMagnitude i : ℝ)/(denominator i : ℝ) := by
+      rw [query_value,ite_eq_right hneg]
+    have hne : (rationalEnumeration i : ℝ) ≠ t := fun h => ht ⟨rationalEnumeration i,h⟩
+    obtain ⟨⟨N,hN,hs⟩,_⟩ := comparison_search t (d.delta : ℝ)
+      (fun n => (d.count n : ℝ)/(n : ℝ)) (by exact_mod_cast d.delta_pos)
+      (fun n hn => d.count_frequency_bound ht0 ht1 n hn) (rationalEnumeration i) hne
+    rw [d.radius_fraction N hN,hq] at hs
+    have hm : N-1+1=N := by omega
+    rcases hs with hl | hu
+    · have hl' := (lower_iff (numeratorMagnitude i) (denominator i) N (d.count N)
+        d.delta.num.natAbs d.delta.den (denominator_pos i) hN d.delta_numerator_pos).mp hl
+      exact ⟨N-1,1,by simp [cutTrial,hm,window,hneg,hl']⟩
+    · have hu' := (upper_iff (numeratorMagnitude i) (denominator i) N (d.count N)
+        d.delta.num.natAbs d.delta.den (denominator_pos i) hN d.delta_numerator_pos).mp hu
+      by_cases hl' : numeratorMagnitude i*N*d.delta.num.natAbs+denominator i*d.delta.den <
+          denominator i*d.count N*d.delta.num.natAbs
+      · exact ⟨N-1,1,by simp [cutTrial,hm,window,hneg,hl']⟩
+      · exact ⟨N-1,0,by simp [cutTrial,hm,window,hneg,hl',hu']⟩
+
+theorem cut_reduces (d : RecoveryData F t u v) (ht : Irrational t)
+    (ht0 : 0 < t) (ht1 : t < 1) : Reduces (cut t) (fourTuple F t u v d.delta) := by
+  apply RecursiveIn.iff_nat.mpr
+  exact UniformOracle.total_search (d.cutTrial_recursive ht0 ht1)
+    (fun i => if cut t i then 1 else 0) (d.cutTrial_sound ht0 ht1)
+      (d.cutTrial_complete ht ht0 ht1)
+
+theorem cut_single_program (d : RecoveryData F t u v) (ht : Irrational t)
+    (ht0 : 0 < t) (ht1 : t < 1) :
+    ∃ c : OracleCode, OracleCode.eval (oracleFunction (fourTuple F t u v d.delta)) c =
+      oracleFunction (cut t) :=
+  (OracleCode.turingReducible_iff_exists_code _ _).mp (d.cut_reduces ht ht0 ht1)
+
+end RecoveryData
+
+theorem four_value_recovery : FourValueRecovery := by
+  intro F hF hfiber hadd t ht ht0 ht1
+  obtain ⟨G,hG,hdata⟩ := recovery_data_exists F hF hfiber hadd t
+  refine ⟨G,hG,?_⟩
+  intro p hp
+  obtain ⟨d⟩ := hdata p hp
+  refine ⟨d.delta,d.delta_pos,?_,d.cut_reduces ht ht0 ht1⟩
+  exact_mod_cast d.delta_lt.trans d.radius_lt_one
+
+theorem main_of_remaining_obligations (hrep : BorelRepresentation) (harith : CutArithmetic)
+    (hcover : IrrationalDegreeCoverage) (havoid : CategoryAvoidance) : MainTheorem :=
+  main_of_obligations hrep harith hcover four_value_recovery havoid
+
+end TuringRigidity
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/Introreducible.lean

@@ -0,0 +1,159 @@
+import OAI.Computability.DegreeRigidity.Effective.PrefixComputability
+import Mathlib.Data.Set.Finite.Range
+import Lean.Elab.Tactic.Omega
+
+namespace OAI
+
+namespace TuringRigidity
+namespace Introreducible
+open Encodable PrefixComputability
+
+def bit (X : Oracle) (n : ℕ) : ℕ := if X n then 1 else 0
+
+def prefixCode (X : Oracle) (n : ℕ) : ℕ := encode (oraclePrefix (bit X) n)
+
+def codeList (c : ℕ) : List ℕ := (decode (α := List ℕ) c).getD []
+def codeLength (c : ℕ) : ℕ := (codeList c).length
+
+def prefixSet (X : Oracle) (c : ℕ) : Bool := decide (prefixCode X (codeLength c) = c)
+
+@[simp] theorem codeList_prefix (X : Oracle) (n : ℕ) :
+    codeList (prefixCode X n) = oraclePrefix (bit X) n := by
+  simp [codeList, prefixCode]
+
+@[simp] theorem codeLength_prefix (X : Oracle) (n : ℕ) :
+    codeLength (prefixCode X n) = n := by
+  simp [codeLength, oraclePrefix]
+
+@[simp] theorem prefixSet_prefix (X : Oracle) (n : ℕ) :
+    prefixSet X (prefixCode X n) = true := by
+  simp [prefixSet]
+
+theorem prefixCode_injective (X : Oracle) : Function.Injective (prefixCode X) := by
+  intro n m h
+  simpa using congrArg codeLength h
+
+theorem prefixSet_infinite (X : Oracle) : {c | prefixSet X c = true}.Infinite := by
+  apply (Set.infinite_range_of_injective (prefixCode_injective X)).mono
+  rintro _ ⟨n, rfl⟩
+  exact prefixSet_prefix X n
+
+theorem subset_unbounded {X Z : Oracle}
+    (hsub : ∀ c, Z c = true → prefixSet X c = true)
+    (hinf : {c | Z c = true}.Infinite) (n : ℕ) :
+    ∃ c, Z c = true ∧ n < codeLength c := by
+  by_contra h
+  have hb : ∀ c, Z c = true → codeLength c ≤ n := by
+    intro c hc
+    by_contra hn
+    exact h ⟨c, hc, Nat.lt_of_not_ge hn⟩
+  apply hinf
+  apply ((Set.finite_le_nat n).image (prefixCode X)).subset
+  intro c hc
+  have he := of_decide_eq_true (hsub c hc)
+  exact ⟨codeLength c, hb c hc, he⟩
+
+theorem codeList_primrec : Primrec codeList :=
+  Primrec.option_getD_default.comp Primrec.decode
+
+theorem codeLength_primrec : Primrec codeLength :=
+  Primrec.list_length.comp codeList_primrec
+
+private def equalBit (c : ℕ) : ℕ :=
+  if (Nat.unpair c).1 = (Nat.unpair c).2 then 1 else 0
+
+private theorem equalBit_primrec : Primrec equalBit := by
+  apply (Primrec.ite (Primrec.eq.comp (Primrec.fst.comp Primrec.unpair)
+    (Primrec.snd.comp Primrec.unpair)) (Primrec.const 1) (Primrec.const 0)).of_eq
+  intro n
+  simp [equalBit]
+
+theorem prefixSet_reduces (X : Oracle) : Reduces (prefixSet X) X := by
+  apply RecursiveIn.iff_nat.mpr
+  have hp := total_comp (prefix_recursive (bit X)) (total_primrec codeLength_primrec)
+  have he := total_comp (total_primrec equalBit_primrec)
+    (total_pair hp (total_primrec Primrec.id))
+  apply he.of_eq
+  intro n
+  by_cases h : encode (oraclePrefix (bit X) (codeLength n)) = n
+  · simp [oracleFunction, prefixSet, equalBit, prefixCode, h]
+  · simp [oracleFunction, prefixSet, equalBit, prefixCode, h]
+
+def codeBit (n c : ℕ) : ℕ := (codeList c).getD n 0
+
+@[simp] theorem codeBit_prefix (X : Oracle) (n m : ℕ) (h : n < m) :
+    codeBit n (prefixCode X m) = bit X n := by
+  simp [codeBit, oraclePrefix, List.getD_eq_getElem?_getD, List.getElem?_range h]
+
+theorem codeBit_primrec : Primrec₂ codeBit :=
+  (Primrec.list_getD 0).comp (codeList_primrec.comp Primrec.snd) Primrec.fst
+
+def trial (Z : Oracle) (n c : ℕ) : Option ℕ :=
+  if Z c = true ∧ n < codeLength c then some (codeBit n c) else none
+
+private def trialStep (p : ℕ) : ℕ :=
+  let n := (Nat.unpair p).1
+  let c := (Nat.unpair (Nat.unpair p).2).1
+  let b := (Nat.unpair (Nat.unpair p).2).2
+  encode (if b = 1 ∧ n < codeLength c then some (codeBit n c) else none)
+
+private theorem trialStep_primrec : Primrec trialStep := by
+  let hn := Primrec.fst.comp Primrec.unpair
+  let hc := Primrec.fst.comp (Primrec.unpair.comp (Primrec.snd.comp Primrec.unpair))
+  let hb := Primrec.snd.comp (Primrec.unpair.comp (Primrec.snd.comp Primrec.unpair))
+  apply (Primrec.encode.comp (Primrec.ite
+    ((Primrec.eq.comp hb (Primrec.const 1)).and
+      (Primrec.nat_lt.comp hn (codeLength_primrec.comp hc)))
+    (Primrec.option_some.comp (codeBit_primrec.comp hn hc)) (Primrec.const none))).of_eq
+  intro p
+  simp [trialStep]
+
+theorem trial_recursive (Z : Oracle) :
+    Nat.RecursiveIn {oracleFunction Z}
+      (fun p => Part.some (encode (trial Z (Nat.unpair p).1 (Nat.unpair p).2))) := by
+  have hq : Nat.RecursiveIn {oracleFunction Z} (oracleFunction Z) :=
+    .oracle _ (Set.mem_singleton _)
+  have hn := total_primrec (O := {oracleFunction Z}) (Primrec.fst.comp Primrec.unpair)
+  have hc := total_primrec (O := {oracleFunction Z}) (Primrec.snd.comp Primrec.unpair)
+  have ht := total_comp (total_primrec trialStep_primrec)
+    (total_pair hn (total_pair hc (total_comp hq hc)))
+  apply ht.of_eq
+  intro p
+  cases hz : Z (Nat.unpair p).2 <;> simp [trialStep, trial, hz]
+
+theorem reduces_of_infinite_subset {X Z : Oracle}
+    (hsub : ∀ c, Z c = true → prefixSet X c = true)
+    (hinf : {c | Z c = true}.Infinite) : Reduces X Z := by
+  apply RecursiveIn.iff_nat.mpr
+  change Nat.RecursiveIn {oracleFunction Z} (fun n => Part.some (bit X n))
+  apply total_search (trial_recursive Z) (bit X)
+  · intro n c a ha
+    simp only [trial] at ha
+    split at ha
+    next h =>
+      have he : prefixCode X (codeLength c) = c := of_decide_eq_true (hsub c h.1)
+      have ha' : a = codeBit n c := (Option.mem_some_iff.mp ha).symm
+      rw [ha', ← he]
+      exact codeBit_prefix X n (codeLength c) h.2
+    next h => simp at ha
+  · intro n
+    obtain ⟨c, hc, hn⟩ := subset_unbounded hsub hinf n
+    exact ⟨c, codeBit n c, by simp [trial, hc, hn]⟩
+
+theorem prefixSet_degree (X : Oracle) : degree (prefixSet X) = degree X := by
+  apply (degree_eq_iff _ _).mpr
+  exact ⟨prefixSet_reduces X, reduces_of_infinite_subset (fun _ h => h)
+    (prefixSet_infinite X)⟩
+
+theorem introreducible_representative (X : Oracle) :
+    ∃ Y : Oracle, degree Y = degree X ∧ {n | Y n = true}.Infinite ∧
+      ∀ Z : Oracle, (∀ n, Z n = true → Y n = true) →
+        {n | Z n = true}.Infinite → Reduces Y Z := by
+  refine ⟨prefixSet X, prefixSet_degree X, prefixSet_infinite X, ?_⟩
+  intro Z hsub hinf
+  exact reduces_trans (prefixSet_reduces X) (reduces_of_infinite_subset hsub hinf)
+
+end Introreducible
+end TuringRigidity
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/Joins.lean

@@ -0,0 +1,126 @@
+import OAI.Computability.DegreeRigidity.Computability.OracleCode
+import Lean.Elab.Tactic.Omega
+
+namespace OAI
+
+namespace TuringRigidity
+
+def join (A B : Oracle) (n : ℕ) : Bool := if n.bodd then B (n / 2) else A (n / 2)
+
+private theorem total_comp {O : Set (ℕ →. ℕ)} {f g : ℕ → ℕ}
+    (hf : Nat.RecursiveIn O (fun n => Part.some (f n)))
+    (hg : Nat.RecursiveIn O (fun n => Part.some (g n))) :
+    Nat.RecursiveIn O (fun n => Part.some (f (g n))) := by
+  simpa using Nat.RecursiveIn.comp hf hg
+
+private theorem total_pair {O : Set (ℕ →. ℕ)} {f g : ℕ → ℕ}
+    (hf : Nat.RecursiveIn O (fun n => Part.some (f n)))
+    (hg : Nat.RecursiveIn O (fun n => Part.some (g n))) :
+    Nat.RecursiveIn O (fun n => Part.some (Nat.pair (f n) (g n))) := by
+  simpa [Seq.seq] using Nat.RecursiveIn.pair hf hg
+
+private theorem total_primrec {O : Set (ℕ →. ℕ)} {f : ℕ → ℕ}
+    (hf : Primrec f) : Nat.RecursiveIn O (fun n => Part.some (f n)) :=
+  RecursiveIn.iff_nat.mp hf.computableIn
+
+@[simp] theorem join_even (A B : Oracle) (n : ℕ) : join A B (2*n) = A n := by
+  simp [join, Nat.bodd_mul]
+
+@[simp] theorem join_odd (A B : Oracle) (n : ℕ) : join A B (2*n+1) = B n := by
+  simp [join, Nat.bodd_mul]
+  congr 1
+  omega
+
+theorem reduces_join_left (A B : Oracle) : Reduces A (join A B) := by
+  apply RecursiveIn.iff_nat.mpr
+  have horacle : Nat.RecursiveIn {oracleFunction (join A B)} (oracleFunction (join A B)) :=
+    .oracle _ (Set.mem_singleton _)
+  have h := total_comp horacle (total_primrec (Primrec.nat_mul.comp (Primrec.const 2) Primrec.id))
+  change Nat.RecursiveIn {oracleFunction (join A B)} (fun n => Part.some (if A n then 1 else 0))
+  simpa [oracleFunction] using h
+
+theorem reduces_join_right (A B : Oracle) : Reduces B (join A B) := by
+  apply RecursiveIn.iff_nat.mpr
+  have horacle : Nat.RecursiveIn {oracleFunction (join A B)} (oracleFunction (join A B)) :=
+    .oracle _ (Set.mem_singleton _)
+  have h := total_comp horacle (total_primrec
+    (Primrec.nat_add.comp (Primrec.nat_mul.comp (Primrec.const 2) Primrec.id) (Primrec.const 1)))
+  change Nat.RecursiveIn {oracleFunction (join A B)} (fun n => Part.some (if B n then 1 else 0))
+  simpa [oracleFunction] using h
+
+private def selectPair (k : ℕ) : ℕ :=
+  if (Nat.unpair k).1.bodd then (Nat.unpair (Nat.unpair k).2).2
+  else (Nat.unpair (Nat.unpair k).2).1
+
+private theorem selectPair_primrec : Primrec selectPair := by
+  apply (Primrec.cond (Primrec.nat_bodd.comp (Primrec.fst.comp Primrec.unpair))
+    (Primrec.snd.comp (Primrec.unpair.comp (Primrec.snd.comp Primrec.unpair)))
+    (Primrec.fst.comp (Primrec.unpair.comp (Primrec.snd.comp Primrec.unpair)))).of_eq
+  intro n
+  cases hb : (Nat.unpair n).1.bodd <;> simp [selectPair, hb]
+
+theorem join_reduces {A B C : Oracle} (hA : Reduces A C) (hB : Reduces B C) :
+    Reduces (join A B) C := by
+  apply RecursiveIn.iff_nat.mpr
+  have hA' := RecursiveIn.iff_nat.mp hA
+  have hB' := RecursiveIn.iff_nat.mp hB
+  have hdiv : Nat.RecursiveIn {oracleFunction C} (fun n => Part.some (n / 2)) :=
+    total_primrec (Primrec.nat_div.comp Primrec.id (Primrec.const 2))
+  have hp := total_pair (total_primrec Primrec.id)
+    (total_pair (total_comp hA' hdiv) (total_comp hB' hdiv))
+  have h := total_comp (total_primrec selectPair_primrec) hp
+  apply Nat.RecursiveIn.of_eq h
+  intro n
+  simp only [selectPair, Nat.unpair_pair, oracleFunction, join, id_eq]
+  by_cases hb : n.bodd = true <;> simp [hb]
+
+theorem join_reduces_iff (A B C : Oracle) :
+    Reduces (join A B) C ↔ Reduces A C ∧ Reduces B C :=
+  ⟨fun h => ⟨reduces_trans (reduces_join_left A B) h,
+    reduces_trans (reduces_join_right A B) h⟩, fun h => join_reduces h.1 h.2⟩
+
+theorem join_mono {A B C D : Oracle} (hA : Reduces A C) (hB : Reduces B D) :
+    Reduces (join A B) (join C D) :=
+  join_reduces (reduces_trans hA (reduces_join_left C D))
+    (reduces_trans hB (reduces_join_right C D))
+
+def degreeJoin (a b : Degree) : Degree :=
+  Quotient.liftOn₂ a b (fun A B => degree (join A B))
+    (fun _ _ _ _ hA hB => (degree_eq_iff _ _).mpr
+      ⟨join_mono hA.1 hB.1, join_mono hA.2 hB.2⟩)
+
+@[simp] theorem degree_join (A B : Oracle) :
+    degreeJoin (degree A) (degree B) = degree (join A B) := rfl
+
+instance : SemilatticeSup Degree where
+  sup := degreeJoin
+  le_sup_left a b := by
+    obtain ⟨A, rfl⟩ := degree_surjective a
+    obtain ⟨B, rfl⟩ := degree_surjective b
+    exact reduces_join_left A B
+  le_sup_right a b := by
+    obtain ⟨A, rfl⟩ := degree_surjective a
+    obtain ⟨B, rfl⟩ := degree_surjective b
+    exact reduces_join_right A B
+  sup_le a b c := by
+    obtain ⟨A, rfl⟩ := degree_surjective a
+    obtain ⟨B, rfl⟩ := degree_surjective b
+    obtain ⟨C, rfl⟩ := degree_surjective c
+    exact join_reduces
+
+instance : OrderBot Degree where
+  bot := degree (fun _ => false)
+  bot_le a := by
+    obtain ⟨A, rfl⟩ := degree_surjective a
+    apply RecursiveIn.iff_nat.mpr
+    change Nat.RecursiveIn {oracleFunction A} (fun _ => Part.some 0)
+    exact .zero
+
+theorem automorphism_preserves_join (π : Degree ≃o Degree) (a b : Degree) :
+    π (a ⊔ b) = π a ⊔ π b := π.map_sup a b
+
+theorem automorphism_fixes_zero (π : Degree ≃o Degree) : π ⊥ = ⊥ := π.map_bot
+
+end TuringRigidity
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/JumpIdeal.lean

@@ -0,0 +1,55 @@
+import OAI.Computability.DegreeRigidity.Constructibility.PersistentLocality
+import OAI.Computability.DegreeRigidity.Representation.GlobalLocality
+
+namespace OAI
+
+namespace TuringRigidity.JumpIdeal
+open OracleJump IdealInterpretation IdealLocality PersistentRestrictions PersistentLocality GlobalLocality
+noncomputable section
+
+theorem iterate_monotone (x : Degree) : Monotone (degreeIterate x) := by
+  apply monotone_nat_of_le_succ
+  intro n
+  exact degree_le_jump _
+
+def generated (x : Degree) : CountableIdeal where
+  carrier := {y | ∃ n, y ≤ degreeIterate x n}
+  nonempty := ⟨x,0,le_rfl⟩
+  countable := by
+    have he : {y | ∃ n, y ≤ degreeIterate x n} = ⋃ n, Set.Iic (degreeIterate x n) := by
+      ext y
+      simp only [Set.mem_ofPred_eq,Set.mem_iUnion,Set.mem_Iic]
+    rw [he]
+    exact Set.countable_iUnion (fun n => countable_principal_lower _)
+  lower := by
+    intro a b hab hb
+    obtain ⟨n,hn⟩ := hb
+    exact ⟨n,hab.trans hn⟩
+  join_mem := by
+    intro a b ha hb
+    obtain ⟨m,hm⟩ := ha
+    obtain ⟨n,hn⟩ := hb
+    exact ⟨max m n,sup_le (hm.trans (iterate_monotone x (le_max_left m n)))
+      (hn.trans (iterate_monotone x (le_max_right m n)))⟩
+
+theorem includes (x : Degree) : x ∈ (generated x).carrier := ⟨0,le_rfl⟩
+
+theorem closed (x : Degree) : JumpClosed (ideal (generated x)) := by
+  intro y hy
+  obtain ⟨n,hn⟩ := hy
+  exact ⟨n+1,degreeJump_mono hn⟩
+
+theorem least (x : Degree) (J : DegreeIdeal) (hx : x ∈ J.carrier)
+    (hj : JumpClosed J) : (generated x).carrier ⊆ J.carrier := by
+  have hi (n : ℕ) : degreeIterate x n ∈ J.carrier := by
+    induction n with
+    | zero => exact hx
+    | succ n ih => exact hj _ ih
+  intro y hy
+  obtain ⟨n,hn⟩ := hy
+  exact J.lower hn (hi n)
+
+end
+end TuringRigidity.JumpIdeal
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/JumpIdealPresentation.lean

@@ -0,0 +1,88 @@
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticJumpBound
+
+namespace OAI
+
+namespace TuringRigidity.JumpIdealPresentation
+open Encodable EncodedForcing OracleJump ArithmeticHierarchy IndexMatrix TableIndices
+open PersistentRestrictions PersistentPresentation UniformArithmetic
+noncomputable section
+
+def omegaJump (X : Oracle) : Oracle := fun v => iterate X (Nat.unpair v).1 (Nat.unpair v).2
+
+@[simp] theorem omegaJump_column (X : Oracle) (n : ℕ) :
+    columns (omegaJump X) n = iterate X n := by
+  funext k
+  simp [columns,omegaJump]
+
+def presentation (X : Oracle) : Oracle := fun v =>
+  tableOracle (iterate X (Nat.unpair (Nat.unpair v).1).1)
+    (Nat.unpair (Nat.unpair v).1).2 (Nat.unpair v).2
+
+@[simp] theorem presentation_column (X : Oracle) (n e : ℕ) :
+    columns (presentation X) (Nat.pair n e) = tableOracle (iterate X n) e := by
+  funext k
+  simp [columns,presentation]
+
+theorem graph_sigma (Y : Oracle) (e : ℕ) : Sigma Y 1 (tableGraph Y e) := by
+  classical
+  have hr := IndexMatrix.run_uniform_recursive Y
+  have hf := UniformOracle.total_comp hr (UniformOracle.total_primrec
+    (Primrec₂.natPair.comp (Primrec.const e)
+      (Primrec₂.natPair.comp UniformArithmetic.left_primrec UniformArithmetic.right_primrec)))
+  have hcheck : Primrec (fun q : ℕ => if q = encode (some (1 : ℕ)) then 1 else 0) :=
+    Primrec.ite (Primrec.eq.comp Primrec.id (Primrec.const _)) (Primrec.const 1) (Primrec.const 0)
+  have h : RecursivePred Y (fun v => run Y (machine e) (Nat.unpair v).1 (Nat.unpair v).2 = some 1) := by
+    exact (UniformOracle.total_comp (UniformOracle.total_primrec hcheck) hf).of_eq
+      (fun v => by simp only [Nat.unpair_pair,Encodable.encode_injective.eq_iff,UniformArithmetic.left,UniformArithmetic.right]; split <;> simp_all)
+  exact (exists_form (n := 0) h).congr
+    (fun _ => by simp only [Nat.unpair_pair,tableGraph])
+
+theorem tableOracle_reduces_jump (Y : Oracle) (e : ℕ) :
+    Reduces (tableOracle Y e) (jump Y) := by
+  apply RecursiveIn.iff_nat.mpr
+  exact (form_recursive (graph_sigma Y e)).of_eq
+    (fun v => by
+      classical
+      simp [oracleFunction,tableOracle])
+
+theorem presents (X : Oracle) : Presented (JumpIdeal.generated (degree X)) (presentation X) := by
+  intro x
+  constructor
+  · rintro ⟨n,hn⟩
+    have hx : x ≤ degree (iterate X n) := by simpa only [GlobalLocality.degreeIterate_degree] using hn
+    obtain ⟨A,rfl⟩ := degree_surjective x
+    obtain ⟨d,hd⟩ := reduces_represents hx
+    have hd' : Represents (iterate X n) (machine (encode d)) A := by simpa using hd
+    refine ⟨Nat.pair n (encode d),?_⟩
+    rw [presentation_column,tableOracle_eq hd']
+  · rintro ⟨k,rfl⟩
+    obtain ⟨⟨n,e⟩,rfl⟩ := Nat.pairEquiv.surjective k
+    change degree (columns (presentation X) (Nat.pair n e)) ∈ _
+    rw [presentation_column]
+    refine ⟨n+1,?_⟩
+    simpa only [GlobalLocality.degreeIterate_degree,iterate,degree_le_iff] using tableOracle_reduces_jump (iterate X n) e
+
+theorem presentation_arith : Arith (fun O v =>
+    tableOracle (columns (O 0) (Nat.unpair (Nat.unpair v).1).1)
+      (Nat.unpair (Nat.unpair v).1).2 (Nat.unpair v).2 = true) := by
+  have hB := column_arith (parameter_arith 0) UniformArithmetic.left_primrec
+  have h := tableOracle_arith hB UniformArithmetic.right_primrec
+  exact h
+
+theorem presentation_bounded (X : Oracle) :
+    ∃ k, Reduces (presentation X) (iterate (omegaJump X) k) := by
+  obtain ⟨k,hk⟩ := presentation_arith.jump_bound
+  refine ⟨k,RecursiveIn.iff_nat.mpr ?_⟩
+  have h := hk (fun _ => omegaJump X) (omegaJump X) (fun _ => reduces_refl _)
+  exact h.of_eq (fun v => by
+    simp only [omegaJump_column]
+    by_cases value : presentation X v = true
+    · simp [oracleFunction,presentation] at value ⊢
+      simp [value]
+    · simp [oracleFunction,presentation] at value ⊢
+      simp [value])
+
+end
+end TuringRigidity.JumpIdealPresentation
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/JumpIterationFormula.lean

@@ -0,0 +1,39 @@
+import OAI.Computability.DegreeRigidity.Computability.JumpSetFormula
+import OAI.Computability.DegreeRigidity.SetModels.ModelIterationFormula
+
+namespace OAI
+
+
+namespace TuringRigidity.BoundedSetTheory
+open UniformArithmetic OracleJump
+universe u
+
+def JumpFormula (φ : Formula) : Prop := ∀ o Q x y : ℕ, ∀ e : ℕ → ZFSet.{u},
+    e o = ZFSet.omega → (∀ f : ℕ → ℕ, ∀ k, finiteNaturalGraph f k ∈ e Q) →
+    ∀ A B : Oracle, e x = realCode A → e y = realCode B →
+      ((Formula.oracleGraph φ o Q x y).Eval e ↔ B = jump A)
+
+namespace Formula
+def jumpIteration (φ : Formula) (o R Qf Qn n A B : ℕ) : Formula :=
+  modelIteration o R Qf n A B (oracleGraph φ (o+3) (Qn+3) 1 0)
+
+theorem jumpIteration_spec {φ : Formula} (hφ : JumpFormula.{u} φ)
+    (o R Qf Qn n x y : ℕ) (e : ℕ → ZFSet.{u}) (ho : e o = ZFSet.omega)
+    (hQn : ∀ f : ℕ → ℕ, ∀ k, finiteNaturalGraph f k ∈ e Qn)
+    (hQf : ∀ a : ℕ → ZFSet.{u}, (∀ i, a i ∈ e R) → ∀ k, finiteModelGraph a k ∈ e Qf)
+    (hR : ∀ w ∈ e R, ∃ B : Oracle, realCode B = w)
+    (A : Oracle) (hA : ∀ i, realCode (iterate A i) ∈ e R)
+    (hx : e x = realCode A) (N : ℕ) (hn : e n = natSet N) :
+    (jumpIteration φ o R Qf Qn n x y).Eval e ↔ e y = realCode (iterate A N) := by
+  apply modelIteration_spec o R Qf n x y _ e ho hQf N hn
+    (fun i => realCode (iterate A i)) hA hx
+  intro i w hw
+  obtain ⟨B,rfl⟩ := hR w hw
+  rw [hφ (o+3) (Qn+3) 1 0 (cons (realCode B) (cons (realCode (iterate A i)) (cons (natSet i) e)))
+    ho hQn (iterate A i) B rfl rfl]
+  exact ⟨fun h => congrArg realCode h,fun h => realCode_injective h⟩
+end Formula
+
+end TuringRigidity.BoundedSetTheory
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/JumpProperties.lean

@@ -0,0 +1,85 @@
+import OAI.Computability.DegreeRigidity.Computability.OracleJump
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticAtoms
+
+namespace OAI
+
+namespace TuringRigidity.OracleJump
+open Encodable UniformOracle CommonIdeal TableIndices IndexMatrix ArithmeticHierarchy
+
+theorem recursive_transfer {Y Z : Oracle} {P : ℕ → Prop}
+    (h : RecursivePred Y P) (hYZ : Reduces Y Z) : RecursivePred Z P :=
+  RecursiveIn.iff_nat.mp (TuringReducible.trans (RecursiveIn.iff_nat.mpr h) hYZ)
+
+theorem recursive_lift {Y : Oracle} {P : ℕ → Prop} (h : RecursivePred Y P) :
+    RecursivePred (jump Y) P := by
+  have hh := exists_recursive_jump (recursive_comp h (Primrec.fst.comp Primrec.unpair))
+  exact Form.congr (n := 0) (s := true) hh (fun x => by simp)
+
+theorem reduces_jump (Y : Oracle) : Reduces Y (jump Y) := by
+  have h : RecursivePred Y (fun x => Y x = true) := by
+    classical
+    have hq : Nat.RecursiveIn {oracleFunction Y} (oracleFunction Y) :=
+      .oracle _ (Set.mem_singleton _)
+    exact hq.of_eq (fun x => by cases hy : Y x <;> simp [oracleFunction,hy])
+  apply RecursiveIn.iff_nat.mpr
+  exact (recursive_lift h).of_eq (fun x => by cases hy : Y x <;> simp [oracleFunction,hy])
+
+theorem halts_sigma (Y : Oracle) :
+    Sigma Y 1 (fun v => Halts Y (Nat.unpair v).1 (Nat.unpair v).2) := by
+  classical
+  let f := Primrec.fst.comp Primrec.unpair
+  let s := Primrec.snd.comp Primrec.unpair
+  have ht := total_comp (run_uniform_recursive Y) (total_primrec
+    (Primrec₂.natPair.comp (f.comp f) (Primrec₂.natPair.comp (s.comp f) s)))
+  have hcheck : Primrec (fun v : ℕ => bit ((decode (α := Option ℕ) v).getD none).isSome) :=
+    bit_primrec.comp (Primrec.option_isSome.comp
+      (Primrec.option_getD.comp Primrec.decode (Primrec.const none)))
+  have h : RecursivePred Y (fun v =>
+      (TableIndices.run Y (machine (Nat.unpair (Nat.unpair v).1).1)
+        (Nat.unpair (Nat.unpair v).1).2 (Nat.unpair v).2).isSome = true) := by
+    exact (total_comp (total_primrec hcheck) ht).of_eq (fun v => by
+      simp only [Nat.unpair_pair, encodek, Option.getD_some, bit]
+      congr 1
+      split <;> rfl)
+  apply (exists_form (n := 0) h).congr
+  intro v
+  simp only [Nat.unpair_pair, Halts]
+  apply exists_congr
+  intro z
+  cases TableIndices.run Y (machine (Nat.unpair v).1) (Nat.unpair v).2 z <;> simp
+
+theorem jump_mono {Y Z : Oracle} (hYZ : Reduces Y Z) : Reduces (jump Y) (jump Z) := by
+  obtain ⟨Q,hQ,he⟩ := halts_sigma Y
+  have h := exists_recursive_jump (recursive_transfer hQ hYZ)
+  have h' : RecursivePred (jump Z) (fun v => Halts Y (Nat.unpair v).1 (Nat.unpair v).2) :=
+    Form.congr (n := 0) (s := true) h (fun v => (he v).symm)
+  apply RecursiveIn.iff_nat.mpr
+  exact h'.of_eq (fun v => by
+    classical
+    by_cases h : Halts Y (Nat.unpair v).1 (Nat.unpair v).2 <;> simp [oracleFunction, jump, h])
+
+theorem iterate_mono {Y Z : Oracle} (hYZ : Reduces Y Z) (n : ℕ) :
+    Reduces (iterate Y n) (iterate Z n) := by
+  induction n with
+  | zero => exact hYZ
+  | succ n ih => exact jump_mono ih
+
+noncomputable def degreeJump (x : Degree) : Degree :=
+  Quotient.liftOn x (fun Y => degree (jump Y)) (fun Y Z h =>
+    (degree_eq_iff (jump Y) (jump Z)).mpr ⟨jump_mono h.1, jump_mono h.2⟩)
+
+@[simp] theorem degreeJump_degree (Y : Oracle) : degreeJump (degree Y) = degree (jump Y) := rfl
+
+theorem degree_le_jump (x : Degree) : x ≤ degreeJump x := by
+  obtain ⟨Y,rfl⟩ := degree_surjective x
+  exact reduces_jump Y
+
+theorem degreeJump_mono : Monotone degreeJump := by
+  intro x y h
+  obtain ⟨Y,rfl⟩ := degree_surjective x
+  obtain ⟨Z,rfl⟩ := degree_surjective y
+  exact jump_mono h
+
+end TuringRigidity.OracleJump
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/JumpSetFormula.lean

@@ -0,0 +1,75 @@
+import OAI.Computability.DegreeRigidity.SetModels.ModelRealOperations
+
+namespace OAI
+
+
+namespace TuringRigidity.BoundedSetTheory
+open UniformArithmetic OracleJump
+universe u
+
+namespace Formula
+def singleOracleVars (o Q A n : ℕ) : ℕ → ℕ
+  | 0 => n
+  | 1 => o
+  | 2 => Q
+  | _+3 => A
+
+def singleOracle (φ : Formula) (o Q A n : ℕ) : Formula := φ.rename (singleOracleVars o Q A n)
+
+theorem singleOracle_spec {φ : Formula} {P : Predicate} (hφ : DefinesArithmetic.{u} φ P)
+    (o Q A n : ℕ) (e : ℕ → ZFSet.{u}) (ho : e o = ZFSet.omega)
+    (hQ : ∀ f : ℕ → ℕ, ∀ k, finiteNaturalGraph f k ∈ e Q)
+    (B : Oracle) (hA : e A = realCode B) (N : ℕ) (hn : e n = natSet N) :
+    (singleOracle φ o Q A n).Eval e ↔ P (fun _ => B) N := by
+  rw [singleOracle,eval_rename]
+  have he : (fun i => e (singleOracleVars o Q A n i)) = arithmeticEnv (e Q) (fun _ => B) N := by
+    funext i
+    rcases i with _|i; exact hn
+    rcases i with _|i; exact ho
+    rcases i with _|i; rfl
+    exact hA
+  rw [he]
+  exact hφ _ hQ _ _
+
+def oracleGraph (φ : Formula) (o Q A B : ℕ) : Formula :=
+  allMem o (iff (.member 0 (B+1)) (singleOracle φ (o+1) (Q+1) (A+1) 0))
+
+theorem oracleGraph_spec {φ : Formula} {P : Predicate} (hφ : DefinesArithmetic.{u} φ P)
+    (o Q x y : ℕ) (e : ℕ → ZFSet.{u}) (ho : e o = ZFSet.omega)
+    (hQ : ∀ f : ℕ → ℕ, ∀ k, finiteNaturalGraph f k ∈ e Q)
+    (A B : Oracle) (hx : e x = realCode A) (hy : e y = realCode B) :
+    (oracleGraph φ o Q x y).Eval e ↔ ∀ n, B n = true ↔ P (fun _ => A) n := by
+  simp only [oracleGraph,eval_allMem,eval_iff,Formula.Eval,cons_zero,cons_succ]
+  rw [ho]
+  constructor
+  · intro h n
+    have hn := h (natSet n) ((mem_omega _).mpr ⟨n,rfl⟩)
+    rw [hy,natSet_mem_realCode] at hn
+    exact hn.trans (singleOracle_spec hφ (o+1) (Q+1) (x+1) 0 (cons (natSet n) e) ho hQ A hx n rfl)
+  · intro h z hz
+    obtain ⟨n,rfl⟩ := (mem_omega z).mp hz
+    rw [hy,natSet_mem_realCode]
+    exact (h n).trans (singleOracle_spec hφ (o+1) (Q+1) (x+1) 0 (cons (natSet n) e) ho hQ A hx n rfl).symm
+end Formula
+
+theorem jump_bounded_relation : ∃ φ : Formula, ∀ o Q x y : ℕ, ∀ e : ℕ → ZFSet.{u},
+    e o = ZFSet.omega → (∀ f : ℕ → ℕ, ∀ k, finiteNaturalGraph f k ∈ e Q) →
+    ∀ A B : Oracle, e x = realCode A → e y = realCode B →
+      ((Formula.oracleGraph φ o Q x y).Eval e ↔ B = jump A) := by
+  have h := Arith.comp (fun n => Nat.pair 0 n) (jump_arith (parameter_arith 0))
+    (Primrec₂.natPair.comp (Primrec.const 0) Primrec.id)
+  have hp : Arith (fun O n => jump (O 0) n = true) := h.congr (fun _ _ => by simp only [right,Nat.unpair_pair])
+  obtain ⟨φ,hφ⟩ := arithmetic_bounded_definition.{u} hp
+  refine ⟨φ,?_⟩
+  intro o Q x y e ho hQ A B hx hy
+  rw [Formula.oracleGraph_spec hφ o Q x y e ho hQ A B hx hy]
+  constructor
+  · intro hb
+    funext n
+    have hn := hb n
+    cases ha : B n <;> cases hj : jump A n <;> simp_all
+  · intro hb; subst B; exact fun _ => Iff.rfl
+
+end TuringRigidity.BoundedSetTheory
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/NormalizedRecovery.lean

@@ -0,0 +1,48 @@
+import OAI.Computability.DegreeRigidity.Effective.StageNormalization
+
+namespace OAI
+
+namespace TuringRigidity.NormalizedRecovery
+open EncodedForcing Encodable UniformOracle Introreducible StageNormalization
+
+def trial (B : Oracle) (n c : ℕ) : Option ℕ :=
+  if B (Nat.pair (Nat.unpair n).1 c) = true ∧ (Nat.unpair n).2 < codeLength c
+    then some (codeBit (Nat.unpair n).2 c) else none
+
+theorem trial_recursive (B : Oracle) :
+    Nat.RecursiveIn {oracleFunction B} (fun v => Part.some (encode (trial B (Nat.unpair v).1 (Nat.unpair v).2))) := by
+  let f := Primrec.fst.comp Primrec.unpair
+  let r := Primrec.snd.comp Primrec.unpair
+  have hq : Nat.RecursiveIn {oracleFunction B} (oracleFunction B) := .oracle _ (Set.mem_singleton _)
+  have hb := total_comp hq (total_primrec (Primrec₂.natPair.comp (f.comp f) r))
+  let n := r.comp (f.comp f)
+  let c := r.comp f
+  have hpost := Primrec.encode.comp (Primrec.ite
+    ((Primrec.eq.comp r (Primrec.const 1)).and (Primrec.nat_lt.comp n (codeLength_primrec.comp c)))
+    (Primrec.option_some.comp (codeBit_primrec.comp n c)) (Primrec.const none))
+  exact (total_comp (total_primrec hpost) (total_pair (total_primrec Primrec.id) hb)).of_eq
+    (fun v => by cases h : B (Nat.pair (Nat.unpair (Nat.unpair v).1).1 (Nat.unpair v).2) <;>
+      simp [trial,h])
+
+theorem normalized_inverse (A : Oracle) : Reduces A (normalized A) := by
+  apply RecursiveIn.iff_nat.mpr
+  change Nat.RecursiveIn {oracleFunction (normalized A)} (fun n => Part.some (bit A n))
+  apply total_search (trial_recursive (normalized A)) (bit A)
+  · intro n c a ha
+    simp only [trial] at ha
+    split at ha
+    next h =>
+      have he : prefixCode (columns A (Nat.unpair n).1) (codeLength c) = c := by
+        simpa [normalized,prefixSet] using h.1
+      have ha' : a = codeBit (Nat.unpair n).2 c := (Option.mem_some_iff.mp ha).symm
+      rw [ha',← he,codeBit_prefix _ _ _ h.2]
+      simp [bit,columns,Nat.pair_unpair]
+    next h => simp at ha
+  · intro n
+    let c := prefixCode (columns A (Nat.unpair n).1) ((Nat.unpair n).2+1)
+    refine ⟨c,codeBit (Nat.unpair n).2 c,?_⟩
+    simp [trial,normalized,c]
+
+end TuringRigidity.NormalizedRecovery
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/OracleCode.lean

@@ -0,0 +1,125 @@
+import OAI.Computability.DegreeRigidity.SetModels.Degrees
+import Mathlib.Tactic.DeriveEncodable
+import Mathlib.Data.Set.Countable
+
+namespace OAI
+
+namespace TuringRigidity
+
+inductive OracleCode where
+  | zero | succ | left | right | query
+  | pair : OracleCode → OracleCode → OracleCode
+  | comp : OracleCode → OracleCode → OracleCode
+  | prec : OracleCode → OracleCode → OracleCode
+  | find : OracleCode → OracleCode
+  deriving Encodable
+
+namespace OracleCode
+
+def eval (g : ℕ →. ℕ) : OracleCode → ℕ →. ℕ
+  | .zero => fun _ => 0
+  | .succ => Nat.succ
+  | .left => fun n => (Nat.unpair n).1
+  | .right => fun n => (Nat.unpair n).2
+  | .query => g
+  | .pair c d => fun n => Nat.pair <$> eval g c n <*> eval g d n
+  | .comp c d => fun n => eval g d n >>= eval g c
+  | .prec c d => fun p =>
+      let (a, n) := Nat.unpair p
+      n.rec (eval g c a) fun y ih => do
+        let i ← ih
+        eval g d (Nat.pair a (Nat.pair y i))
+  | .find c => fun a =>
+      Nat.rfind fun n => (fun m => m = 0) <$> eval g c (Nat.pair a n)
+
+theorem eval_recursiveIn (g : ℕ →. ℕ) (c : OracleCode) :
+    Nat.RecursiveIn {g} (eval g c) := by
+  induction c with
+  | zero => exact .zero
+  | succ => exact .succ
+  | left => exact .left
+  | right => exact .right
+  | query => exact .oracle g (Set.mem_singleton g)
+  | pair c d hc hd => exact .pair hc hd
+  | comp c d hc hd => exact .comp hc hd
+  | prec c d hc hd => exact .prec hc hd
+  | find c hc => exact .rfind hc
+
+theorem exists_code {g f : ℕ →. ℕ} (hf : Nat.RecursiveIn {g} f) :
+    ∃ c : OracleCode, eval g c = f := by
+  induction hf with
+  | zero => exact ⟨.zero, rfl⟩
+  | succ => exact ⟨.succ, rfl⟩
+  | left => exact ⟨.left, rfl⟩
+  | right => exact ⟨.right, rfl⟩
+  | oracle f hf =>
+      have hfg : f = g := Set.mem_singleton_iff.mp hf
+      subst f
+      exact ⟨.query, rfl⟩
+  | pair _ _ hc hd =>
+      obtain ⟨c, rfl⟩ := hc
+      obtain ⟨d, rfl⟩ := hd
+      exact ⟨.pair c d, rfl⟩
+  | comp _ _ hc hd =>
+      obtain ⟨c, rfl⟩ := hc
+      obtain ⟨d, rfl⟩ := hd
+      exact ⟨.comp c d, rfl⟩
+  | prec _ _ hc hd =>
+      obtain ⟨c, rfl⟩ := hc
+      obtain ⟨d, rfl⟩ := hd
+      exact ⟨.prec c d, rfl⟩
+  | rfind _ hc =>
+      obtain ⟨c, rfl⟩ := hc
+      exact ⟨.find c, rfl⟩
+
+theorem turingReducible_iff_exists_code (f g : ℕ →. ℕ) :
+    TuringReducible f g ↔ ∃ c : OracleCode, eval g c = f := by
+  change RecursiveIn {g} f ↔ _
+  rw [RecursiveIn.iff_nat]
+  exact ⟨exists_code, fun ⟨c, hc⟩ => hc ▸ eval_recursiveIn g c⟩
+
+theorem countable_reducible (g : ℕ →. ℕ) :
+    {f : ℕ →. ℕ | TuringReducible f g}.Countable := by
+  have heq : {f : ℕ →. ℕ | TuringReducible f g} = Set.range (eval g) := by
+    ext f
+    exact turingReducible_iff_exists_code f g
+  rw [heq]
+  exact Set.countable_range _
+
+end OracleCode
+
+theorem oracleFunction_injective : Function.Injective oracleFunction := by
+  intro A B hab
+  funext n
+  have h := congrFun hab n
+  cases ha : A n <;> cases hb : B n <;> simp [oracleFunction, ha, hb] at h ⊢
+
+theorem countable_reduces (B : Oracle) : {A : Oracle | Reduces A B}.Countable := by
+  exact (OracleCode.countable_reducible (oracleFunction B)).preimage oracleFunction_injective
+
+theorem countable_degree_fiber (a : Degree) : {A : Oracle | degree A = a}.Countable := by
+  obtain ⟨B, rfl⟩ := degree_surjective a
+  apply (countable_reduces B).mono
+  intro A hA
+  exact ((degree_eq_iff A B).mp hA).1
+
+theorem countable_lift_fiber {X : Type*} (C : X → Oracle) (hC : Function.Injective C)
+    (π : Degree → Degree) (hπ : Function.Injective π)
+    (F : X → Oracle) (hF : ∀ x, degree (F x) = π (degree (C x))) (B : Oracle) :
+    {x : X | F x = B}.Countable := by
+  by_cases hne : ∃ x, F x = B
+  · obtain ⟨x₀, hx₀⟩ := hne
+    apply ((countable_degree_fiber (degree (C x₀))).preimage hC).mono
+    intro x hx
+    apply hπ
+    rw [← hF x, ← hF x₀, hx, hx₀]
+  · have hempty : {x : X | F x = B} = ∅ := by
+      ext x
+      simp only [Set.mem_ofPred_eq, Set.mem_empty_iff_false, iff_false]
+      exact fun h => hne ⟨x,h⟩
+    rw [hempty]
+    exact Set.countable_empty
+
+end TuringRigidity
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/OracleEnumeration.lean

@@ -0,0 +1,96 @@
+import OAI.Computability.DegreeRigidity.Effective.PrefixComputability
+import Mathlib.Data.Set.Finite.Range
+import Lean.Elab.Tactic.Omega
+
+namespace OAI
+
+namespace TuringRigidity.OracleEnumeration
+open PrefixComputability
+
+theorem exists_ge {A : Oracle} (hA : {n | A n = true}.Infinite) (n : ℕ) :
+    ∃ m, n ≤ m ∧ A m = true := by
+  by_contra h
+  apply hA
+  apply (Set.finite_le_nat n).subset
+  intro m hm
+  exact Nat.le_of_lt (Nat.lt_of_not_ge (fun hnm => h ⟨m, hnm, hm⟩))
+
+noncomputable def next (A : Oracle) (hA : {n | A n = true}.Infinite) (n : ℕ) : ℕ :=
+  Nat.find (exists_ge hA n)
+
+theorem next_spec (A : Oracle) (hA : {n | A n = true}.Infinite) (n : ℕ) :
+    n ≤ next A hA n ∧ A (next A hA n) = true := Nat.find_spec (exists_ge hA n)
+
+theorem next_min (A : Oracle) (hA : {n | A n = true}.Infinite) (n m : ℕ)
+    (hm : n ≤ m) (hAm : A m = true) : next A hA n ≤ m :=
+  Nat.find_min' (exists_ge hA n) ⟨hm, hAm⟩
+
+private def searchFlag (p : ℕ) : ℕ :=
+  if (Nat.unpair p).1 ≤ (Nat.unpair (Nat.unpair p).2).1 ∧
+    (Nat.unpair (Nat.unpair p).2).2 = 1 then 0 else 1
+
+private theorem searchFlag_primrec : Primrec searchFlag := by
+  exact Primrec.ite ((Primrec.nat_le.comp (Primrec.fst.comp Primrec.unpair)
+    (Primrec.fst.comp (Primrec.unpair.comp (Primrec.snd.comp Primrec.unpair)))).and
+    (Primrec.eq.comp (Primrec.snd.comp (Primrec.unpair.comp (Primrec.snd.comp Primrec.unpair)))
+      (Primrec.const 1))) (Primrec.const 0) (Primrec.const 1)
+
+theorem next_recursive (A : Oracle) (hA : {n | A n = true}.Infinite) :
+    Nat.RecursiveIn {oracleFunction A} (fun n => Part.some (next A hA n)) := by
+  have hq : Nat.RecursiveIn {oracleFunction A} (oracleFunction A) :=
+    .oracle _ (Set.mem_singleton _)
+  have hn := total_primrec (O := {oracleFunction A}) (Primrec.fst.comp Primrec.unpair)
+  have hm := total_primrec (O := {oracleFunction A}) (Primrec.snd.comp Primrec.unpair)
+  have hf := total_comp (total_primrec searchFlag_primrec)
+    (total_pair hn (total_pair hm (total_comp hq hm)))
+  apply (Nat.RecursiveIn.rfind hf).of_eq_tot
+  intro n
+  apply Nat.mem_rfind.mpr
+  constructor
+  · have hs := next_spec A hA n
+    simp [searchFlag, hs.1, hs.2]
+  · intro m hm'
+    have hh : ¬(n ≤ m ∧ A m = true) := Nat.find_min (exists_ge hA n) hm'
+    cases ha : A m <;> simp_all [searchFlag]
+
+noncomputable def enumerate (A : Oracle) (hA : {n | A n = true}.Infinite) : ℕ → ℕ
+  | 0 => next A hA 0
+  | n+1 => next A hA (enumerate A hA n + 1)
+
+theorem enumerate_mem (A : Oracle) (hA : {n | A n = true}.Infinite) (n : ℕ) :
+    A (enumerate A hA n) = true := by
+  cases n <;> exact (next_spec A hA _).2
+
+theorem enumerate_strictMono (A : Oracle) (hA : {n | A n = true}.Infinite) :
+    StrictMono (enumerate A hA) := by
+  apply strictMono_nat_of_lt_succ
+  intro n
+  exact (Nat.lt_succ_self _).trans_le (next_spec A hA _).1
+
+theorem le_enumerate (A : Oracle) (hA : {n | A n = true}.Infinite) (n : ℕ) :
+    n ≤ enumerate A hA n := (enumerate_strictMono A hA).id_le n
+
+theorem enumerate_recursive (A : Oracle) (hA : {n | A n = true}.Infinite) :
+    Nat.RecursiveIn {oracleFunction A} (fun n => Part.some (enumerate A hA n)) := by
+  have hnext := next_recursive A hA
+  have hbase := total_comp hnext (total_primrec (Primrec.const 0))
+  have hstep := total_comp hnext (total_primrec
+    (Primrec.succ.comp (Primrec.snd.comp (Primrec.unpair.comp
+      (Primrec.snd.comp Primrec.unpair)))))
+  have hrec := Nat.RecursiveIn.prec hbase hstep
+  have hr := Nat.RecursiveIn.comp hrec
+    (total_pair (total_primrec (Primrec.const 0)) (total_primrec Primrec.id))
+  apply hr.of_eq
+  intro n
+  change (Part.some (Nat.pair 0 n)).bind _ = _
+  rw [Part.bind_some]
+  simp only [Nat.unpair_pair]
+  induction n with
+  | zero => rfl
+  | succ n ih =>
+    simp only [ih]
+    simp [enumerate]
+
+end TuringRigidity.OracleEnumeration
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/OracleJump.lean

@@ -0,0 +1,90 @@
+import OAI.Computability.DegreeRigidity.Computability.ArithmeticHierarchy
+import OAI.Computability.DegreeRigidity.OrdinalCodes.IndexMatrix
+
+namespace OAI
+
+namespace TuringRigidity.OracleJump
+open Encodable UniformOracle CommonIdeal TableIndices IndexMatrix ArithmeticHierarchy
+
+def Halts (Y : Oracle) (e n : ℕ) : Prop := ∃ z a, a ∈ TableIndices.run Y (machine e) n z
+
+noncomputable def jump (Y : Oracle) : Oracle := by
+  classical
+  exact fun v => decide (Halts Y (Nat.unpair v).1 (Nat.unpair v).2)
+
+theorem partial_table {Y : Oracle} {f : ℕ →. ℕ}
+    (hf : Nat.RecursiveIn {oracleFunction Y} f) :
+    ∃ e, ∀ n, Halts Y e n ↔ (f n).Dom := by
+  obtain ⟨c, hc⟩ := OracleCode.exists_code hf
+  have hh : Partrec₂ (fun L : List ℕ => fun n => OracleCode.eval (BranchMachine.lookup L) c n) :=
+    OracleCode.eval_partrec BranchMachine.lookup_partrec c
+  obtain ⟨d, hd⟩ := partrec_code hh
+  have hd' : ∀ L n, d.eval (Nat.pair (encode L) n) = OracleCode.eval (BranchMachine.lookup L) c n :=
+    fun L n => hd (L,n)
+  have ha (n : ℕ) : Approximates (f n)
+      (fun m => d.eval (Nat.pair (encode (oraclePrefix (fun k => bit (Y k)) m)) n)) := by
+    simp only [hd', ← hc]
+    exact OracleCode.eval_approximates (prefix_approximates (fun k => bit (Y k))) c n
+  refine ⟨encode d, fun n => ?_⟩
+  constructor
+  · rintro ⟨z,a,ha'⟩
+    simp only [machine_encode] at ha'
+    exact ((ha n).1 (Nat.unpair z).1 a (Nat.Partrec.Code.evaln_sound ha')).1
+  · intro hf'
+    obtain ⟨m,hm⟩ := (ha n).2 ((f n).get hf') ⟨hf',rfl⟩
+    obtain ⟨t,ht⟩ := Nat.Partrec.Code.evaln_complete.mp (hm m le_rfl)
+    exact ⟨Nat.pair m t, (f n).get hf', by simpa [TableIndices.run, trial] using ht⟩
+
+theorem domain_recursive_jump {Y : Oracle} {f : ℕ →. ℕ}
+    (hf : Nat.RecursiveIn {oracleFunction Y} f) :
+    RecursivePred (jump Y) (fun n => (f n).Dom) := by
+  classical
+  obtain ⟨e,he⟩ := partial_table hf
+  have hq : Nat.RecursiveIn {oracleFunction (jump Y)} (oracleFunction (jump Y)) :=
+    .oracle _ (Set.mem_singleton _)
+  have h := Nat.RecursiveIn.comp hq (total_primrec (Primrec₂.natPair.comp (Primrec.const e) Primrec.id))
+  exact h.of_eq (fun n => by
+    change (Part.some (Nat.pair e n)).bind
+      (fun input => Part.some (if jump Y input then 1 else 0)) = _
+    rw [Part.bind_some]
+    simp [jump, he])
+
+theorem exists_recursive_jump {Y : Oracle} {P : ℕ → Prop} (hP : RecursivePred Y P) :
+    RecursivePred (jump Y) (fun x => ∃ a, P (Nat.pair x a)) := by
+  classical
+  have hN := recursive_not hP
+  have hs := Nat.RecursiveIn.rfind hN
+  have hd := domain_recursive_jump hs
+  apply Form.congr (n := 0) (s := true) hd
+  intro x
+  erw [Nat.rfind_dom]
+  simp
+
+theorem forall_recursive_jump {Y : Oracle} {P : ℕ → Prop} (hP : RecursivePred Y P) :
+    RecursivePred (jump Y) (fun x => ∀ a, P (Nat.pair x a)) := by
+  have h := recursive_not (exists_recursive_jump (recursive_not hP))
+  simpa only [not_exists, not_not] using h
+
+noncomputable def iterate (Y : Oracle) : ℕ → Oracle
+  | 0 => Y
+  | n+1 => jump (iterate Y n)
+
+theorem form_recursive {Y n s P} (h : Form Y n s P) : RecursivePred (iterate Y n) P := by
+  induction n generalizing s P with
+  | zero => exact h
+  | succ n ih =>
+    obtain ⟨Q,hQ,he⟩ := h
+    have hr := ih hQ
+    cases s with
+    | false =>
+      have hh := forall_recursive_jump hr
+      have he' : (fun x => ∀ a, Q (Nat.pair x a)) = P := funext (fun x => propext (he x).symm)
+      exact he' ▸ hh
+    | true =>
+      have hh := exists_recursive_jump hr
+      have he' : (fun x => ∃ a, Q (Nat.pair x a)) = P := funext (fun x => propext (he x).symm)
+      exact he' ▸ hh
+
+end TuringRigidity.OracleJump
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/RationalCoding.lean

@@ -0,0 +1,157 @@
+import OAI.Computability.DegreeRigidity.Computability.Cuts
+import Mathlib.Computability.Primrec.List
+
+namespace OAI
+
+namespace TuringRigidity
+open Encodable
+
+namespace RationalCoding
+
+def magnitude (n : ℕ) : ℕ := n/2+n%2
+
+theorem magnitude_primrec : Primrec magnitude :=
+  Primrec.nat_add.comp (Primrec.nat_div.comp Primrec.id (Primrec.const 2))
+    (Primrec.nat_mod.comp Primrec.id (Primrec.const 2))
+
+theorem encode_int_nonneg (n : ℕ) : encode (Int.ofNat n) = 2*n := by
+  change Nat.bit false n = 2*n
+  simp [Nat.bit]
+
+theorem encode_int_neg (n : ℕ) : encode (Int.negSucc n) = 2*n+1 := by
+  change Nat.bit true n = 2*n+1
+  simp [Nat.bit]
+
+theorem magnitude_encode_int (z : ℤ) : magnitude (encode z) = z.natAbs := by
+  cases z with
+  | ofNat n =>
+    change magnitude (encode (Int.ofNat n)) = n
+    rw [encode_int_nonneg]
+    simp [magnitude]
+  | negSucc n => simp [encode_int_neg,magnitude]; omega
+
+theorem encode_rat (q : ℚ) : encode q = Nat.pair (encode q.num) q.den := rfl
+
+def valid (n : ℕ) : Prop :=
+  0 < (Nat.unpair n).2 ∧ (magnitude (Nat.unpair n).1).Coprime (Nat.unpair n).2
+
+instance (n : ℕ) : Decidable (valid n) := inferInstanceAs (Decidable (_ ∧ _))
+
+theorem valid_iff (n : ℕ) : valid n ↔ ∃ q : ℚ, encode q = n := by
+  constructor
+  · rintro ⟨hd,hcop⟩
+    let z := Equiv.intEquivNat.symm (Nat.unpair n).1
+    have hz : encode z = (Nat.unpair n).1 := Equiv.intEquivNat.apply_symm_apply _
+    have hm : z.natAbs = magnitude (Nat.unpair n).1 := by rw [←hz,magnitude_encode_int]
+    let q : ℚ := ⟨z,(Nat.unpair n).2,Nat.ne_of_gt hd,hm.symm ▸ hcop⟩
+    refine ⟨q,?_⟩
+    rw [encode_rat]
+    change Nat.pair (encode z) (Nat.unpair n).2 = n
+    rw [hz,Nat.pair_unpair]
+  · rintro ⟨q,rfl⟩
+    simp only [valid,encode_rat,Nat.unpair_pair,magnitude_encode_int]
+    exact ⟨q.den_pos,q.reduced⟩
+
+theorem coprime_bounded (a b : ℕ) :
+    (0 < b ∧ a.Coprime b) ↔
+      (0 < b ∧ ∀ k ∈ List.range (b+1), a%k ≠ 0 ∨ b%k ≠ 0 ∨ k=1) := by
+  constructor
+  · rintro ⟨hb,hc⟩
+    refine ⟨hb,fun k _hk => ?_⟩
+    by_cases ha : a%k = 0
+    · by_cases hb' : b%k = 0
+      · exact Or.inr (Or.inr (Nat.dvd_one.mp (by
+          rw [←hc]
+          exact Nat.dvd_gcd (Nat.dvd_of_mod_eq_zero ha) (Nat.dvd_of_mod_eq_zero hb'))))
+      · exact Or.inr (Or.inl hb')
+    · exact Or.inl ha
+  · rintro ⟨hb,h⟩
+    refine ⟨hb,?_⟩
+    have hg : a.gcd b ∈ List.range (b+1) := by
+      simp only [List.mem_range,Nat.lt_succ_iff]
+      exact Nat.gcd_le_right a hb
+    have hh := h (a.gcd b) hg
+    simpa [Nat.mod_eq_zero_of_dvd (Nat.gcd_dvd_left a b),
+      Nat.mod_eq_zero_of_dvd (Nat.gcd_dvd_right a b)] using hh
+
+theorem coprime_positive_primrec : PrimrecPred (fun p : ℕ × ℕ => 0 < p.2 ∧ p.1.Coprime p.2) := by
+  have hr : PrimrecRel (fun k (p : ℕ × ℕ) => p.1%k ≠ 0 ∨ p.2%k ≠ 0 ∨ k=1) :=
+    ((Primrec.eq.comp (Primrec.nat_mod.comp (Primrec.fst.comp Primrec.snd) Primrec.fst)
+      (Primrec.const 0)).not).or
+    (((Primrec.eq.comp (Primrec.nat_mod.comp (Primrec.snd.comp Primrec.snd) Primrec.fst)
+      (Primrec.const 0)).not).or (Primrec.eq.comp Primrec.fst (Primrec.const 1)))
+  have hh := (Primrec.nat_lt.comp (Primrec.const 0) Primrec.snd).and
+    (hr.forall_mem_list.comp (Primrec.list_range.comp (Primrec.succ.comp Primrec.snd)) Primrec.id)
+  exact hh.of_eq (fun p => (coprime_bounded p.1 p.2).symm)
+
+theorem valid_primrec : PrimrecPred valid :=
+  coprime_positive_primrec.comp ((magnitude_primrec.comp (Primrec.fst.comp Primrec.unpair)).pair
+    (Primrec.snd.comp Primrec.unpair))
+
+def canonicalCode (n : ℕ) : ℕ := if valid n then n else encode (0 : ℚ)
+
+theorem canonicalCode_primrec : Primrec canonicalCode :=
+  Primrec.ite valid_primrec Primrec.id (Primrec.const (encode (0 : ℚ)))
+
+theorem decode_invalid (n : ℕ) (hv : ¬valid n) : decode (α := ℚ) n = none := by
+  let z := Equiv.intEquivNat.symm (Nat.unpair n).1
+  have hz : decode (α := ℤ) (Nat.unpair n).1 = some z := rfl
+  have henc : encode z = (Nat.unpair n).1 := Equiv.intEquivNat.apply_symm_apply _
+  have hbad : ¬(0 < (Nat.unpair n).2 ∧ z.natAbs.Coprime (Nat.unpair n).2) := by
+    simpa only [valid, ←henc, magnitude_encode_int] using hv
+  have hsub : decode (α := { b : ℕ // 0 < b ∧ z.natAbs.Coprime b }) (Nat.unpair n).2 = none := by
+    change Encodable.decodeSubtype (P := fun b => 0 < b ∧ z.natAbs.Coprime b) _ = none
+    simp [Encodable.decodeSubtype,hbad]
+  have hsigma : decode (α := Σ z : ℤ, { b : ℕ // 0 < b ∧ z.natAbs.Coprime b }) n = none := by
+    change Encodable.decodeSigma (γ := fun z : ℤ => { b : ℕ // 0 < b ∧ z.natAbs.Coprime b }) n = none
+    simp only [Encodable.decodeSigma]
+    rw [hz]
+    simp only [Option.bind_some]
+    rw [hsub]
+    rfl
+  simp only [Encodable.decode_ofEquiv,hsigma,Option.map_none]
+
+theorem canonicalCode_eq (n : ℕ) : canonicalCode n = encode (rationalEnumeration n) := by
+  by_cases hv : valid n
+  · obtain ⟨q,rfl⟩ := (valid_iff n).mp hv
+    simp only [canonicalCode,ite_eq_left hv,rationalEnumeration,encodek,Option.getD_some]
+  · have hn := decode_invalid n hv
+    simp only [canonicalCode,ite_eq_right hv,rationalEnumeration,hn,Option.getD_none]
+
+def numeratorCode (n : ℕ) : ℕ := (Nat.unpair (canonicalCode n)).1
+def numeratorMagnitude (n : ℕ) : ℕ := magnitude (numeratorCode n)
+def denominator (n : ℕ) : ℕ := (Nat.unpair (canonicalCode n)).2
+def negative (n : ℕ) : Bool := (numeratorCode n).bodd
+
+theorem numeratorCode_primrec : Primrec numeratorCode :=
+  (Primrec.fst.comp Primrec.unpair).comp canonicalCode_primrec
+theorem numeratorMagnitude_primrec : Primrec numeratorMagnitude :=
+  magnitude_primrec.comp numeratorCode_primrec
+theorem denominator_primrec : Primrec denominator :=
+  (Primrec.snd.comp Primrec.unpair).comp canonicalCode_primrec
+theorem negative_primrec : Primrec negative := Primrec.nat_bodd.comp numeratorCode_primrec
+
+theorem numeratorCode_eq (n : ℕ) : numeratorCode n = encode (rationalEnumeration n).num := by
+  rw [numeratorCode,canonicalCode_eq,encode_rat,Nat.unpair_pair]
+theorem numeratorMagnitude_eq (n : ℕ) : numeratorMagnitude n = (rationalEnumeration n).num.natAbs := by
+  rw [numeratorMagnitude,numeratorCode_eq,magnitude_encode_int]
+theorem denominator_eq (n : ℕ) : denominator n = (rationalEnumeration n).den := by
+  rw [denominator,canonicalCode_eq,encode_rat,Nat.unpair_pair]
+theorem denominator_pos (n : ℕ) : 0 < denominator n := by
+  rw [denominator_eq]
+  exact (rationalEnumeration n).den_pos
+
+theorem query_value (n : ℕ) : (rationalEnumeration n : ℝ) =
+    if negative n then -(numeratorMagnitude n : ℝ)/(denominator n : ℝ)
+    else (numeratorMagnitude n : ℝ)/(denominator n : ℝ) := by
+  rw [negative,numeratorCode_eq,numeratorMagnitude_eq,denominator_eq,Rat.cast_def]
+  cases hz : (rationalEnumeration n).num with
+  | ofNat k =>
+    rw [encode_int_nonneg]
+    simp [Nat.bodd_mul]
+  | negSucc k => simp [encode_int_neg,Nat.bodd_mul]
+
+end RationalCoding
+end TuringRigidity
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/RationalCut.lean

@@ -0,0 +1,82 @@
+import OAI.Computability.DegreeRigidity.Computability.RationalCoding
+import OAI.Computability.DegreeRigidity.Effective.UniformOracle
+
+namespace OAI
+
+namespace TuringRigidity
+namespace RationalCoding
+
+def positiveNumerator (n : ℕ) : ℕ := if negative n then 0 else numeratorMagnitude n
+def negativeNumerator (n : ℕ) : ℕ := if negative n then numeratorMagnitude n else 0
+
+theorem positiveNumerator_primrec : Primrec positiveNumerator :=
+  Primrec.ite (Primrec.eq.comp negative_primrec (Primrec.const true)) (Primrec.const 0)
+    numeratorMagnitude_primrec
+
+theorem negativeNumerator_primrec : Primrec negativeNumerator :=
+  Primrec.ite (Primrec.eq.comp negative_primrec (Primrec.const true)) numeratorMagnitude_primrec
+    (Primrec.const 0)
+
+theorem signed_query_value (n : ℕ) : (rationalEnumeration n : ℝ) =
+    ((positiveNumerator n : ℝ)-(negativeNumerator n : ℝ))/(denominator n : ℝ) := by
+  rw [query_value]
+  cases hn : negative n <;> simp [positiveNumerator,negativeNumerator,hn]
+
+def ltCode (i j : ℕ) : Prop :=
+  positiveNumerator i*denominator j + negativeNumerator j*denominator i <
+    positiveNumerator j*denominator i + negativeNumerator i*denominator j
+
+instance (i j : ℕ) : Decidable (ltCode i j) := inferInstanceAs (Decidable (_ < _))
+
+theorem ltCode_primrec : PrimrecRel ltCode :=
+  Primrec.nat_lt.comp
+    (Primrec.nat_add.comp
+      (Primrec.nat_mul.comp (positiveNumerator_primrec.comp Primrec.fst)
+        (denominator_primrec.comp Primrec.snd))
+      (Primrec.nat_mul.comp (negativeNumerator_primrec.comp Primrec.snd)
+        (denominator_primrec.comp Primrec.fst)))
+    (Primrec.nat_add.comp
+      (Primrec.nat_mul.comp (positiveNumerator_primrec.comp Primrec.snd)
+        (denominator_primrec.comp Primrec.fst))
+      (Primrec.nat_mul.comp (negativeNumerator_primrec.comp Primrec.fst)
+        (denominator_primrec.comp Primrec.snd)))
+
+theorem ltCode_iff (i j : ℕ) :
+    ltCode i j ↔ (rationalEnumeration i : ℝ) < (rationalEnumeration j : ℝ) := by
+  have hi : (0 : ℝ) < denominator i := by exact_mod_cast denominator_pos i
+  have hj : (0 : ℝ) < denominator j := by exact_mod_cast denominator_pos j
+  rw [signed_query_value,signed_query_value,div_lt_div_iff₀ hi hj]
+  constructor
+  · intro h
+    have hh : (positiveNumerator i : ℝ)*denominator j + negativeNumerator j*denominator i <
+        (positiveNumerator j : ℝ)*denominator i + negativeNumerator i*denominator j := by
+      exact_mod_cast h
+    nlinarith
+  · intro h
+    change positiveNumerator i*denominator j + negativeNumerator j*denominator i <
+      positiveNumerator j*denominator i + negativeNumerator i*denominator j
+    have hh : (positiveNumerator i : ℝ)*denominator j + negativeNumerator j*denominator i <
+        (positiveNumerator j : ℝ)*denominator i + negativeNumerator i*denominator j := by nlinarith
+    exact_mod_cast hh
+end RationalCoding
+
+theorem rational_cut_computable (q : ℚ) :
+    Primrec (fun n => if cut (q : ℝ) n then (1 : ℕ) else 0) := by
+  have hp := Primrec.ite
+    (RationalCoding.ltCode_primrec.comp Primrec.id (Primrec.const (Encodable.encode q)))
+    (Primrec.const 1) (Primrec.const 0)
+  apply hp.of_eq
+  intro n
+  have hq : rationalEnumeration (Encodable.encode q) = q := by simp [rationalEnumeration]
+  have he : RationalCoding.ltCode n (Encodable.encode q) ↔ (rationalEnumeration n : ℝ) < q := by
+    rw [RationalCoding.ltCode_iff,hq]
+  by_cases h : (rationalEnumeration n : ℝ) < q
+  · simp [he,h,cut]
+  · simp [he,h,cut]
+
+theorem rational_cut_reduces (q : ℚ) (A : Oracle) : Reduces (cut (q : ℝ)) A := by
+  exact RecursiveIn.iff_nat.mpr (UniformOracle.total_primrec (rational_cut_computable q))
+
+end TuringRigidity
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/RealProjectionSyntax.lean

@@ -0,0 +1,136 @@
+import OAI.Computability.DegreeRigidity.Constructibility.ConstructionInputData
+import OAI.Computability.DegreeRigidity.SetModels.SetModelJoin
+
+namespace OAI
+
+namespace TuringRigidity.RelativeConstructible
+open ElementaryModel BoundedSetTheory TransitiveNameModel SetModelArithmetic SetModelReals
+universe u
+
+def bitIndex : List Bool → ℕ → ℕ
+  | [], n => n
+  | b::bs, n => 2 * bitIndex bs n + if b then 1 else 0
+
+def partBits : ℕ → List Bool
+  | 0 => [false]
+  | i+1 => true :: partBits i
+
+def pathBits : List ℕ → List Bool
+  | [] => []
+  | i::is => partBits i ++ pathBits is
+
+theorem bitIndex_append (a b : List Bool) (n : ℕ) :
+    bitIndex (a++b) n = bitIndex a (bitIndex b n) := by
+  induction a with
+  | nil => rfl
+  | cons c a ih => simp only [List.cons_append,bitIndex,ih]
+
+theorem realPart_bits (P : Oracle) (i n : ℕ) :
+    realPart P i n = P (bitIndex (partBits i) n) := by
+  induction i generalizing P with
+  | zero => simp [realPart,partBits,bitIndex]
+  | succ i ih => exact ih (fun k => P (2*k+1))
+
+theorem pathReal_bits (P : Oracle) (path : List ℕ) (n : ℕ) :
+    pathReal P path n = P (bitIndex (pathBits path) n) := by
+  induction path generalizing P with
+  | nil => rfl
+  | cons i is ih => rw [pathReal,ih,realPart_bits,pathBits,bitIndex_append]
+
+def bitStep (b : Bool) (w a d x y : ℕ) : Formula :=
+  if b then .existsMem w (.conj (tripleFormula (x+1) (x+1) 0 (a+1) (d+1))
+    (.successor (y+1) 0)) else tripleFormula x x y a d
+
+theorem bitStep_spec (b : Bool) (w a d x y : ℕ) (e : ℕ → ZFSet.{u})
+    (hw : e w = ZFSet.omega) (ha : e a = additionSet) (hd : e d = pairNumbers)
+    (n m : ℕ) (hx : e x = natSet n) (hy : e y = natSet m) :
+    (bitStep b w a d x y).Eval e ↔ m = 2*n + if b then 1 else 0 := by
+  cases b
+  · simp [bitStep,eval_tripleFormula,hx,hy,ha,hd,addition_code,two_mul]
+  · simp only [bitStep,ite_true,Formula.Eval,eval_tripleFormula,Formula.eval_successor,
+      cons_zero,cons_succ,hw,hx,hy,ha,hd]
+    rw [omega_exists]
+    simp only [natPair_mem,true_and,addition_code,natSet_successor_eq]
+    constructor
+    · rintro ⟨k,hk,hm⟩; omega
+    · intro hm; exact ⟨n+n,rfl,by omega⟩
+
+def bitIndexFormula : List Bool → ℕ → ℕ → ℕ → ℕ → ℕ → Formula
+  | [], _, _, _, x, y => .equal y x
+  | b::bs, w, a, d, x, y => .existsMem w
+      (.conj (bitIndexFormula bs (w+1) (a+1) (d+1) (x+1) 0)
+        (bitStep b (w+1) (a+1) (d+1) 0 (y+1)))
+
+theorem bitIndexFormula_spec (bs : List Bool) (w a d x y : ℕ) (e : ℕ → ZFSet.{u})
+    (hw : e w = ZFSet.omega) (ha : e a = additionSet) (hd : e d = pairNumbers)
+    (n m : ℕ) (hx : e x = natSet n) (hy : e y = natSet m) :
+    (bitIndexFormula bs w a d x y).Eval e ↔ m = bitIndex bs n := by
+  induction bs generalizing w a d x y e m with
+  | nil => simp [bitIndexFormula,Formula.Eval,hx,hy,bitIndex,natSet_injective.eq_iff]
+  | cons b bs ih =>
+    simp only [bitIndexFormula,Formula.Eval,hw]
+    rw [omega_exists]
+    have hb (k : ℕ) := bitStep_spec b (w+1) (a+1) (d+1) 0 (y+1)
+      (cons (natSet k) e) hw ha hd k m rfl hy
+    have hi (k : ℕ) := ih (w+1) (a+1) (d+1) (x+1) 0 (cons (natSet k) e)
+      hw ha hd k hx rfl
+    simp only [hi,hb,exists_eq_left,bitIndex]
+
+def projectionMember (bs : List Bool) (w a d P x : ℕ) : Formula :=
+  .conj (.member x w) (.existsMem w
+    (.conj (bitIndexFormula bs (w+1) (a+1) (d+1) (x+1) 0) (.member 0 (P+1))))
+
+theorem projectionMember_spec (bs : List Bool) (w a d P x : ℕ)
+    (e : ℕ → ZFSet.{u}) (hw : e w = ZFSet.omega) (ha : e a = additionSet)
+    (hd : e d = pairNumbers) (Q : Oracle) (hP : e P = realCode Q) :
+    (projectionMember bs w a d P x).Eval e ↔ e x ∈ realCode (fun n => Q (bitIndex bs n)) := by
+  simp only [projectionMember,Formula.Eval,hw,cons_zero,cons_succ,hP]
+  constructor
+  · rintro ⟨hx,k,hk,hrel,hQ⟩
+    obtain ⟨n,hn⟩ := (mem_omega (e x)).mp hx
+    obtain ⟨m,rfl⟩ := (mem_omega k).mp hk
+    have hm := (bitIndexFormula_spec bs (w+1) (a+1) (d+1) (x+1) 0
+      (cons (natSet m) e) hw ha hd n m hn rfl).mp hrel
+    rw [hn,natSet_mem_realCode]
+    simpa [hm] using (natSet_mem_realCode Q m).mp hQ
+  · intro hx
+    obtain ⟨n,hn⟩ := (mem_omega (e x)).mp (realCode_subset _ hx)
+    have hnQ : Q (bitIndex bs n) = true := (natSet_mem_realCode _ n).mp (hn ▸ hx)
+    refine ⟨hn.symm ▸ (mem_omega _).mpr ⟨n,rfl⟩,natSet (bitIndex bs n),
+      (mem_omega _).mpr ⟨_,rfl⟩,?_,(natSet_mem_realCode Q _).mpr hnQ⟩
+    exact (bitIndexFormula_spec bs (w+1) (a+1) (d+1) (x+1) 0
+      (cons (natSet (bitIndex bs n)) e) hw ha hd n _ hn rfl).mpr rfl
+
+noncomputable def projectionFormula (bs : List Bool) (out w a d P : ℕ) : SentenceForm :=
+  SentenceForm.all (SentenceForm.iff (.member 0 (out+1))
+    (fromBounded (projectionMember bs (w+1) (a+1) (d+1) (P+1) 0)))
+
+theorem projectionFormula_spec (M : ZFSet.{u}) (hM : Transitive M)
+    (bs : List Bool) (out w a d P : ℕ) (e : ℕ → ZFSet.{u}) (he : ∀ i, e i ∈ M)
+    (hw : e w = ZFSet.omega) (ha : e a = additionSet) (hd : e d = pairNumbers)
+    (Q : Oracle) (hP : e P = realCode Q) :
+    (projectionFormula bs out w a d P).Sat (M : Set ZFSet) e ↔
+      e out = realCode (fun n => Q (bitIndex bs n)) := by
+  have hs (x : ZFSet.{u}) (hx : x ∈ M) :
+      (fromBounded (projectionMember bs (w+1) (a+1) (d+1) (P+1) 0)).Sat
+        (M : Set ZFSet) (cons x e) ↔ x ∈ realCode (fun n => Q (bitIndex bs n)) := by
+    rw [bounded_sat,Formula.absolute _ M hM _
+      (by intro i; cases i; exact hx; exact he _)]
+    exact projectionMember_spec bs (w+1) (a+1) (d+1) (P+1) 0 (cons x e) hw ha hd Q hP
+  simp only [projectionFormula,SentenceForm.sat_all,SentenceForm.sat_iff,
+    SentenceForm.Sat,cons_zero,cons_succ]
+  constructor
+  · intro h
+    apply ZFSet.ext; intro x
+    constructor
+    · intro hx
+      have hxM := hM _ (he out) _ hx
+      exact (hs x hxM).mp ((h x hxM).mp hx)
+    · intro hx
+      have hxM := hM _ (hw ▸ he w) _ (realCode_subset _ hx)
+      exact (h x hxM).mpr ((hs x hxM).mpr hx)
+  · intro h x hx; rw [h]; exact (hs x hx).symm
+
+end TuringRigidity.RelativeConstructible
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/RecoverySetup.lean

@@ -0,0 +1,95 @@
+import OAI.Computability.DegreeRigidity.Representation.Endpoints
+
+namespace OAI
+
+open Set Filter Topology
+namespace TuringRigidity
+
+structure RecoveryData (F : ℝ → Oracle) (t u v : ℝ) where
+  radius : ℝ
+  radius_pos : 0 < radius
+  radius_lt_one : radius < 1
+  lo : ℝ
+  hi : ℝ
+  lo_gt : -radius < lo
+  lo_neg : lo < 0
+  hi_pos : 0 < hi
+  hi_lt : hi < radius
+  delta : ℚ
+  delta_pos : 0 < delta
+  delta_lt : (delta : ℝ) < radius
+  delta_gap : 3*(delta : ℝ) < hi-lo
+  bit : ℕ
+  forward : ℕ
+  backward : ℕ
+  left : ∀ s ∈ rationalSpan t, s ∈ Icc lo (lo+(delta : ℝ)) →
+    F (u+s) bit ≠ F (u+hi) bit
+  right : ∀ s ∈ rationalSpan t, s ∈ Icc (hi-(delta : ℝ)) hi →
+    F (u+s) bit = F (u+hi) bit
+  forward_correct : ∀ s ∈ rationalSpan t, ∀ a ∈ rationalSpan t,
+    |s| < radius → |a| < radius →
+      OracleCode.eval (oracleFunction (join (F (u+s)) (F (v-u+a))))
+        (codeEnumeration forward) = oracleFunction (F (v+s+a))
+  backward_correct : ∀ s ∈ rationalSpan t, |s| < radius →
+    OracleCode.eval (oracleFunction (join (F (v+s)) (F (u-v))))
+      (codeEnumeration backward) = oracleFunction (F (u+s))
+
+theorem recovery_data_exists (F : ℝ → Oracle) (hF : Measurable F)
+    (hfiber : ∀ B, {x | F x = B}.Countable)
+    (hadd : ∀ x y, Reduces (F (x+y)) (join (F x) (F y))) (t : ℝ) :
+    ∃ G : Set (ℝ × ℝ), G ∈ residual (ℝ × ℝ) ∧
+      ∀ p ∈ G, Nonempty (RecoveryData F t p.1 p.2) := by
+  obtain ⟨D,hD,hFD⟩ := measurable_continuousOn_residual F hF
+  obtain ⟨e,E,hE,he,hspec⟩ := addition_program_continuous_restriction F hF hadd
+  refine ⟨goodPairs t D E,goodPairs_residual t D E hD hE,?_⟩
+  rintro ⟨u,v⟩ hgood
+  obtain ⟨p,q,ρ,hρ,hρ1,hp,hq⟩ := fixed_local_programs F t u v D E e he hgood hspec
+  obtain ⟨lo,hi,j,δ,hloρ,hlo,hhi,hhiρ,hδ,hδρ,hgap,hleft,hright⟩ :=
+    exists_endpoint_bands F hfiber D hD hFD t u ρ hρ (fun s hs => (hgood s hs).1)
+  exact ⟨{
+    radius := ρ, radius_pos := hρ, radius_lt_one := hρ1,
+    lo := lo, hi := hi, lo_gt := hloρ, lo_neg := hlo, hi_pos := hhi, hi_lt := hhiρ,
+    delta := δ, delta_pos := hδ, delta_lt := hδρ, delta_gap := hgap,
+    bit := j, forward := p, backward := q,
+    left := hleft, right := hright, forward_correct := hp, backward_correct := hq }⟩
+
+namespace RecoveryData
+variable {F : ℝ → Oracle} {t u v : ℝ}
+
+def test (d : RecoveryData F t u v) (s : ℝ) : Bool :=
+  decide (F (u+s) d.bit = F (u+d.hi) d.bit)
+
+theorem bounded (d : RecoveryData F t u v) (ht0 : 0 < t) (ht1 : t < 1) (n : ℕ) :
+    state d.test (d.delta : ℝ) t n ∈ Icc d.lo d.hi := by
+  apply state_mem_Icc_on_span d.test d.delta t d.lo d.hi
+    (by exact_mod_cast d.delta_pos) ht0 ht1 d.lo_neg.le d.hi_pos.le
+  · intro s hs hb
+    simp [test, d.left s hs hb]
+  · intro s hs hb
+    simp [test, d.right s hs hb]
+
+theorem abs_state_lt (d : RecoveryData F t u v) (ht0 : 0 < t) (ht1 : t < 1) (n : ℕ) :
+    |state d.test (d.delta : ℝ) t n| < d.radius := by
+  obtain ⟨hl,hu⟩ := d.bounded ht0 ht1 n
+  exact abs_lt.mpr ⟨d.lo_gt.trans_le hl, hu.trans_lt d.hi_lt⟩
+
+theorem frequency_bound (d : RecoveryData F t u v) (ht0 : 0 < t) (ht1 : t < 1)
+    (n : ℕ) (hn : 0 < n) :
+    |t - (∑ k ∈ Finset.range n, branch d.test (d.delta : ℝ) t k) / (n : ℝ)| <
+      1 / ((n : ℝ) * (d.delta : ℝ)) := by
+  exact frequency_error d.test (d.delta : ℝ) t n
+    (by exact_mod_cast d.delta_pos) hn ((d.abs_state_lt ht0 ht1 n).trans d.radius_lt_one)
+
+theorem cut_search (d : RecoveryData F t u v) (ht : Irrational t) (ht0 : 0 < t)
+    (ht1 : t < 1) (q : ℚ) :
+    (q : ℝ) < t ↔ ∃ n : ℕ, 0 < n ∧ (q : ℝ) <
+      (∑ k ∈ Finset.range n, branch d.test (d.delta : ℝ) t k) / (n : ℝ) -
+        1 / ((n : ℝ) * (d.delta : ℝ)) := by
+  exact irrational_cut_iff_search t (d.delta : ℝ)
+    (fun n => (∑ k ∈ Finset.range n, branch d.test (d.delta : ℝ) t k) / (n : ℝ))
+    ht (by exact_mod_cast d.delta_pos) (fun n hn => d.frequency_bound ht0 ht1 n hn) q
+end RecoveryData
+
+end TuringRigidity
+
+end OAI

lean/OAI/Computability/DegreeRigidity/Computability/ScalarCoding.lean

@@ -0,0 +1,94 @@
+import OAI.Computability.DegreeRigidity.Computability.RationalCut
+
+namespace OAI
+
+namespace TuringRigidity
+namespace RationalCoding
+
+def scalarLeft (r : ℕ) (z : ℕ × ℕ) : ℕ :=
+  (positiveNumerator r*positiveNumerator z.2 + negativeNumerator r*negativeNumerator z.2)*denominator z.1 +
+    negativeNumerator z.1*denominator r*denominator z.2
+
+def scalarRight (r : ℕ) (z : ℕ × ℕ) : ℕ :=
+  (positiveNumerator r*negativeNumerator z.2 + negativeNumerator r*positiveNumerator z.2)*denominator z.1 +
+    positiveNumerator z.1*denominator r*denominator z.2
+
+private theorem scalarPolynomial_primrec (a b D : ℕ) {p q c : ℕ → ℕ}
+    (hp : Primrec p) (hq : Primrec q) (hc : Primrec c) :
+    Primrec (fun z : ℕ × ℕ => (a*p z.2+b*q z.2)*denominator z.1+c z.1*D*denominator z.2) :=
+  Primrec.nat_add.comp
+    (Primrec.nat_mul.comp
+      (Primrec.nat_add.comp (Primrec.nat_mul.comp (Primrec.const a) (hp.comp Primrec.snd))
+        (Primrec.nat_mul.comp (Primrec.const b) (hq.comp Primrec.snd)))
+      (denominator_primrec.comp Primrec.fst))
+    (Primrec.nat_mul.comp (Primrec.nat_mul.comp (hc.comp Primrec.fst) (Primrec.const D))
+      (denominator_primrec.comp Primrec.snd))
+
+theorem scalarLeft_primrec (r : ℕ) : Primrec (scalarLeft r) :=
+  scalarPolynomial_primrec _ _ _ positiveNumerator_primrec negativeNumerator_primrec negativeNumerator_primrec
+
+theorem scalarRight_primrec (r : ℕ) : Primrec (scalarRight r) :=
+  scalarPolynomial_primrec _ _ _ negativeNumerator_primrec positiveNumerator_primrec positiveNumerator_primrec
+
+theorem scalar_eq_iff (r i j : ℕ) : scalarLeft r (i,j)=scalarRight r (i,j) ↔
+    (rationalEnumeration r : ℝ)*(rationalEnumeration j : ℝ)=(rationalEnumeration i : ℝ) := by
+  have hr : (denominator r : ℝ) ≠ 0 := by exact_mod_cast (Nat.ne_of_gt (denominator_pos r))
+  have hi : (denominator i : ℝ) ≠ 0 := by exact_mod_cast (Nat.ne_of_gt (denominator_pos i))
+  have hj : (denominator j : ℝ) ≠ 0 := by exact_mod_cast (Nat.ne_of_gt (denominator_pos j))
+  rw [signed_query_value,signed_query_value,signed_query_value]
+  have he : ((positiveNumerator r : ℝ)-negativeNumerator r)/denominator r *
+      (((positiveNumerator j : ℝ)-negativeNumerator j)/denominator j) =
+      ((positiveNumerator i : ℝ)-negativeNumerator i)/denominator i ↔
+      (scalarLeft r (i,j) : ℝ)=(scalarRight r (i,j) : ℝ) := by
+    simp only [scalarLeft,scalarRight,Nat.cast_add,Nat.cast_mul]
+    field_simp
+    constructor <;> intro h <;> nlinarith
+  rw [he]
+  exact Nat.cast_inj.symm
+
+def divideIndex (r : ℚ) (i : ℕ) : ℕ := Encodable.encode (rationalEnumeration i/r)
+
+theorem divideIndex_value (r : ℚ) (i : ℕ) :
+    rationalEnumeration (divideIndex r i) = rationalEnumeration i/r := by
+  simp only [divideIndex,rationalEnumeration,Encodable.encodek,Option.getD_some]
+
+theorem divideIndex_recursive {O : Set (ℕ →. ℕ)} (r : ℚ) (hr : r ≠ 0) :
+    Nat.RecursiveIn O (fun i => Part.some (divideIndex r i)) := by
+  let ridx := Encodable.encode r
+  let E : ℕ → ℕ → Option ℕ := fun i j =>
+    if valid j ∧ scalarLeft ridx (i,j)=scalarRight ridx (i,j) then some j else none
+  have hE : Primrec (fun z : ℕ => Encodable.encode (E (Nat.unpair z).1 (Nat.unpair z).2)) :=
+    Primrec.encode.comp ((Primrec.ite ((valid_primrec.comp Primrec.snd).and
+      (Primrec.eq.comp (scalarLeft_primrec ridx) (scalarRight_primrec ridx)))
+      (Primrec.option_some.comp Primrec.snd) (Primrec.const none)).comp Primrec.unpair)
+  have hridx : rationalEnumeration ridx = r := by simp [ridx,rationalEnumeration]
+  apply UniformOracle.total_search (UniformOracle.total_primrec hE) (divideIndex r)
+  · intro i j a ha
+    dsimp only [E] at ha
+    split at ha
+    · rename_i h
+      have haj : a=j := by symm; simpa using ha
+      subst a
+      have he := (scalar_eq_iff ridx i j).mp h.2
+      rw [hridx] at he
+      have heq : r*rationalEnumeration j=rationalEnumeration i := by exact_mod_cast he
+      have hval : rationalEnumeration j=rationalEnumeration i/r :=
+        (eq_div_iff hr).mpr (by simpa [mul_comm] using heq)
+      have hj : canonicalCode j=j := ite_eq_left h.1
+      rw [canonicalCode_eq,hval] at hj
+      exact hj.symm
+    · simp at ha
+  · intro i
+    let j := divideIndex r i
+    have hv : valid j := (valid_iff j).mpr ⟨rationalEnumeration i/r,rfl⟩
+    have he : scalarLeft ridx (i,j)=scalarRight ridx (i,j) := by
+      apply (scalar_eq_iff ridx i j).mpr
+      rw [hridx,show rationalEnumeration j=rationalEnumeration i/r from divideIndex_value r i]
+      push_cast
+      field_simp
+    exact ⟨j,j,by simp [E,hv,he]⟩
+
+end RationalCoding
+end TuringRigidity
+
+end OAI