Split (1)

train · 213k rows

state stringlengths 0 159k	srcUpToTactic stringlengths 387 167k	nextTactic stringlengths 3 9k	declUpToTactic stringlengths 22 11.5k	declId stringlengths 38 95	decl stringlengths 16 1.89k	file_tag stringlengths 17 73
k₂ : ℕ c : Code n x : ℕ x✝ : 0 ≤ k₂ h : x ∈ evaln 0 c n ⊢ x ∈ evaln k₂ c n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by	simp [evaln] at h	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
k k₂ : ℕ c : Code n x : ℕ hl : k + 1 ≤ k₂ + 1 h : x ∈ evaln (k + 1) c n ⊢ x ∈ evaln (k₂ + 1) c n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by	have hl' := Nat.le_of_succ_le_succ hl	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
k k₂ : ℕ c : Code n x : ℕ hl : k + 1 ≤ k₂ + 1 h : x ∈ evaln (k + 1) c n hl' : k ≤ k₂ ⊢ x ∈ evaln (k₂ + 1) c n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl	have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
k k₂ : ℕ c : Code n x : ℕ hl : k + 1 ≤ k₂ + 1 h : x ∈ evaln (k + 1) c n hl' : k ≤ k₂ ⊢ ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by	simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp]	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
k k₂ : ℕ c : Code n x : ℕ hl : k + 1 ≤ k₂ + 1 h : x ∈ evaln (k + 1) c n hl' : k ≤ k₂ ⊢ ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (o₁ = some x → o₂ = some x) → n ≤ k → o₁ = some x → n ≤ k₂ ∧ o₂ = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp]	introv h h₁ h₂ h₃	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp]	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
k✝ k₂✝ : ℕ c : Code n✝ x✝ : ℕ hl : k✝ + 1 ≤ k₂✝ + 1 h✝ : x✝ ∈ evaln (k✝ + 1) c n✝ hl' : k✝ ≤ k₂✝ k k₂ n x : ℕ o₁ o₂ : Option ℕ h : k ≤ k₂ h₁ : o₁ = some x → o₂ = some x h₂ : n ≤ k h₃ : o₁ = some x ⊢ n ≤ k₂ ∧ o₂ = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃	exact ⟨le_trans h₂ h, h₁ h₃⟩	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
k k₂ : ℕ c : Code n x : ℕ hl : k + 1 ≤ k₂ + 1 h : x ∈ evaln (k + 1) c n hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ ⊢ x ∈ evaln (k₂ + 1) c n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩	simp? at h ⊢ says simp only [Option.mem_def] at h ⊢	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
k k₂ : ℕ c : Code n x : ℕ hl : k + 1 ≤ k₂ + 1 h : x ∈ evaln (k + 1) c n hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ ⊢ x ∈ evaln (k₂ + 1) c n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says	simp only [Option.mem_def] at h ⊢	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
k k₂ : ℕ c : Code n x : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ h : evaln (k + 1) c n = some x ⊢ evaln (k₂ + 1) c n = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢	induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case zero k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h : evaln (k + 1) zero n = some x ⊢ evaln (k₂ + 1) zero n = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	rw [evaln] at h ⊢	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case succ k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h : evaln (k + 1) succ n = some x ⊢ evaln (k₂ + 1) succ n = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	rw [evaln] at h ⊢	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case left k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h : evaln (k + 1) left n = some x ⊢ evaln (k₂ + 1) left n = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	rw [evaln] at h ⊢	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case right k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h : evaln (k + 1) right n = some x ⊢ evaln (k₂ + 1) right n = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	rw [evaln] at h ⊢	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case pair k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h : evaln (k + 1) (pair cf cg) n = some x ⊢ evaln (k₂ + 1) (pair cf cg) n = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	rw [evaln] at h ⊢	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case comp k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h : evaln (k + 1) (comp cf cg) n = some x ⊢ evaln (k₂ + 1) (comp cf cg) n = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	rw [evaln] at h ⊢	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case prec k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h : evaln (k + 1) (prec cf cg) n = some x ⊢ evaln (k₂ + 1) (prec cf cg) n = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	rw [evaln] at h ⊢	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case rfind' k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x n x : ℕ h : evaln (k + 1) (rfind' cf) n = some x ⊢ evaln (k₂ + 1) (rfind' cf) n = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	rw [evaln] at h ⊢	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case zero k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h : (fun n => do guard (n ≤ k) pure 0) n = some x ⊢ (fun n => do guard (n ≤ k₂) pure 0) n = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;>	refine' this hl' (fun h => _) h	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case succ k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h : (fun n => do guard (n ≤ k) pure (Nat.succ n)) n = some x ⊢ (fun n => do guard (n ≤ k₂) pure (Nat.succ n)) n = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;>	refine' this hl' (fun h => _) h	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case left k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h : (fun n => do guard (n ≤ k) pure (unpair n).1) n = some x ⊢ (fun n => do guard (n ≤ k₂) pure (unpair n).1) n = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;>	refine' this hl' (fun h => _) h	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case right k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h : (fun n => do guard (n ≤ k) pure (unpair n).2) n = some x ⊢ (fun n => do guard (n ≤ k₂) pure (unpair n).2) n = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;>	refine' this hl' (fun h => _) h	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case pair k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h : (fun n => do guard (n ≤ k) Seq.seq (Nat.pair <$> evaln (k + 1) cf n) fun x => evaln (k + 1) cg n) n = some x ⊢ (fun n => do guard (n ≤ k₂) Seq.seq (Nat.pair <$> evaln (k₂ + 1) cf n) fun x => evaln (k₂ + 1) cg n) n = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;>	refine' this hl' (fun h => _) h	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case comp k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h : (fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x) n = some x ⊢ (fun n => do guard (n ≤ k₂) let x ← evaln (k₂ + 1) cg n evaln (k₂ + 1) cf x) n = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;>	refine' this hl' (fun h => _) h	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case prec k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h : (fun n => do guard (n ≤ k) unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n) n = some x ⊢ (fun n => do guard (n ≤ k₂) unpaired (fun a n => Nat.casesOn n (evaln (k₂ + 1) cf a) fun y => do let i ← evaln k₂ (prec cf cg) (Nat.pair a y) evaln (k₂ + 1) cg (Nat.pair a (Nat.pair y i))) n) n = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;>	refine' this hl' (fun h => _) h	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case rfind' k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x n x : ℕ h : (fun n => do guard (n ≤ k) unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n) n = some x ⊢ (fun n => do guard (n ≤ k₂) unpaired (fun a m => do let x ← evaln (k₂ + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k₂ (rfind' cf) (Nat.pair a (m + 1))) n) n = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;>	refine' this hl' (fun h => _) h	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case zero k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h✝ : (fun n => do guard (n ≤ k) pure 0) n = some x h : x ∈ pure 0 ⊢ x ∈ pure 0 case succ k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h✝ : (fun n => do guard (n ≤ k) pure (Nat.succ n)) n = some x h : x ∈ pure (Nat.succ n) ⊢ x ∈ pure (Nat.succ n) case left k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h✝ : (fun n => do guard (n ≤ k) pure (unpair n).1) n = some x h : x ∈ pure (unpair n).1 ⊢ x ∈ pure (unpair n).1 case right k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h✝ : (fun n => do guard (n ≤ k) pure (unpair n).2) n = some x h : x ∈ pure (unpair n).2 ⊢ x ∈ pure (unpair n).2 case pair k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) Seq.seq (Nat.pair <$> evaln (k + 1) cf n) fun x => evaln (k + 1) cg n) n = some x h : x ∈ Seq.seq (Nat.pair <$> evaln (k + 1) cf n) fun x => evaln (k + 1) cg n ⊢ x ∈ Seq.seq (Nat.pair <$> evaln (k₂ + 1) cf n) fun x => evaln (k₂ + 1) cg n case comp k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x) n = some x h : x ∈ do let x ← evaln (k + 1) cg n evaln (k + 1) cf x ⊢ x ∈ do let x ← evaln (k₂ + 1) cg n evaln (k₂ + 1) cf x case prec k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n) n = some x h : x ∈ unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n ⊢ x ∈ unpaired (fun a n => Nat.casesOn n (evaln (k₂ + 1) cf a) fun y => do let i ← evaln k₂ (prec cf cg) (Nat.pair a y) evaln (k₂ + 1) cg (Nat.pair a (Nat.pair y i))) n case rfind' k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n) n = some x h : x ∈ unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n ⊢ x ∈ unpaired (fun a m => do let x ← evaln (k₂ + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k₂ (rfind' cf) (Nat.pair a (m + 1))) n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h	iterate 4 exact h	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case zero k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h✝ : (fun n => do guard (n ≤ k) pure 0) n = some x h : x ∈ pure 0 ⊢ x ∈ pure 0 case succ k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h✝ : (fun n => do guard (n ≤ k) pure (Nat.succ n)) n = some x h : x ∈ pure (Nat.succ n) ⊢ x ∈ pure (Nat.succ n) case left k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h✝ : (fun n => do guard (n ≤ k) pure (unpair n).1) n = some x h : x ∈ pure (unpair n).1 ⊢ x ∈ pure (unpair n).1 case right k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h✝ : (fun n => do guard (n ≤ k) pure (unpair n).2) n = some x h : x ∈ pure (unpair n).2 ⊢ x ∈ pure (unpair n).2 case pair k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) Seq.seq (Nat.pair <$> evaln (k + 1) cf n) fun x => evaln (k + 1) cg n) n = some x h : x ∈ Seq.seq (Nat.pair <$> evaln (k + 1) cf n) fun x => evaln (k + 1) cg n ⊢ x ∈ Seq.seq (Nat.pair <$> evaln (k₂ + 1) cf n) fun x => evaln (k₂ + 1) cg n case comp k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x) n = some x h : x ∈ do let x ← evaln (k + 1) cg n evaln (k + 1) cf x ⊢ x ∈ do let x ← evaln (k₂ + 1) cg n evaln (k₂ + 1) cf x case prec k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n) n = some x h : x ∈ unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n ⊢ x ∈ unpaired (fun a n => Nat.casesOn n (evaln (k₂ + 1) cf a) fun y => do let i ← evaln k₂ (prec cf cg) (Nat.pair a y) evaln (k₂ + 1) cg (Nat.pair a (Nat.pair y i))) n case rfind' k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n) n = some x h : x ∈ unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n ⊢ x ∈ unpaired (fun a m => do let x ← evaln (k₂ + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k₂ (rfind' cf) (Nat.pair a (m + 1))) n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4	exact h	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case succ k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h✝ : (fun n => do guard (n ≤ k) pure (Nat.succ n)) n = some x h : x ∈ pure (Nat.succ n) ⊢ x ∈ pure (Nat.succ n) case left k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h✝ : (fun n => do guard (n ≤ k) pure (unpair n).1) n = some x h : x ∈ pure (unpair n).1 ⊢ x ∈ pure (unpair n).1 case right k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h✝ : (fun n => do guard (n ≤ k) pure (unpair n).2) n = some x h : x ∈ pure (unpair n).2 ⊢ x ∈ pure (unpair n).2 case pair k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) Seq.seq (Nat.pair <$> evaln (k + 1) cf n) fun x => evaln (k + 1) cg n) n = some x h : x ∈ Seq.seq (Nat.pair <$> evaln (k + 1) cf n) fun x => evaln (k + 1) cg n ⊢ x ∈ Seq.seq (Nat.pair <$> evaln (k₂ + 1) cf n) fun x => evaln (k₂ + 1) cg n case comp k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x) n = some x h : x ∈ do let x ← evaln (k + 1) cg n evaln (k + 1) cf x ⊢ x ∈ do let x ← evaln (k₂ + 1) cg n evaln (k₂ + 1) cf x case prec k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n) n = some x h : x ∈ unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n ⊢ x ∈ unpaired (fun a n => Nat.casesOn n (evaln (k₂ + 1) cf a) fun y => do let i ← evaln k₂ (prec cf cg) (Nat.pair a y) evaln (k₂ + 1) cg (Nat.pair a (Nat.pair y i))) n case rfind' k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n) n = some x h : x ∈ unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n ⊢ x ∈ unpaired (fun a m => do let x ← evaln (k₂ + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k₂ (rfind' cf) (Nat.pair a (m + 1))) n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4	exact h	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case left k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h✝ : (fun n => do guard (n ≤ k) pure (unpair n).1) n = some x h : x ∈ pure (unpair n).1 ⊢ x ∈ pure (unpair n).1 case right k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h✝ : (fun n => do guard (n ≤ k) pure (unpair n).2) n = some x h : x ∈ pure (unpair n).2 ⊢ x ∈ pure (unpair n).2 case pair k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) Seq.seq (Nat.pair <$> evaln (k + 1) cf n) fun x => evaln (k + 1) cg n) n = some x h : x ∈ Seq.seq (Nat.pair <$> evaln (k + 1) cf n) fun x => evaln (k + 1) cg n ⊢ x ∈ Seq.seq (Nat.pair <$> evaln (k₂ + 1) cf n) fun x => evaln (k₂ + 1) cg n case comp k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x) n = some x h : x ∈ do let x ← evaln (k + 1) cg n evaln (k + 1) cf x ⊢ x ∈ do let x ← evaln (k₂ + 1) cg n evaln (k₂ + 1) cf x case prec k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n) n = some x h : x ∈ unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n ⊢ x ∈ unpaired (fun a n => Nat.casesOn n (evaln (k₂ + 1) cf a) fun y => do let i ← evaln k₂ (prec cf cg) (Nat.pair a y) evaln (k₂ + 1) cg (Nat.pair a (Nat.pair y i))) n case rfind' k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n) n = some x h : x ∈ unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n ⊢ x ∈ unpaired (fun a m => do let x ← evaln (k₂ + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k₂ (rfind' cf) (Nat.pair a (m + 1))) n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4	exact h	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case right k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ n x : ℕ h✝ : (fun n => do guard (n ≤ k) pure (unpair n).2) n = some x h : x ∈ pure (unpair n).2 ⊢ x ∈ pure (unpair n).2 case pair k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) Seq.seq (Nat.pair <$> evaln (k + 1) cf n) fun x => evaln (k + 1) cg n) n = some x h : x ∈ Seq.seq (Nat.pair <$> evaln (k + 1) cf n) fun x => evaln (k + 1) cg n ⊢ x ∈ Seq.seq (Nat.pair <$> evaln (k₂ + 1) cf n) fun x => evaln (k₂ + 1) cg n case comp k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x) n = some x h : x ∈ do let x ← evaln (k + 1) cg n evaln (k + 1) cf x ⊢ x ∈ do let x ← evaln (k₂ + 1) cg n evaln (k₂ + 1) cf x case prec k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n) n = some x h : x ∈ unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n ⊢ x ∈ unpaired (fun a n => Nat.casesOn n (evaln (k₂ + 1) cf a) fun y => do let i ← evaln k₂ (prec cf cg) (Nat.pair a y) evaln (k₂ + 1) cg (Nat.pair a (Nat.pair y i))) n case rfind' k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n) n = some x h : x ∈ unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n ⊢ x ∈ unpaired (fun a m => do let x ← evaln (k₂ + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k₂ (rfind' cf) (Nat.pair a (m + 1))) n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4	exact h	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case pair k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) Seq.seq (Nat.pair <$> evaln (k + 1) cf n) fun x => evaln (k + 1) cg n) n = some x h : x ∈ Seq.seq (Nat.pair <$> evaln (k + 1) cf n) fun x => evaln (k + 1) cg n ⊢ x ∈ Seq.seq (Nat.pair <$> evaln (k₂ + 1) cf n) fun x => evaln (k₂ + 1) cg n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg	simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case pair k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) Seq.seq (Nat.pair <$> evaln (k + 1) cf n) fun x => evaln (k + 1) cg n) n = some x h : x ∈ Seq.seq (Nat.pair <$> evaln (k + 1) cf n) fun x => evaln (k + 1) cg n ⊢ x ∈ Seq.seq (Nat.pair <$> evaln (k₂ + 1) cf n) fun x => evaln (k₂ + 1) cg n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says	simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case pair k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) Seq.seq (Nat.pair <$> evaln (k + 1) cf n) fun x => evaln (k + 1) cg n) n = some x h : ∃ a, evaln (k + 1) cf n = some a ∧ ∃ a_1, evaln (k + 1) cg n = some a_1 ∧ Nat.pair a a_1 = x ⊢ ∃ a, evaln (k₂ + 1) cf n = some a ∧ ∃ a_1, evaln (k₂ + 1) cg n = some a_1 ∧ Nat.pair a a_1 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢	exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _)	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case comp k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x) n = some x h : x ∈ do let x ← evaln (k + 1) cg n evaln (k + 1) cf x ⊢ x ∈ do let x ← evaln (k₂ + 1) cg n evaln (k₂ + 1) cf x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg	simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case comp k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x) n = some x h : x ∈ do let x ← evaln (k + 1) cg n evaln (k + 1) cf x ⊢ x ∈ do let x ← evaln (k₂ + 1) cg n evaln (k₂ + 1) cf x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says	simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case comp k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x) n = some x h : ∃ a, evaln (k + 1) cg n = some a ∧ evaln (k + 1) cf a = some x ⊢ ∃ a, evaln (k₂ + 1) cg n = some a ∧ evaln (k₂ + 1) cf a = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢	exact h.imp fun a => And.imp (hg _ _) (hf _ _)	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case prec k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n) n = some x h : x ∈ unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n ⊢ x ∈ unpaired (fun a n => Nat.casesOn n (evaln (k₂ + 1) cf a) fun y => do let i ← evaln k₂ (prec cf cg) (Nat.pair a y) evaln (k₂ + 1) cg (Nat.pair a (Nat.pair y i))) n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg	revert h	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case prec k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h : (fun n => do guard (n ≤ k) unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n) n = some x ⊢ x ∈ unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n → x ∈ unpaired (fun a n => Nat.casesOn n (evaln (k₂ + 1) cf a) fun y => do let i ← evaln k₂ (prec cf cg) (Nat.pair a y) evaln (k₂ + 1) cg (Nat.pair a (Nat.pair y i))) n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h	simp only [unpaired, bind, Option.mem_def]	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case prec k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h : (fun n => do guard (n ≤ k) unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n) n = some x ⊢ Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) (unpair n).2 = some x → Nat.rec (evaln (k₂ + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k₂ (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k₂ + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) (unpair n).2 = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def]	induction n.unpair.2	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def]	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case prec.zero k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h : (fun n => do guard (n ≤ k) unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n) n = some x ⊢ Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) Nat.zero = some x → Nat.rec (evaln (k₂ + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k₂ (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k₂ + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) Nat.zero = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;>	simp	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case prec.succ k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h : (fun n => do guard (n ≤ k) unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n) n = some x n✝ : ℕ n_ih✝ : Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) n✝ = some x → Nat.rec (evaln (k₂ + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k₂ (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k₂ + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) n✝ = some x ⊢ Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) (Nat.succ n✝) = some x → Nat.rec (evaln (k₂ + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k₂ (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k₂ + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) (Nat.succ n✝) = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;>	simp	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case prec.zero k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h : (fun n => do guard (n ≤ k) unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n) n = some x ⊢ evaln (k + 1) cf (unpair n).1 = some x → evaln (k₂ + 1) cf (unpair n).1 = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp ·	apply hf	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp ·	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case prec.succ k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf cg : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x hg : ∀ (n x : ℕ), evaln (k + 1) cg n = some x → evaln (k₂ + 1) cg n = some x n x : ℕ h : (fun n => do guard (n ≤ k) unpaired (fun a n => Nat.casesOn n (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i))) n) n = some x n✝ : ℕ n_ih✝ : Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) n✝ = some x → Nat.rec (evaln (k₂ + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k₂ (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k₂ + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) n✝ = some x ⊢ ∀ (x_1 : ℕ), evaln k (prec cf cg) (Nat.pair (unpair n).1 n✝) = some x_1 → evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n✝ x_1)) = some x → ∃ a, evaln k₂ (prec cf cg) (Nat.pair (unpair n).1 n✝) = some a ∧ evaln (k₂ + 1) cg (Nat.pair (unpair n).1 (Nat.pair n✝ a)) = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf ·	exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf ·	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case rfind' k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n) n = some x h : x ∈ unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n ⊢ x ∈ unpaired (fun a m => do let x ← evaln (k₂ + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k₂ (rfind' cf) (Nat.pair a (m + 1))) n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf	simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case rfind' k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n) n = some x h : x ∈ unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n ⊢ x ∈ unpaired (fun a m => do let x ← evaln (k₂ + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k₂ (rfind' cf) (Nat.pair a (m + 1))) n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says	simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case rfind' k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x n x : ℕ h✝ : (fun n => do guard (n ≤ k) unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n) n = some x h : ∃ a, evaln (k + 1) cf n = some a ∧ (if a = 0 then pure (unpair n).2 else evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x ⊢ ∃ a, evaln (k₂ + 1) cf n = some a ∧ (if a = 0 then pure (unpair n).2 else evaln k₂ (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢	refine' h.imp fun x => And.imp (hf _ _) _	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case rfind' k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x n x✝ : ℕ h✝ : (fun n => do guard (n ≤ k) unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n) n = some x✝ h : ∃ a, evaln (k + 1) cf n = some a ∧ (if a = 0 then pure (unpair n).2 else evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x✝ x : ℕ ⊢ (if x = 0 then pure (unpair n).2 else evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x✝ → (if x = 0 then pure (unpair n).2 else evaln k₂ (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x✝	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _	by_cases x0 : x = 0	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case pos k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x n x✝ : ℕ h✝ : (fun n => do guard (n ≤ k) unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n) n = some x✝ h : ∃ a, evaln (k + 1) cf n = some a ∧ (if a = 0 then pure (unpair n).2 else evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x✝ x : ℕ x0 : x = 0 ⊢ (if x = 0 then pure (unpair n).2 else evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x✝ → (if x = 0 then pure (unpair n).2 else evaln k₂ (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x✝	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;>	simp [x0]	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case neg k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x n x✝ : ℕ h✝ : (fun n => do guard (n ≤ k) unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n) n = some x✝ h : ∃ a, evaln (k + 1) cf n = some a ∧ (if a = 0 then pure (unpair n).2 else evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x✝ x : ℕ x0 : ¬x = 0 ⊢ (if x = 0 then pure (unpair n).2 else evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x✝ → (if x = 0 then pure (unpair n).2 else evaln k₂ (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x✝	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;>	simp [x0]	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;>	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
case neg k k₂ : ℕ hl : k + 1 ≤ k₂ + 1 hl' : k ≤ k₂ this : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → (x ∈ do guard (n ≤ k) o₁) → x ∈ do guard (n ≤ k₂) o₂ cf : Code hf : ∀ (n x : ℕ), evaln (k + 1) cf n = some x → evaln (k₂ + 1) cf n = some x n x✝ : ℕ h✝ : (fun n => do guard (n ≤ k) unpaired (fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1))) n) n = some x✝ h : ∃ a, evaln (k + 1) cf n = some a ∧ (if a = 0 then pure (unpair n).2 else evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x✝ x : ℕ x0 : ¬x = 0 ⊢ evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1)) = some x✝ → evaln k₂ (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1)) = some x✝	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0]	exact evaln_mono hl'	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0]	Mathlib.Computability.PartrecCode.783_0.A3c3Aev6SyIRjCJ	theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl'	Mathlib_Computability_PartrecCode
x✝ : Code n x : ℕ h : x ∈ evaln 0 x✝ n ⊢ x ∈ eval x✝ n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by	simp [evaln] at h	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
k : ℕ c : Code n x : ℕ h : x ∈ evaln (k + 1) c n ⊢ x ∈ eval c n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by	induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case zero k n x : ℕ h : x ∈ evaln (k + 1) zero n ⊢ x ∈ eval zero n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case succ k n x : ℕ h : x ∈ evaln (k + 1) succ n ⊢ x ∈ eval succ n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case left k n x : ℕ h : x ∈ evaln (k + 1) left n ⊢ x ∈ eval left n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case right k n x : ℕ h : x ∈ evaln (k + 1) right n ⊢ x ∈ eval right n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case pair k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ h : x ∈ evaln (k + 1) (pair cf cg) n ⊢ x ∈ eval (pair cf cg) n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case comp k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ h : x ∈ evaln (k + 1) (comp cf cg) n ⊢ x ∈ eval (comp cf cg) n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case prec k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ h : x ∈ evaln (k + 1) (prec cf cg) n ⊢ x ∈ eval (prec cf cg) n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case rfind' k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n x : ℕ h : x ∈ evaln (k + 1) (rfind' cf) n ⊢ x ∈ eval (rfind' cf) n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case zero k n x : ℕ h : n ≤ k ∧ pure 0 = some x ⊢ x ∈ pure 0 n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;>	cases' h with _ h	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case succ k n x : ℕ h : n ≤ k ∧ pure (Nat.succ n) = some x ⊢ x = Nat.succ n	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;>	cases' h with _ h	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case left k n x : ℕ h : n ≤ k ∧ pure (unpair n).1 = some x ⊢ x = (unpair n).1	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;>	cases' h with _ h	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case right k n x : ℕ h : n ≤ k ∧ pure (unpair n).2 = some x ⊢ x = (unpair n).2	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;>	cases' h with _ h	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case pair k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ h : n ≤ k ∧ ∃ a, evaln (k + 1) cf n = some a ∧ ∃ a_1, evaln (k + 1) cg n = some a_1 ∧ Nat.pair a a_1 = x ⊢ ∃ a ∈ eval cf n, ∃ a_1 ∈ eval cg n, Nat.pair a a_1 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;>	cases' h with _ h	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case comp k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ h : n ≤ k ∧ ∃ a, evaln (k + 1) cg n = some a ∧ evaln (k + 1) cf a = some x ⊢ ∃ a ∈ eval cg n, x ∈ eval cf a	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;>	cases' h with _ h	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case prec k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ h : n ≤ k ∧ Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) (unpair n).2 = some x ⊢ x ∈ Nat.rec (eval cf (unpair n).1) (fun y IH => Part.bind IH fun i => eval cg (Nat.pair (unpair n).1 (Nat.pair y i))) (unpair n).2	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;>	cases' h with _ h	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case rfind' k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n x : ℕ h : n ≤ k ∧ ∃ a, evaln (k + 1) cf n = some a ∧ (if a = 0 then pure (unpair n).2 else evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x ⊢ ∃ a, (0 ∈ eval cf (Nat.pair (unpair n).1 (a + (unpair n).2)) ∧ ∀ {m : ℕ}, m < a → ∃ a ∈ eval cf (Nat.pair (unpair n).1 (m + (unpair n).2)), ¬a = 0) ∧ a + (unpair n).2 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;>	cases' h with _ h	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case zero.intro k n x : ℕ left✝ : n ≤ k h : pure 0 = some x ⊢ x ∈ pure 0 n case succ.intro k n x : ℕ left✝ : n ≤ k h : pure (Nat.succ n) = some x ⊢ x = Nat.succ n case left.intro k n x : ℕ left✝ : n ≤ k h : pure (unpair n).1 = some x ⊢ x = (unpair n).1 case right.intro k n x : ℕ left✝ : n ≤ k h : pure (unpair n).2 = some x ⊢ x = (unpair n).2 case pair.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k h : ∃ a, evaln (k + 1) cf n = some a ∧ ∃ a_1, evaln (k + 1) cg n = some a_1 ∧ Nat.pair a a_1 = x ⊢ ∃ a ∈ eval cf n, ∃ a_1 ∈ eval cg n, Nat.pair a a_1 = x case comp.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k h : ∃ a, evaln (k + 1) cg n = some a ∧ evaln (k + 1) cf a = some x ⊢ ∃ a ∈ eval cg n, x ∈ eval cf a case prec.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k h : Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) (unpair n).2 = some x ⊢ x ∈ Nat.rec (eval cf (unpair n).1) (fun y IH => Part.bind IH fun i => eval cg (Nat.pair (unpair n).1 (Nat.pair y i))) (unpair n).2 case rfind'.intro k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n x : ℕ left✝ : n ≤ k h : ∃ a, evaln (k + 1) cf n = some a ∧ (if a = 0 then pure (unpair n).2 else evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x ⊢ ∃ a, (0 ∈ eval cf (Nat.pair (unpair n).1 (a + (unpair n).2)) ∧ ∀ {m : ℕ}, m < a → ∃ a ∈ eval cf (Nat.pair (unpair n).1 (m + (unpair n).2)), ¬a = 0) ∧ a + (unpair n).2 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h	iterate 4 simpa [pure, PFun.pure, eq_comm] using h	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case zero.intro k n x : ℕ left✝ : n ≤ k h : pure 0 = some x ⊢ x ∈ pure 0 n case succ.intro k n x : ℕ left✝ : n ≤ k h : pure (Nat.succ n) = some x ⊢ x = Nat.succ n case left.intro k n x : ℕ left✝ : n ≤ k h : pure (unpair n).1 = some x ⊢ x = (unpair n).1 case right.intro k n x : ℕ left✝ : n ≤ k h : pure (unpair n).2 = some x ⊢ x = (unpair n).2 case pair.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k h : ∃ a, evaln (k + 1) cf n = some a ∧ ∃ a_1, evaln (k + 1) cg n = some a_1 ∧ Nat.pair a a_1 = x ⊢ ∃ a ∈ eval cf n, ∃ a_1 ∈ eval cg n, Nat.pair a a_1 = x case comp.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k h : ∃ a, evaln (k + 1) cg n = some a ∧ evaln (k + 1) cf a = some x ⊢ ∃ a ∈ eval cg n, x ∈ eval cf a case prec.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k h : Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) (unpair n).2 = some x ⊢ x ∈ Nat.rec (eval cf (unpair n).1) (fun y IH => Part.bind IH fun i => eval cg (Nat.pair (unpair n).1 (Nat.pair y i))) (unpair n).2 case rfind'.intro k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n x : ℕ left✝ : n ≤ k h : ∃ a, evaln (k + 1) cf n = some a ∧ (if a = 0 then pure (unpair n).2 else evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x ⊢ ∃ a, (0 ∈ eval cf (Nat.pair (unpair n).1 (a + (unpair n).2)) ∧ ∀ {m : ℕ}, m < a → ∃ a ∈ eval cf (Nat.pair (unpair n).1 (m + (unpair n).2)), ¬a = 0) ∧ a + (unpair n).2 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4	simpa [pure, PFun.pure, eq_comm] using h	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case succ.intro k n x : ℕ left✝ : n ≤ k h : pure (Nat.succ n) = some x ⊢ x = Nat.succ n case left.intro k n x : ℕ left✝ : n ≤ k h : pure (unpair n).1 = some x ⊢ x = (unpair n).1 case right.intro k n x : ℕ left✝ : n ≤ k h : pure (unpair n).2 = some x ⊢ x = (unpair n).2 case pair.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k h : ∃ a, evaln (k + 1) cf n = some a ∧ ∃ a_1, evaln (k + 1) cg n = some a_1 ∧ Nat.pair a a_1 = x ⊢ ∃ a ∈ eval cf n, ∃ a_1 ∈ eval cg n, Nat.pair a a_1 = x case comp.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k h : ∃ a, evaln (k + 1) cg n = some a ∧ evaln (k + 1) cf a = some x ⊢ ∃ a ∈ eval cg n, x ∈ eval cf a case prec.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k h : Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) (unpair n).2 = some x ⊢ x ∈ Nat.rec (eval cf (unpair n).1) (fun y IH => Part.bind IH fun i => eval cg (Nat.pair (unpair n).1 (Nat.pair y i))) (unpair n).2 case rfind'.intro k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n x : ℕ left✝ : n ≤ k h : ∃ a, evaln (k + 1) cf n = some a ∧ (if a = 0 then pure (unpair n).2 else evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x ⊢ ∃ a, (0 ∈ eval cf (Nat.pair (unpair n).1 (a + (unpair n).2)) ∧ ∀ {m : ℕ}, m < a → ∃ a ∈ eval cf (Nat.pair (unpair n).1 (m + (unpair n).2)), ¬a = 0) ∧ a + (unpair n).2 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4	simpa [pure, PFun.pure, eq_comm] using h	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case left.intro k n x : ℕ left✝ : n ≤ k h : pure (unpair n).1 = some x ⊢ x = (unpair n).1 case right.intro k n x : ℕ left✝ : n ≤ k h : pure (unpair n).2 = some x ⊢ x = (unpair n).2 case pair.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k h : ∃ a, evaln (k + 1) cf n = some a ∧ ∃ a_1, evaln (k + 1) cg n = some a_1 ∧ Nat.pair a a_1 = x ⊢ ∃ a ∈ eval cf n, ∃ a_1 ∈ eval cg n, Nat.pair a a_1 = x case comp.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k h : ∃ a, evaln (k + 1) cg n = some a ∧ evaln (k + 1) cf a = some x ⊢ ∃ a ∈ eval cg n, x ∈ eval cf a case prec.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k h : Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) (unpair n).2 = some x ⊢ x ∈ Nat.rec (eval cf (unpair n).1) (fun y IH => Part.bind IH fun i => eval cg (Nat.pair (unpair n).1 (Nat.pair y i))) (unpair n).2 case rfind'.intro k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n x : ℕ left✝ : n ≤ k h : ∃ a, evaln (k + 1) cf n = some a ∧ (if a = 0 then pure (unpair n).2 else evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x ⊢ ∃ a, (0 ∈ eval cf (Nat.pair (unpair n).1 (a + (unpair n).2)) ∧ ∀ {m : ℕ}, m < a → ∃ a ∈ eval cf (Nat.pair (unpair n).1 (m + (unpair n).2)), ¬a = 0) ∧ a + (unpair n).2 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4	simpa [pure, PFun.pure, eq_comm] using h	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case right.intro k n x : ℕ left✝ : n ≤ k h : pure (unpair n).2 = some x ⊢ x = (unpair n).2 case pair.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k h : ∃ a, evaln (k + 1) cf n = some a ∧ ∃ a_1, evaln (k + 1) cg n = some a_1 ∧ Nat.pair a a_1 = x ⊢ ∃ a ∈ eval cf n, ∃ a_1 ∈ eval cg n, Nat.pair a a_1 = x case comp.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k h : ∃ a, evaln (k + 1) cg n = some a ∧ evaln (k + 1) cf a = some x ⊢ ∃ a ∈ eval cg n, x ∈ eval cf a case prec.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k h : Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) (unpair n).2 = some x ⊢ x ∈ Nat.rec (eval cf (unpair n).1) (fun y IH => Part.bind IH fun i => eval cg (Nat.pair (unpair n).1 (Nat.pair y i))) (unpair n).2 case rfind'.intro k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n x : ℕ left✝ : n ≤ k h : ∃ a, evaln (k + 1) cf n = some a ∧ (if a = 0 then pure (unpair n).2 else evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x ⊢ ∃ a, (0 ∈ eval cf (Nat.pair (unpair n).1 (a + (unpair n).2)) ∧ ∀ {m : ℕ}, m < a → ∃ a ∈ eval cf (Nat.pair (unpair n).1 (m + (unpair n).2)), ¬a = 0) ∧ a + (unpair n).2 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4	simpa [pure, PFun.pure, eq_comm] using h	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case pair.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k h : ∃ a, evaln (k + 1) cf n = some a ∧ ∃ a_1, evaln (k + 1) cg n = some a_1 ∧ Nat.pair a a_1 = x ⊢ ∃ a ∈ eval cf n, ∃ a_1 ∈ eval cg n, Nat.pair a a_1 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg	rcases h with ⟨y, ef, z, eg, rfl⟩	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case pair.intro.intro.intro.intro.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n : ℕ left✝ : n ≤ k y : ℕ ef : evaln (k + 1) cf n = some y z : ℕ eg : evaln (k + 1) cg n = some z ⊢ ∃ a ∈ eval cf n, ∃ a_1 ∈ eval cg n, Nat.pair a a_1 = Nat.pair y z	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩	exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case comp.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k h : ∃ a, evaln (k + 1) cg n = some a ∧ evaln (k + 1) cf a = some x ⊢ ∃ a ∈ eval cg n, x ∈ eval cf a	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg	rcases h with ⟨y, eg, ef⟩	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case comp.intro.intro.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k y : ℕ eg : evaln (k + 1) cg n = some y ef : evaln (k + 1) cf y = some x ⊢ ∃ a ∈ eval cg n, x ∈ eval cf a	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩	exact ⟨_, hg _ _ eg, hf _ _ ef⟩	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case prec.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k h : Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) (unpair n).2 = some x ⊢ x ∈ Nat.rec (eval cf (unpair n).1) (fun y IH => Part.bind IH fun i => eval cg (Nat.pair (unpair n).1 (Nat.pair y i))) (unpair n).2	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg	revert h	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case prec.intro k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n x : ℕ left✝ : n ≤ k ⊢ Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) (unpair n).2 = some x → x ∈ Nat.rec (eval cf (unpair n).1) (fun y IH => Part.bind IH fun i => eval cg (Nat.pair (unpair n).1 (Nat.pair y i))) (unpair n).2	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h	induction' n.unpair.2 with m IH generalizing x	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case prec.intro.zero k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n : ℕ left✝ : n ≤ k x : ℕ ⊢ Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) Nat.zero = some x → x ∈ Nat.rec (eval cf (unpair n).1) (fun y IH => Part.bind IH fun i => eval cg (Nat.pair (unpair n).1 (Nat.pair y i))) Nat.zero	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;>	simp	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case prec.intro.succ k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n : ℕ left✝ : n ≤ k m : ℕ IH : ∀ (x : ℕ), Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) m = some x → x ∈ Nat.rec (eval cf (unpair n).1) (fun y IH => Part.bind IH fun i => eval cg (Nat.pair (unpair n).1 (Nat.pair y i))) m x : ℕ ⊢ Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) (Nat.succ m) = some x → x ∈ Nat.rec (eval cf (unpair n).1) (fun y IH => Part.bind IH fun i => eval cg (Nat.pair (unpair n).1 (Nat.pair y i))) (Nat.succ m)	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;>	simp	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case prec.intro.zero k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n : ℕ left✝ : n ≤ k x : ℕ ⊢ evaln (k + 1) cf (unpair n).1 = some x → x ∈ eval cf (unpair n).1	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp ·	apply hf	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp ·	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case prec.intro.succ k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n : ℕ left✝ : n ≤ k m : ℕ IH : ∀ (x : ℕ), Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) m = some x → x ∈ Nat.rec (eval cf (unpair n).1) (fun y IH => Part.bind IH fun i => eval cg (Nat.pair (unpair n).1 (Nat.pair y i))) m x : ℕ ⊢ ∀ (x_1 : ℕ), evaln k (prec cf cg) (Nat.pair (unpair n).1 m) = some x_1 → evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair m x_1)) = some x → ∃ a ∈ Nat.rec (eval cf (unpair n).1) (fun y IH => Part.bind IH fun i => eval cg (Nat.pair (unpair n).1 (Nat.pair y i))) m, x ∈ eval cg (Nat.pair (unpair n).1 (Nat.pair m a))	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf ·	refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf ·	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case prec.intro.succ.refine'_1 k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n : ℕ left✝ : n ≤ k m : ℕ IH : ∀ (x : ℕ), Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) m = some x → x ∈ Nat.rec (eval cf (unpair n).1) (fun y IH => Part.bind IH fun i => eval cg (Nat.pair (unpair n).1 (Nat.pair y i))) m x y : ℕ h₁ : evaln k (prec cf cg) (Nat.pair (unpair n).1 m) = some y h₂ : evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair m y)) = some x ⊢ Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) m = some y	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ ·	have := evaln_mono k.le_succ h₁	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ ·	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case prec.intro.succ.refine'_1 k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n : ℕ left✝ : n ≤ k m : ℕ IH : ∀ (x : ℕ), Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) m = some x → x ∈ Nat.rec (eval cf (unpair n).1) (fun y IH => Part.bind IH fun i => eval cg (Nat.pair (unpair n).1 (Nat.pair y i))) m x y : ℕ h₁ : evaln k (prec cf cg) (Nat.pair (unpair n).1 m) = some y h₂ : evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair m y)) = some x this : y ∈ evaln (Nat.succ k) (prec cf cg) (Nat.pair (unpair n).1 m) ⊢ Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) m = some y	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁	simp [evaln, Bind.bind] at this	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case prec.intro.succ.refine'_1 k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n : ℕ left✝ : n ≤ k m : ℕ IH : ∀ (x : ℕ), Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) m = some x → x ∈ Nat.rec (eval cf (unpair n).1) (fun y IH => Part.bind IH fun i => eval cg (Nat.pair (unpair n).1 (Nat.pair y i))) m x y : ℕ h₁ : evaln k (prec cf cg) (Nat.pair (unpair n).1 m) = some y h₂ : evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair m y)) = some x this : Nat.pair (unpair n).1 m ≤ k ∧ Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) m = some y ⊢ Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) m = some y	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this	exact this.2	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case prec.intro.succ.refine'_2 k : ℕ cf cg : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n hg : ∀ (n x : ℕ), x ∈ evaln (k + 1) cg n → x ∈ eval cg n n : ℕ left✝ : n ≤ k m : ℕ IH : ∀ (x : ℕ), Nat.rec (evaln (k + 1) cf (unpair n).1) (fun n_1 n_ih => Option.bind (evaln k (prec cf cg) (Nat.pair (unpair n).1 n_1)) fun i => evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair n_1 i))) m = some x → x ∈ Nat.rec (eval cf (unpair n).1) (fun y IH => Part.bind IH fun i => eval cg (Nat.pair (unpair n).1 (Nat.pair y i))) m x y : ℕ h₁ : evaln k (prec cf cg) (Nat.pair (unpair n).1 m) = some y h₂ : evaln (k + 1) cg (Nat.pair (unpair n).1 (Nat.pair m y)) = some x ⊢ x ∈ eval cg (Nat.pair (unpair n).1 (Nat.pair m y))	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 ·	exact hg _ _ h₂	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 ·	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case rfind'.intro k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n x : ℕ left✝ : n ≤ k h : ∃ a, evaln (k + 1) cf n = some a ∧ (if a = 0 then pure (unpair n).2 else evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x ⊢ ∃ a, (0 ∈ eval cf (Nat.pair (unpair n).1 (a + (unpair n).2)) ∧ ∀ {m : ℕ}, m < a → ∃ a ∈ eval cf (Nat.pair (unpair n).1 (m + (unpair n).2)), ¬a = 0) ∧ a + (unpair n).2 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf	rcases h with ⟨m, h₁, h₂⟩	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case rfind'.intro.intro.intro k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n x : ℕ left✝ : n ≤ k m : ℕ h₁ : evaln (k + 1) cf n = some m h₂ : (if m = 0 then pure (unpair n).2 else evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x ⊢ ∃ a, (0 ∈ eval cf (Nat.pair (unpair n).1 (a + (unpair n).2)) ∧ ∀ {m : ℕ}, m < a → ∃ a ∈ eval cf (Nat.pair (unpair n).1 (m + (unpair n).2)), ¬a = 0) ∧ a + (unpair n).2 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩	by_cases m0 : m = 0	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case pos k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n x : ℕ left✝ : n ≤ k m : ℕ h₁ : evaln (k + 1) cf n = some m h₂ : (if m = 0 then pure (unpair n).2 else evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x m0 : m = 0 ⊢ ∃ a, (0 ∈ eval cf (Nat.pair (unpair n).1 (a + (unpair n).2)) ∧ ∀ {m : ℕ}, m < a → ∃ a ∈ eval cf (Nat.pair (unpair n).1 (m + (unpair n).2)), ¬a = 0) ∧ a + (unpair n).2 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;>	simp [m0] at h₂	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case neg k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n x : ℕ left✝ : n ≤ k m : ℕ h₁ : evaln (k + 1) cf n = some m h₂ : (if m = 0 then pure (unpair n).2 else evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1))) = some x m0 : ¬m = 0 ⊢ ∃ a, (0 ∈ eval cf (Nat.pair (unpair n).1 (a + (unpair n).2)) ∧ ∀ {m : ℕ}, m < a → ∃ a ∈ eval cf (Nat.pair (unpair n).1 (m + (unpair n).2)), ¬a = 0) ∧ a + (unpair n).2 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;>	simp [m0] at h₂	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;>	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case pos k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n x : ℕ left✝ : n ≤ k m : ℕ h₁ : evaln (k + 1) cf n = some m m0 : m = 0 h₂ : pure (unpair n).2 = some x ⊢ ∃ a, (0 ∈ eval cf (Nat.pair (unpair n).1 (a + (unpair n).2)) ∧ ∀ {m : ℕ}, m < a → ∃ a ∈ eval cf (Nat.pair (unpair n).1 (m + (unpair n).2)), ¬a = 0) ∧ a + (unpair n).2 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;> simp [m0] at h₂ ·	exact ⟨0, ⟨by simpa [m0] using hf _ _ h₁, fun {m} => (Nat.not_lt_zero _).elim⟩, by injection h₂ with h₂; simp [h₂]⟩	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;> simp [m0] at h₂ ·	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n x : ℕ left✝ : n ≤ k m : ℕ h₁ : evaln (k + 1) cf n = some m m0 : m = 0 h₂ : pure (unpair n).2 = some x ⊢ 0 ∈ eval cf (Nat.pair (unpair n).1 (0 + (unpair n).2))	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;> simp [m0] at h₂ · exact ⟨0, ⟨by	simpa [m0] using hf _ _ h₁	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;> simp [m0] at h₂ · exact ⟨0, ⟨by	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n x : ℕ left✝ : n ≤ k m : ℕ h₁ : evaln (k + 1) cf n = some m m0 : m = 0 h₂ : pure (unpair n).2 = some x ⊢ 0 + (unpair n).2 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;> simp [m0] at h₂ · exact ⟨0, ⟨by simpa [m0] using hf _ _ h₁, fun {m} => (Nat.not_lt_zero _).elim⟩, by	injection h₂ with h₂	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;> simp [m0] at h₂ · exact ⟨0, ⟨by simpa [m0] using hf _ _ h₁, fun {m} => (Nat.not_lt_zero _).elim⟩, by	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n x : ℕ left✝ : n ≤ k m : ℕ h₁ : evaln (k + 1) cf n = some m m0 : m = 0 h₂ : (unpair n).2 = x ⊢ 0 + (unpair n).2 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;> simp [m0] at h₂ · exact ⟨0, ⟨by simpa [m0] using hf _ _ h₁, fun {m} => (Nat.not_lt_zero _).elim⟩, by injection h₂ with h₂;	simp [h₂]	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;> simp [m0] at h₂ · exact ⟨0, ⟨by simpa [m0] using hf _ _ h₁, fun {m} => (Nat.not_lt_zero _).elim⟩, by injection h₂ with h₂;	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case neg k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n x : ℕ left✝ : n ≤ k m : ℕ h₁ : evaln (k + 1) cf n = some m m0 : ¬m = 0 h₂ : evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1)) = some x ⊢ ∃ a, (0 ∈ eval cf (Nat.pair (unpair n).1 (a + (unpair n).2)) ∧ ∀ {m : ℕ}, m < a → ∃ a ∈ eval cf (Nat.pair (unpair n).1 (m + (unpair n).2)), ¬a = 0) ∧ a + (unpair n).2 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;> simp [m0] at h₂ · exact ⟨0, ⟨by simpa [m0] using hf _ _ h₁, fun {m} => (Nat.not_lt_zero _).elim⟩, by injection h₂ with h₂; simp [h₂]⟩ ·	have := evaln_sound h₂	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;> simp [m0] at h₂ · exact ⟨0, ⟨by simpa [m0] using hf _ _ h₁, fun {m} => (Nat.not_lt_zero _).elim⟩, by injection h₂ with h₂; simp [h₂]⟩ ·	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case neg k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n x : ℕ left✝ : n ≤ k m : ℕ h₁ : evaln (k + 1) cf n = some m m0 : ¬m = 0 h₂ : evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1)) = some x this : x ∈ eval (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1)) ⊢ ∃ a, (0 ∈ eval cf (Nat.pair (unpair n).1 (a + (unpair n).2)) ∧ ∀ {m : ℕ}, m < a → ∃ a ∈ eval cf (Nat.pair (unpair n).1 (m + (unpair n).2)), ¬a = 0) ∧ a + (unpair n).2 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;> simp [m0] at h₂ · exact ⟨0, ⟨by simpa [m0] using hf _ _ h₁, fun {m} => (Nat.not_lt_zero _).elim⟩, by injection h₂ with h₂; simp [h₂]⟩ · have := evaln_sound h₂	simp [eval] at this	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;> simp [m0] at h₂ · exact ⟨0, ⟨by simpa [m0] using hf _ _ h₁, fun {m} => (Nat.not_lt_zero _).elim⟩, by injection h₂ with h₂; simp [h₂]⟩ · have := evaln_sound h₂	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case neg k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n x : ℕ left✝ : n ≤ k m : ℕ h₁ : evaln (k + 1) cf n = some m m0 : ¬m = 0 h₂ : evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1)) = some x this : ∃ a, (0 ∈ eval cf (Nat.pair (unpair n).1 (a + ((unpair n).2 + 1))) ∧ ∀ {m : ℕ}, m < a → ∃ a ∈ eval cf (Nat.pair (unpair n).1 (m + ((unpair n).2 + 1))), ¬a = 0) ∧ a + ((unpair n).2 + 1) = x ⊢ ∃ a, (0 ∈ eval cf (Nat.pair (unpair n).1 (a + (unpair n).2)) ∧ ∀ {m : ℕ}, m < a → ∃ a ∈ eval cf (Nat.pair (unpair n).1 (m + (unpair n).2)), ¬a = 0) ∧ a + (unpair n).2 = x	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;> simp [m0] at h₂ · exact ⟨0, ⟨by simpa [m0] using hf _ _ h₁, fun {m} => (Nat.not_lt_zero _).elim⟩, by injection h₂ with h₂; simp [h₂]⟩ · have := evaln_sound h₂ simp [eval] at this	rcases this with ⟨y, ⟨hy₁, hy₂⟩, rfl⟩	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;> simp [m0] at h₂ · exact ⟨0, ⟨by simpa [m0] using hf _ _ h₁, fun {m} => (Nat.not_lt_zero _).elim⟩, by injection h₂ with h₂; simp [h₂]⟩ · have := evaln_sound h₂ simp [eval] at this	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
case neg.intro.intro.intro k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n : ℕ left✝ : n ≤ k m : ℕ h₁ : evaln (k + 1) cf n = some m m0 : ¬m = 0 y : ℕ hy₁ : 0 ∈ eval cf (Nat.pair (unpair n).1 (y + ((unpair n).2 + 1))) hy₂ : ∀ {m : ℕ}, m < y → ∃ a ∈ eval cf (Nat.pair (unpair n).1 (m + ((unpair n).2 + 1))), ¬a = 0 h₂ : evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1)) = some (y + ((unpair n).2 + 1)) ⊢ ∃ a, (0 ∈ eval cf (Nat.pair (unpair n).1 (a + (unpair n).2)) ∧ ∀ {m : ℕ}, m < a → ∃ a ∈ eval cf (Nat.pair (unpair n).1 (m + (unpair n).2)), ¬a = 0) ∧ a + (unpair n).2 = y + ((unpair n).2 + 1)	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;> simp [m0] at h₂ · exact ⟨0, ⟨by simpa [m0] using hf _ _ h₁, fun {m} => (Nat.not_lt_zero _).elim⟩, by injection h₂ with h₂; simp [h₂]⟩ · have := evaln_sound h₂ simp [eval] at this rcases this with ⟨y, ⟨hy₁, hy₂⟩, rfl⟩	refine' ⟨y + 1, ⟨by simpa [add_comm, add_left_comm] using hy₁, fun {i} im => _⟩, by simp [add_comm, add_left_comm]⟩	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;> simp [m0] at h₂ · exact ⟨0, ⟨by simpa [m0] using hf _ _ h₁, fun {m} => (Nat.not_lt_zero _).elim⟩, by injection h₂ with h₂; simp [h₂]⟩ · have := evaln_sound h₂ simp [eval] at this rcases this with ⟨y, ⟨hy₁, hy₂⟩, rfl⟩	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode
k : ℕ cf : Code hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ eval cf n n : ℕ left✝ : n ≤ k m : ℕ h₁ : evaln (k + 1) cf n = some m m0 : ¬m = 0 y : ℕ hy₁ : 0 ∈ eval cf (Nat.pair (unpair n).1 (y + ((unpair n).2 + 1))) hy₂ : ∀ {m : ℕ}, m < y → ∃ a ∈ eval cf (Nat.pair (unpair n).1 (m + ((unpair n).2 + 1))), ¬a = 0 h₂ : evaln k (rfind' cf) (Nat.pair (unpair n).1 ((unpair n).2 + 1)) = some (y + ((unpair n).2 + 1)) ⊢ 0 ∈ eval cf (Nat.pair (unpair n).1 (y + 1 + (unpair n).2))	/- Copyright (c) 2018 Mario Carneiro. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Mario Carneiro -/ import Mathlib.Computability.Partrec #align_import computability.partrec_code from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8" /-! # Gödel Numbering for Partial Recursive Functions. This file defines `Nat.Partrec.Code`, an inductive datatype describing code for partial recursive functions on ℕ. It defines an encoding for these codes, and proves that the constructors are primitive recursive with respect to the encoding. It also defines the evaluation of these codes as partial functions using `PFun`, and proves that a function is partially recursive (as defined by `Nat.Partrec`) if and only if it is the evaluation of some code. ## Main Definitions * `Nat.Partrec.Code`: Inductive datatype for partial recursive codes. * `Nat.Partrec.Code.encodeCode`: A (computable) encoding of codes as natural numbers. * `Nat.Partrec.Code.ofNatCode`: The inverse of this encoding. * `Nat.Partrec.Code.eval`: The interpretation of a `Nat.Partrec.Code` as a partial function. ## Main Results * `Nat.Partrec.Code.rec_prim`: Recursion on `Nat.Partrec.Code` is primitive recursive. * `Nat.Partrec.Code.rec_computable`: Recursion on `Nat.Partrec.Code` is computable. * `Nat.Partrec.Code.smn`: The $S_n^m$ theorem. * `Nat.Partrec.Code.exists_code`: Partial recursiveness is equivalent to being the eval of a code. * `Nat.Partrec.Code.evaln_prim`: `evaln` is primitive recursive. * `Nat.Partrec.Code.fixed_point`: Roger's fixed point theorem. ## References * [Mario Carneiro, Formalizing computability theory via partial recursive functions][carneiro2019] -/ open Encodable Denumerable Primrec namespace Nat.Partrec open Nat (pair) theorem rfind' {f} (hf : Nat.Partrec f) : Nat.Partrec (Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) := Partrec₂.unpaired'.2 <\| by refine' Partrec.map ((@Partrec₂.unpaired' fun a b : ℕ => Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + b))).1 _) (Primrec.nat_add.comp Primrec.snd <\| Primrec.snd.comp Primrec.fst).to_comp.to₂ have : Nat.Partrec (fun a => Nat.rfind (fun n => (fun m => decide (m = 0)) <$> Nat.unpaired (fun a b => f (Nat.pair (Nat.unpair a).1 (b + (Nat.unpair a).2))) (Nat.pair a n))) := rfind (Partrec₂.unpaired'.2 ((Partrec.nat_iff.2 hf).comp (Primrec₂.pair.comp (Primrec.fst.comp <\| Primrec.unpair.comp Primrec.fst) (Primrec.nat_add.comp Primrec.snd (Primrec.snd.comp <\| Primrec.unpair.comp Primrec.fst))).to_comp)) simp at this; exact this #align nat.partrec.rfind' Nat.Partrec.rfind' /-- Code for partial recursive functions from ℕ to ℕ. See `Nat.Partrec.Code.eval` for the interpretation of these constructors. -/ inductive Code : Type \| zero : Code \| succ : Code \| left : Code \| right : Code \| pair : Code → Code → Code \| comp : Code → Code → Code \| prec : Code → Code → Code \| rfind' : Code → Code #align nat.partrec.code Nat.Partrec.Code -- Porting note: `Nat.Partrec.Code.recOn` is noncomputable in Lean4, so we make it computable. compile_inductive% Code end Nat.Partrec namespace Nat.Partrec.Code open Nat (pair unpair) open Nat.Partrec (Code) instance instInhabited : Inhabited Code := ⟨zero⟩ #align nat.partrec.code.inhabited Nat.Partrec.Code.instInhabited /-- Returns a code for the constant function outputting a particular natural. -/ protected def const : ℕ → Code \| 0 => zero \| n + 1 => comp succ (Code.const n) #align nat.partrec.code.const Nat.Partrec.Code.const theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂ \| 0, 0, _ => by simp \| n₁ + 1, n₂ + 1, h => by dsimp [Nat.add_one, Nat.Partrec.Code.const] at h injection h with h₁ h₂ simp only [const_inj h₂] #align nat.partrec.code.const_inj Nat.Partrec.Code.const_inj /-- A code for the identity function. -/ protected def id : Code := pair left right #align nat.partrec.code.id Nat.Partrec.Code.id /-- Given a code `c` taking a pair as input, returns a code using `n` as the first argument to `c`. -/ def curry (c : Code) (n : ℕ) : Code := comp c (pair (Code.const n) Code.id) #align nat.partrec.code.curry Nat.Partrec.Code.curry -- Porting note: `bit0` and `bit1` are deprecated. /-- An encoding of a `Nat.Partrec.Code` as a ℕ. -/ def encodeCode : Code → ℕ \| zero => 0 \| succ => 1 \| left => 2 \| right => 3 \| pair cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 4 \| comp cf cg => 2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg) + 1) + 4 \| prec cf cg => (2 * (2 * Nat.pair (encodeCode cf) (encodeCode cg)) + 1) + 4 \| rfind' cf => (2 * (2 * encodeCode cf + 1) + 1) + 4 #align nat.partrec.code.encode_code Nat.Partrec.Code.encodeCode /-- A decoder for `Nat.Partrec.Code.encodeCode`, taking any ℕ to the `Nat.Partrec.Code` it represents. -/ def ofNatCode : ℕ → Code \| 0 => zero \| 1 => succ \| 2 => left \| 3 => right \| n + 4 => let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm match n.bodd, n.div2.bodd with \| false, false => pair (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| false, true => comp (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , false => prec (ofNatCode m.unpair.1) (ofNatCode m.unpair.2) \| true , true => rfind' (ofNatCode m) #align nat.partrec.code.of_nat_code Nat.Partrec.Code.ofNatCode /-- Proof that `Nat.Partrec.Code.ofNatCode` is the inverse of `Nat.Partrec.Code.encodeCode`-/ private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n \| 0 => by simp [ofNatCode, encodeCode] \| 1 => by simp [ofNatCode, encodeCode] \| 2 => by simp [ofNatCode, encodeCode] \| 3 => by simp [ofNatCode, encodeCode] \| n + 4 => by let m := n.div2.div2 have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have _m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have _m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm have IH := encode_ofNatCode m have IH1 := encode_ofNatCode m.unpair.1 have IH2 := encode_ofNatCode m.unpair.2 conv_rhs => rw [← Nat.bit_decomp n, ← Nat.bit_decomp n.div2] simp only [ofNatCode._eq_5] cases n.bodd <;> cases n.div2.bodd <;> simp [encodeCode, ofNatCode, IH, IH1, IH2, Nat.bit_val] instance instDenumerable : Denumerable Code := mk' ⟨encodeCode, ofNatCode, fun c => by induction c <;> try {rfl} <;> simp [encodeCode, ofNatCode, Nat.div2_val, ], encode_ofNatCode⟩ #align nat.partrec.code.denumerable Nat.Partrec.Code.instDenumerable theorem encodeCode_eq : encode = encodeCode := rfl #align nat.partrec.code.encode_code_eq Nat.Partrec.Code.encodeCode_eq theorem ofNatCode_eq : ofNat Code = ofNatCode := rfl #align nat.partrec.code.of_nat_code_eq Nat.Partrec.Code.ofNatCode_eq theorem encode_lt_pair (cf cg) : encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right (Nat.pair cf.encodeCode cg.encodeCode) (by decide : 1 ≤ 2 2) rw [one_mul, mul_assoc] at this have := lt_of_le_of_lt this (lt_add_of_pos_right _ (by decide : 0 < 4)) exact ⟨lt_of_le_of_lt (Nat.left_le_pair _ _) this, lt_of_le_of_lt (Nat.right_le_pair _ _) this⟩ #align nat.partrec.code.encode_lt_pair Nat.Partrec.Code.encode_lt_pair theorem encode_lt_comp (cf cg) : encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_comp Nat.Partrec.Code.encode_lt_comp theorem encode_lt_prec (cf cg) : encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) := by suffices; exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this change _; simp [encodeCode_eq, encodeCode] #align nat.partrec.code.encode_lt_prec Nat.Partrec.Code.encode_lt_prec theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) := by simp only [encodeCode_eq, encodeCode] have := Nat.mul_le_mul_right cf.encodeCode (by decide : 1 ≤ 2 * 2) rw [one_mul, mul_assoc] at this refine' lt_of_le_of_lt (le_trans this _) (lt_add_of_pos_right _ (by decide : 0 < 4)) exact le_of_lt (Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_of_lt <\| Nat.lt_succ_of_le <\| Nat.mul_le_mul_left _ <\| le_rfl) #align nat.partrec.code.encode_lt_rfind' Nat.Partrec.Code.encode_lt_rfind' section theorem pair_prim : Primrec₂ pair := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.pair_prim Nat.Partrec.Code.pair_prim theorem comp_prim : Primrec₂ comp := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double.comp <\| nat_double_succ.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.comp_prim Nat.Partrec.Code.comp_prim theorem prec_prim : Primrec₂ prec := Primrec₂.ofNat_iff.2 <\| Primrec₂.encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double.comp <\| Primrec₂.natPair.comp (encode_iff.2 <\| (Primrec.ofNat Code).comp fst) (encode_iff.2 <\| (Primrec.ofNat Code).comp snd)) (Primrec₂.const 4) #align nat.partrec.code.prec_prim Nat.Partrec.Code.prec_prim theorem rfind_prim : Primrec rfind' := ofNat_iff.2 <\| encode_iff.1 <\| nat_add.comp (nat_double_succ.comp <\| nat_double_succ.comp <\| encode_iff.2 <\| Primrec.ofNat Code) (const 4) #align nat.partrec.code.rfind_prim Nat.Partrec.Code.rfind_prim theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Primrec (fun a => F a (c a) : α → σ) := by intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Primrec.ofNat Code).comp m).pair s)) (hpc.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Primrec.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim' Nat.Partrec.Code.rec_prim' /-- Recursion on `Nat.Partrec.Code` is primitive recursive. -/ theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ} (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Code → Code → σ → σ → σ} (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Code → Code → σ → σ → σ} (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) : let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a) Primrec fun a => F a (c a) := by intros F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m) s) (pc a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) (cond n.div2.bodd (co a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂) (pr a (ofNat Code m.unpair.1) (ofNat Code m.unpair.2) s₁ s₂)) have : Primrec G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Primrec₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Primrec.unpair.comp (snd.comp snd))).comp fst) _ unfold Primrec₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Primrec.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Primrec.unpair.comp m) have m₂ := snd.comp (Primrec.unpair.comp m) have s : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Primrec (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd have h₁ := hrf.comp <\| a.pair (((Primrec.ofNat Code).comp m).pair s) have h₂ := hpc.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₃ := hco.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) have h₄ := hpr.comp <\| a.pair (((Primrec.ofNat Code).comp m₁).pair <\| ((Primrec.ofNat Code).comp m₂).pair <\| s₁.pair s₂) unfold Primrec₂ exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond h₁ h₂) (cond (nat_bodd.comp <\| nat_div2.comp n) h₃ h₄) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Primrec₂ G := by unfold Primrec₂ refine nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ refine nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) ?_ unfold Primrec₂ exact this.comp <\| ((fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp _root_.Primrec.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_prim Nat.Partrec.Code.rec_prim end section open Computable /-- Recursion on `Nat.Partrec.Code` is computable. -/ theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) : let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg) let CO (a) cf cg hf hg := co a (cf, cg, hf, hg) let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg) let RF (a) cf hf := rf a (cf, hf) let F (a : α) (c : Code) : σ := Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a) Computable fun a => F a (c a) := by -- TODO(Mario): less copy-paste from previous proof intros _ _ _ _ F let G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => let a := p.1.1 let IH := p.1.2 let n := p.2.1 let m := p.2.2 (IH.get? m).bind fun s => (IH.get? m.unpair.1).bind fun s₁ => (IH.get? m.unpair.2).map fun s₂ => cond n.bodd (cond n.div2.bodd (rf a (ofNat Code m, s)) (pc a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) (cond n.div2.bodd (co a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂)) (pr a (ofNat Code m.unpair.1, ofNat Code m.unpair.2, s₁, s₂))) have : Computable G₁ := by refine' option_bind (list_get?.comp (snd.comp fst) (snd.comp snd)) _ unfold Computable₂ refine' option_bind ((list_get?.comp (snd.comp fst) (fst.comp <\| Computable.unpair.comp (snd.comp snd))).comp fst) _ unfold Computable₂ refine' option_map ((list_get?.comp (snd.comp fst) (snd.comp <\| Computable.unpair.comp (snd.comp snd))).comp <\| fst.comp fst) _ have a : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.1.1) := fst.comp (fst.comp <\| fst.comp <\| fst.comp fst) have n : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.1) := fst.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.1.2.2) := snd.comp (snd.comp <\| fst.comp <\| fst.comp fst) have m₁ := fst.comp (Computable.unpair.comp m) have m₂ := snd.comp (Computable.unpair.comp m) have s : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.1.2) := snd.comp (fst.comp fst) have s₁ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.1.2) := snd.comp fst have s₂ : Computable (fun p : ((((α × List σ) × ℕ × ℕ) × σ) × σ) × σ => p.2) := snd exact (nat_bodd.comp n).cond ((nat_bodd.comp <\| nat_div2.comp n).cond (hrf.comp a (((Computable.ofNat Code).comp m).pair s)) (hpc.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) (Computable.cond (nat_bodd.comp <\| nat_div2.comp n) (hco.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂)) (hpr.comp a (((Computable.ofNat Code).comp m₁).pair <\| ((Computable.ofNat Code).comp m₂).pair <\| s₁.pair s₂))) let G : α → List σ → Option σ := fun a IH => IH.length.casesOn (some (z a)) fun n => n.casesOn (some (s a)) fun n => n.casesOn (some (l a)) fun n => n.casesOn (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2) have : Computable₂ G := Computable.nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <\| Computable.nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <\| fst.comp fst))) <\| Computable.nat_casesOn snd (option_some_iff.2 (hr.comp (fst.comp <\| fst.comp <\| fst.comp fst))) (this.comp <\| ((Computable.fst.pair snd).comp <\| fst.comp <\| fst.comp <\| fst.comp <\| fst).pair <\| snd.pair <\| nat_div2.comp <\| nat_div2.comp snd) refine' ((nat_strong_rec (fun a n => F a (ofNat Code n)) this.to₂ fun a n => _).comp Computable.id <\| encode_iff.2 hc).of_eq fun a => by simp simp (config := { zeta := false }) iterate 4 cases' n with n; · simp (config := { zeta := false }) [ofNatCode_eq, ofNatCode]; rfl simp only [] rw [List.length_map, List.length_range] let m := n.div2.div2 show G₁ ((a, (List.range (n + 4)).map fun n => F a (ofNat Code n)), n, m) = some (F a (ofNat Code (n + 4))) have hm : m < n + 4 := by simp only [div2_val] exact lt_of_le_of_lt (le_trans (Nat.div_le_self _ _) (Nat.div_le_self _ _)) (Nat.succ_le_succ (Nat.le_add_right _ _)) have m1 : m.unpair.1 < n + 4 := lt_of_le_of_lt m.unpair_left_le hm have m2 : m.unpair.2 < n + 4 := lt_of_le_of_lt m.unpair_right_le hm simp [List.get?_map, List.get?_range, hm, m1, m2] rw [show ofNat Code (n + 4) = ofNatCode (n + 4) from rfl] simp [ofNatCode] cases n.bodd <;> cases n.div2.bodd <;> rfl #align nat.partrec.code.rec_computable Nat.Partrec.Code.rec_computable end /-- The interpretation of a `Nat.Partrec.Code` as a partial function. * `Nat.Partrec.Code.zero`: The constant zero function. * `Nat.Partrec.Code.succ`: The successor function. * `Nat.Partrec.Code.left`: Left unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.right`: Right unpairing of a pair of ℕ (encoded by `Nat.pair`) * `Nat.Partrec.Code.pair`: Pairs the outputs of argument codes using `Nat.pair`. * `Nat.Partrec.Code.comp`: Composition of two argument codes. * `Nat.Partrec.Code.prec`: Primitive recursion. Given an argument of the form `Nat.pair a n`: * If `n = 0`, returns `eval cf a`. * If `n = succ k`, returns `eval cg (pair a (pair k (eval (prec cf cg) (pair a k))))` * `Nat.Partrec.Code.rfind'`: Minimization. For `f` an argument of the form `Nat.pair a m`, `rfind' f m` returns the least `a` such that `f a m = 0`, if one exists and `f b m` terminates for `b < a` -/ def eval : Code → ℕ →. ℕ \| zero => pure 0 \| succ => Nat.succ \| left => ↑fun n : ℕ => n.unpair.1 \| right => ↑fun n : ℕ => n.unpair.2 \| pair cf cg => fun n => Nat.pair <$> eval cf n <> eval cg n \| comp cf cg => fun n => eval cg n >>= eval cf \| prec cf cg => Nat.unpaired fun a n => n.rec (eval cf a) fun y IH => do let i ← IH eval cg (Nat.pair a (Nat.pair y i)) \| rfind' cf => Nat.unpaired fun a m => (Nat.rfind fun n => (fun m => m = 0) <$> eval cf (Nat.pair a (n + m))).map (· + m) #align nat.partrec.code.eval Nat.Partrec.Code.eval /-- Helper lemma for the evaluation of `prec` in the base case. -/ @[simp] theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a := by rw [eval, Nat.unpaired, Nat.unpair_pair] simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only [] rw [Nat.rec_zero] #align nat.partrec.code.eval_prec_zero Nat.Partrec.Code.eval_prec_zero /-- Helper lemma for the evaluation of `prec` in the recursive case. -/ theorem eval_prec_succ (cf cg : Code) (a k : ℕ) : eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} := by rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] simp #align nat.partrec.code.eval_prec_succ Nat.Partrec.Code.eval_prec_succ instance : Membership (ℕ →. ℕ) Code := ⟨fun f c => eval c = f⟩ @[simp] theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n \| 0, m => rfl \| n + 1, m => by simp! [eval_const n m] #align nat.partrec.code.eval_const Nat.Partrec.Code.eval_const @[simp] theorem eval_id (n) : eval Code.id n = Part.some n := by simp! [Seq.seq] #align nat.partrec.code.eval_id Nat.Partrec.Code.eval_id @[simp] theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) := by simp! [Seq.seq] #align nat.partrec.code.eval_curry Nat.Partrec.Code.eval_curry theorem const_prim : Primrec Code.const := (_root_.Primrec.id.nat_iterate (_root_.Primrec.const zero) (comp_prim.comp (_root_.Primrec.const succ) Primrec.snd).to₂).of_eq fun n => by simp; induction n <;> simp [, Code.const, Function.iterate_succ', -Function.iterate_succ] #align nat.partrec.code.const_prim Nat.Partrec.Code.const_prim theorem curry_prim : Primrec₂ curry := comp_prim.comp Primrec.fst <\| pair_prim.comp (const_prim.comp Primrec.snd) (_root_.Primrec.const Code.id) #align nat.partrec.code.curry_prim Nat.Partrec.Code.curry_prim theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ := ⟨by injection h, by injection h with h₁ h₂ injection h₂ with h₃ h₄ exact const_inj h₃⟩ #align nat.partrec.code.curry_inj Nat.Partrec.Code.curry_inj /-- The $S_n^m$ theorem: There is a computable function, namely `Nat.Partrec.Code.curry`, that takes a program and a ℕ `n`, and returns a new program using `n` as the first argument. -/ theorem smn : ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) := ⟨curry, Primrec₂.to_comp curry_prim, eval_curry⟩ #align nat.partrec.code.smn Nat.Partrec.Code.smn /-- A function is partial recursive if and only if there is a code implementing it. -/ theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f := ⟨fun h => by induction h case zero => exact ⟨zero, rfl⟩ case succ => exact ⟨succ, rfl⟩ case left => exact ⟨left, rfl⟩ case right => exact ⟨right, rfl⟩ case pair f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨pair cf cg, rfl⟩ case comp f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨comp cf cg, rfl⟩ case prec f g pf pg hf hg => rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩ exact ⟨prec cf cg, rfl⟩ case rfind f pf hf => rcases hf with ⟨cf, rfl⟩ refine' ⟨comp (rfind' cf) (pair Code.id zero), _⟩ simp [eval, Seq.seq, pure, PFun.pure, Part.map_id'], fun h => by rcases h with ⟨c, rfl⟩; induction c case zero => exact Nat.Partrec.zero case succ => exact Nat.Partrec.succ case left => exact Nat.Partrec.left case right => exact Nat.Partrec.right case pair cf cg pf pg => exact pf.pair pg case comp cf cg pf pg => exact pf.comp pg case prec cf cg pf pg => exact pf.prec pg case rfind' cf pf => exact pf.rfind'⟩ #align nat.partrec.code.exists_code Nat.Partrec.Code.exists_code -- Porting note: `>>`s in `evaln` are now `>>=` because `>>`s are not elaborated well in Lean4. /-- A modified evaluation for the code which returns an `Option ℕ` instead of a `Part ℕ`. To avoid undecidability, `evaln` takes a parameter `k` and fails if it encounters a number ≥ k in the course of its execution. Other than this, the semantics are the same as in `Nat.Partrec.Code.eval`. -/ def evaln : ℕ → Code → ℕ → Option ℕ \| 0, _ => fun _ => Option.none \| k + 1, zero => fun n => do guard (n ≤ k) return 0 \| k + 1, succ => fun n => do guard (n ≤ k) return (Nat.succ n) \| k + 1, left => fun n => do guard (n ≤ k) return n.unpair.1 \| k + 1, right => fun n => do guard (n ≤ k) pure n.unpair.2 \| k + 1, pair cf cg => fun n => do guard (n ≤ k) Nat.pair <$> evaln (k + 1) cf n <*> evaln (k + 1) cg n \| k + 1, comp cf cg => fun n => do guard (n ≤ k) let x ← evaln (k + 1) cg n evaln (k + 1) cf x \| k + 1, prec cf cg => fun n => do guard (n ≤ k) n.unpaired fun a n => n.casesOn (evaln (k + 1) cf a) fun y => do let i ← evaln k (prec cf cg) (Nat.pair a y) evaln (k + 1) cg (Nat.pair a (Nat.pair y i)) \| k + 1, rfind' cf => fun n => do guard (n ≤ k) n.unpaired fun a m => do let x ← evaln (k + 1) cf (Nat.pair a m) if x = 0 then pure m else evaln k (rfind' cf) (Nat.pair a (m + 1)) termination_by evaln k c => (k, c) decreasing_by { decreasing_with simp (config := { arith := true }) [Zero.zero]; done } #align nat.partrec.code.evaln Nat.Partrec.Code.evaln theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k \| 0, c, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by cases c <;> rw [evaln] at h <;> exact this h simpa [Bind.bind] using Nat.lt_succ_of_le #align nat.partrec.code.evaln_bound Nat.Partrec.Code.evaln_bound theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n \| 0, k₂, c, n, x, _, h => by simp [evaln] at h \| k + 1, k₂ + 1, c, n, x, hl, h => by have hl' := Nat.le_of_succ_le_succ hl have : ∀ {k k₂ n x : ℕ} {o₁ o₂ : Option ℕ}, k ≤ k₂ → (x ∈ o₁ → x ∈ o₂) → x ∈ do { guard (n ≤ k); o₁ } → x ∈ do { guard (n ≤ k₂); o₂ } := by simp only [Option.mem_def, bind, Option.bind_eq_some, Option.guard_eq_some', exists_and_left, exists_const, and_imp] introv h h₁ h₂ h₃ exact ⟨le_trans h₂ h, h₁ h₃⟩ simp? at h ⊢ says simp only [Option.mem_def] at h ⊢ induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> rw [evaln] at h ⊢ <;> refine' this hl' (fun h => _) h iterate 4 exact h · -- pair cf cg simp? [Seq.seq] at h ⊢ says simp only [Seq.seq, Option.map_eq_map, Option.mem_def, Option.bind_eq_some, Option.map_eq_some', exists_exists_and_eq_and] at h ⊢ exact h.imp fun a => And.imp (hf _ _) <\| Exists.imp fun b => And.imp_left (hg _ _) · -- comp cf cg simp? [Bind.bind] at h ⊢ says simp only [bind, Option.mem_def, Option.bind_eq_some] at h ⊢ exact h.imp fun a => And.imp (hg _ _) (hf _ _) · -- prec cf cg revert h simp only [unpaired, bind, Option.mem_def] induction n.unpair.2 <;> simp · apply hf · exact fun y h₁ h₂ => ⟨y, evaln_mono hl' h₁, hg _ _ h₂⟩ · -- rfind' cf simp? [Bind.bind] at h ⊢ says simp only [unpaired, bind, pair_unpair, Option.mem_def, Option.bind_eq_some] at h ⊢ refine' h.imp fun x => And.imp (hf _ _) _ by_cases x0 : x = 0 <;> simp [x0] exact evaln_mono hl' #align nat.partrec.code.evaln_mono Nat.Partrec.Code.evaln_mono theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;> simp [m0] at h₂ · exact ⟨0, ⟨by simpa [m0] using hf _ _ h₁, fun {m} => (Nat.not_lt_zero _).elim⟩, by injection h₂ with h₂; simp [h₂]⟩ · have := evaln_sound h₂ simp [eval] at this rcases this with ⟨y, ⟨hy₁, hy₂⟩, rfl⟩ refine' ⟨y + 1, ⟨by	simpa [add_comm, add_left_comm] using hy₁	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have := evaln_mono k.le_succ h₁ simp [evaln, Bind.bind] at this exact this.2 · exact hg _ _ h₂ · -- rfind' cf rcases h with ⟨m, h₁, h₂⟩ by_cases m0 : m = 0 <;> simp [m0] at h₂ · exact ⟨0, ⟨by simpa [m0] using hf _ _ h₁, fun {m} => (Nat.not_lt_zero _).elim⟩, by injection h₂ with h₂; simp [h₂]⟩ · have := evaln_sound h₂ simp [eval] at this rcases this with ⟨y, ⟨hy₁, hy₂⟩, rfl⟩ refine' ⟨y + 1, ⟨by	Mathlib.Computability.PartrecCode.821_0.A3c3Aev6SyIRjCJ	theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n \| 0, _, n, x, h => by simp [evaln] at h \| k + 1, c, n, x, h => by induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;> simp [eval, evaln, Bind.bind, Seq.seq] at h ⊢ <;> cases' h with _ h iterate 4 simpa [pure, PFun.pure, eq_comm] using h · -- pair cf cg rcases h with ⟨y, ef, z, eg, rfl⟩ exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩ · --comp hf hg rcases h with ⟨y, eg, ef⟩ exact ⟨_, hg _ _ eg, hf _ _ ef⟩ · -- prec cf cg revert h induction' n.unpair.2 with m IH generalizing x <;> simp · apply hf · refine' fun y h₁ h₂ => ⟨y, IH _ _, _⟩ · have	Mathlib_Computability_PartrecCode

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.