Theorem: Partrec.nat_rec
File: Mathlib/Computability/Partrec.lean

tactic: cases' e : decode (α := α) n with a <;> simp [e]
state_before: α : Type u_1
β : Type ?u.63305
γ : Type ?u.63308
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → ℕ
g : α →. σ
h : α → ℕ × σ →. σ
hf : Computable f
hg : Partrec g
hh : Partrec₂ h
n : ℕ
⊢ (Part.bind (Part.bind ↑(decode n) fun a => Part.map encode (↑f a)) fun n_1 =>
      Nat.rec (Part.bind ↑(decode n) fun a => Part.map encode (g a))
        (fun y IH => do
          let i ← IH
          Part.bind ↑(decode (Nat.pair n (Nat.pair y i))) fun a => Part.map encode ((fun p => h p.fst p.snd) a))
        n_1) =
    Part.bind ↑(decode n) fun a =>
      Part.map encode ((fun a => Nat.rec (g a) (fun y IH => Part.bind IH fun i => h a (y, i)) (f a)) a)

tactic: induction' f a with m IH <;> simp
state_before: case some
α : Type u_1
β : Type ?u.63305
γ : Type ?u.63308
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → ℕ
g : α →. σ
h : α → ℕ × σ →. σ
hf : Computable f
hg : Partrec g
hh : Partrec₂ h
n : ℕ
a : α
e : decode n = Option.some a
⊢ Nat.rec (Part.map encode (g a))
      (fun y IH =>
        Part.bind IH fun i =>
          Part.bind ↑(Option.map (Prod.mk a ∘ Prod.mk y) (decode i)) fun a => Part.map encode (h a.fst a.snd))
      (f a) =
    Part.map encode (Nat.rec (g a) (fun y IH => Part.bind IH fun i => h a (y, i)) (f a))

tactic: rw [IH, Part.bind_map]
state_before: case some.succ
α : Type u_1
β : Type ?u.63305
γ : Type ?u.63308
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → ℕ
g : α →. σ
h : α → ℕ × σ →. σ
hf : Computable f
hg : Partrec g
hh : Partrec₂ h
n : ℕ
a : α
e : decode n = Option.some a
m : ℕ
IH :
  Nat.rec (Part.map encode (g a))
      (fun y IH =>
        Part.bind IH fun i =>
          Part.bind ↑(Option.map (Prod.mk a ∘ Prod.mk y) (decode i)) fun a => Part.map encode (h a.fst a.snd))
      m =
    Part.map encode (Nat.rec (g a) (fun y IH => Part.bind IH fun i => h a (y, i)) m)
⊢ (Part.bind
      (Nat.rec (Part.map encode (g a))
        (fun y IH =>
          Part.bind IH fun i =>
            Part.bind ↑(Option.map (Prod.mk a ∘ Prod.mk y) (decode i)) fun a => Part.map encode (h a.fst a.snd))
        m)
      fun i => Part.bind ↑(Option.map (Prod.mk a ∘ Prod.mk m) (decode i)) fun a => Part.map encode (h a.fst a.snd)) =
    Part.bind (Nat.rec (g a) (fun y IH => Part.bind IH fun i => h a (y, i)) m) fun y => Part.map encode (h a (m, y))

tactic: congr
state_before: case some.succ
α : Type u_1
β : Type ?u.63305
γ : Type ?u.63308
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → ℕ
g : α →. σ
h : α → ℕ × σ →. σ
hf : Computable f
hg : Partrec g
hh : Partrec₂ h
n : ℕ
a : α
e : decode n = Option.some a
m : ℕ
IH :
  Nat.rec (Part.map encode (g a))
      (fun y IH =>
        Part.bind IH fun i =>
          Part.bind ↑(Option.map (Prod.mk a ∘ Prod.mk y) (decode i)) fun a => Part.map encode (h a.fst a.snd))
      m =
    Part.map encode (Nat.rec (g a) (fun y IH => Part.bind IH fun i => h a (y, i)) m)
⊢ (Part.bind (Nat.rec (g a) (fun y IH => Part.bind IH fun i => h a (y, i)) m) fun y =>
      Part.bind ↑(Option.map (Prod.mk a ∘ Prod.mk m) (decode (encode y))) fun a => Part.map encode (h a.fst a.snd)) =
    Part.bind (Nat.rec (g a) (fun y IH => Part.bind IH fun i => h a (y, i)) m) fun y => Part.map encode (h a (m, y))

tactic: funext s
state_before: case some.succ.e_g
α : Type u_1
β : Type ?u.63305
γ : Type ?u.63308
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → ℕ
g : α →. σ
h : α → ℕ × σ →. σ
hf : Computable f
hg : Partrec g
hh : Partrec₂ h
n : ℕ
a : α
e : decode n = Option.some a
m : ℕ
IH :
  Nat.rec (Part.map encode (g a))
      (fun y IH =>
        Part.bind IH fun i =>
          Part.bind ↑(Option.map (Prod.mk a ∘ Prod.mk y) (decode i)) fun a => Part.map encode (h a.fst a.snd))
      m =
    Part.map encode (Nat.rec (g a) (fun y IH => Part.bind IH fun i => h a (y, i)) m)
⊢ (fun y =>
      Part.bind ↑(Option.map (Prod.mk a ∘ Prod.mk m) (decode (encode y))) fun a => Part.map encode (h a.fst a.snd)) =
    fun y => Part.map encode (h a (m, y))

tactic: simp [encodek]
state_before: case some.succ.e_g.h
α : Type u_1
β : Type ?u.63305
γ : Type ?u.63308
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → ℕ
g : α →. σ
h : α → ℕ × σ →. σ
hf : Computable f
hg : Partrec g
hh : Partrec₂ h
n : ℕ
a : α
e : decode n = Option.some a
m : ℕ
IH :
  Nat.rec (Part.map encode (g a))
      (fun y IH =>
        Part.bind IH fun i =>
          Part.bind ↑(Option.map (Prod.mk a ∘ Prod.mk y) (decode i)) fun a => Part.map encode (h a.fst a.snd))
      m =
    Part.map encode (Nat.rec (g a) (fun y IH => Part.bind IH fun i => h a (y, i)) m)
s : σ
⊢ (Part.bind ↑(Option.map (Prod.mk a ∘ Prod.mk m) (decode (encode s))) fun a => Part.map encode (h a.fst a.snd)) =
    Part.map encode (h a (m, s))