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

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → ℕ
g : α →. σ
h : α → ℕ × σ →. σ
hf : Computable f
hg : Partrec g
hh : Partrec₂ h
n : ℕ
⊢ (((↑(decode n)).bind fun a => Part.map encode (↑f a)).bind fun n_1 =>
      Nat.rec ((↑(decode n)).bind fun a => Part.map encode (g a))
        (fun y IH => do
          let i ← IH
          (↑(decode (Nat.pair n (Nat.pair y i)))).bind fun a => Part.map encode ((fun p => h p.1 p.2) a))
        n_1) =
    (↑(decode n)).bind fun a =>
      Part.map encode ((fun a => Nat.rec (g a) (fun y IH => IH.bind fun i => h a (y, i)) (f a)) a)
state_after: case some
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
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 =>
        IH.bind fun i => (↑(Option.map (Prod.mk a ∘ Prod.mk y) (decode i))).bind fun a => Part.map encode (h a.1 a.2))
      (f a) =
    Part.map encode (Nat.rec (g a) (fun y IH => IH.bind fun i => h a (y, i)) (f a))
tactic: cases' e : decode (α := α) n with a <;> simp [e]
state_before: case some
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
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 =>
        IH.bind fun i => (↑(Option.map (Prod.mk a ∘ Prod.mk y) (decode i))).bind fun a => Part.map encode (h a.1 a.2))
      (f a) =
    Part.map encode (Nat.rec (g a) (fun y IH => IH.bind fun i => h a (y, i)) (f a))
state_after: case some.succ
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
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 =>
        IH.bind fun i => (↑(Option.map (Prod.mk a ∘ Prod.mk y) (decode i))).bind fun a => Part.map encode (h a.1 a.2))
      m =
    Part.map encode (Nat.rec (g a) (fun y IH => IH.bind fun i => h a (y, i)) m)
⊢ ((Nat.rec (Part.map encode (g a))
          (fun y IH =>
            IH.bind fun i =>
              (↑(Option.map (Prod.mk a ∘ Prod.mk y) (decode i))).bind fun a => Part.map encode (h a.1 a.2))
          m).bind
      fun i => (↑(Option.map (Prod.mk a ∘ Prod.mk m) (decode i))).bind fun a => Part.map encode (h a.1 a.2)) =
    (Nat.rec (g a) (fun y IH => IH.bind fun i => h a (y, i)) m).bind fun y => Part.map encode (h a (m, y))
tactic: induction' f a with m IH <;> simp
state_before: case some.succ
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
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 =>
        IH.bind fun i => (↑(Option.map (Prod.mk a ∘ Prod.mk y) (decode i))).bind fun a => Part.map encode (h a.1 a.2))
      m =
    Part.map encode (Nat.rec (g a) (fun y IH => IH.bind fun i => h a (y, i)) m)
⊢ ((Nat.rec (Part.map encode (g a))
          (fun y IH =>
            IH.bind fun i =>
              (↑(Option.map (Prod.mk a ∘ Prod.mk y) (decode i))).bind fun a => Part.map encode (h a.1 a.2))
          m).bind
      fun i => (↑(Option.map (Prod.mk a ∘ Prod.mk m) (decode i))).bind fun a => Part.map encode (h a.1 a.2)) =
    (Nat.rec (g a) (fun y IH => IH.bind fun i => h a (y, i)) m).bind fun y => Part.map encode (h a (m, y))
state_after: case some.succ
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
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 =>
        IH.bind fun i => (↑(Option.map (Prod.mk a ∘ Prod.mk y) (decode i))).bind fun a => Part.map encode (h a.1 a.2))
      m =
    Part.map encode (Nat.rec (g a) (fun y IH => IH.bind fun i => h a (y, i)) m)
⊢ ((Nat.rec (g a) (fun y IH => IH.bind fun i => h a (y, i)) m).bind fun y =>
      (↑(Option.map (Prod.mk a ∘ Prod.mk m) (decode (encode y)))).bind fun a => Part.map encode (h a.1 a.2)) =
    (Nat.rec (g a) (fun y IH => IH.bind fun i => h a (y, i)) m).bind fun y => Part.map encode (h a (m, y))
tactic: rw [IH, Part.bind_map]
state_before: case some.succ
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
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 =>
        IH.bind fun i => (↑(Option.map (Prod.mk a ∘ Prod.mk y) (decode i))).bind fun a => Part.map encode (h a.1 a.2))
      m =
    Part.map encode (Nat.rec (g a) (fun y IH => IH.bind fun i => h a (y, i)) m)
⊢ ((Nat.rec (g a) (fun y IH => IH.bind fun i => h a (y, i)) m).bind fun y =>
      (↑(Option.map (Prod.mk a ∘ Prod.mk m) (decode (encode y)))).bind fun a => Part.map encode (h a.1 a.2)) =
    (Nat.rec (g a) (fun y IH => IH.bind fun i => h a (y, i)) m).bind fun y => Part.map encode (h a (m, y))
state_after: case some.succ.e_g
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
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 =>
        IH.bind fun i => (↑(Option.map (Prod.mk a ∘ Prod.mk y) (decode i))).bind fun a => Part.map encode (h a.1 a.2))
      m =
    Part.map encode (Nat.rec (g a) (fun y IH => IH.bind fun i => h a (y, i)) m)
⊢ (fun y => (↑(Option.map (Prod.mk a ∘ Prod.mk m) (decode (encode y)))).bind fun a => Part.map encode (h a.1 a.2)) =
    fun y => Part.map encode (h a (m, y))
tactic: congr
state_before: case some.succ.e_g
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
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 =>
        IH.bind fun i => (↑(Option.map (Prod.mk a ∘ Prod.mk y) (decode i))).bind fun a => Part.map encode (h a.1 a.2))
      m =
    Part.map encode (Nat.rec (g a) (fun y IH => IH.bind fun i => h a (y, i)) m)
⊢ (fun y => (↑(Option.map (Prod.mk a ∘ Prod.mk m) (decode (encode y)))).bind fun a => Part.map encode (h a.1 a.2)) =
    fun y => Part.map encode (h a (m, y))
state_after: case some.succ.e_g.h
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
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 =>
        IH.bind fun i => (↑(Option.map (Prod.mk a ∘ Prod.mk y) (decode i))).bind fun a => Part.map encode (h a.1 a.2))
      m =
    Part.map encode (Nat.rec (g a) (fun y IH => IH.bind fun i => h a (y, i)) m)
s : σ
⊢ ((↑(Option.map (Prod.mk a ∘ Prod.mk m) (decode (encode s)))).bind fun a => Part.map encode (h a.1 a.2)) =
    Part.map encode (h a (m, s))
tactic: funext s
state_before: case some.succ.e_g.h
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
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 =>
        IH.bind fun i => (↑(Option.map (Prod.mk a ∘ Prod.mk y) (decode i))).bind fun a => Part.map encode (h a.1 a.2))
      m =
    Part.map encode (Nat.rec (g a) (fun y IH => IH.bind fun i => h a (y, i)) m)
s : σ
⊢ ((↑(Option.map (Prod.mk a ∘ Prod.mk m) (decode (encode s)))).bind fun a => Part.map encode (h a.1 a.2)) =
    Part.map encode (h a (m, s))
state_after: no goals
tactic: simp [encodek]