ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Language.reverseIso_apply
@[simps]
def reverseIso : Language α ≃+* (Language α)ᵐᵒᵖ 
Arguments: (α : Type u_1) (l : Language α)
Goal: (Language.reverseIso α) l = MulOpposite.op l.reverse
-- Language.reverseIso_symm_apply
@[simps]
def reverseIso : Language α ≃+* (Language α)ᵐᵒᵖ 
Arguments: (α : Type u_1) (l' : (Language α)ᵐᵒᵖ)
Goal: (Language.reverseIso α).symm l' = (MulOpposite.unop l').reverse
-- Language.reverse_pow
@[simp]
lemma reverse_pow (l : Language α) (n : ℕ) : (l ^ n).reverse = l.reverse ^ n 
Arguments: {α : Type u_1} (l : Language α) (n : ℕ)
Goal: (l ^ n).reverse = l.reverse ^ n
-- Language.reverse_kstar
@[simp]
lemma reverse_kstar (l : Language α) : l∗.reverse = l.reverse∗ 
Arguments: {α : Type u_1} (l : Language α)
Goal: l∗.reverse = l.reverse∗
-- Turing.EvalsTo.evals_in_steps
structure EvalsTo {σ : Type*} (f : σ → Option σ) (a : σ) (b : Option σ) where
    steps : ℕ
  evals_in_steps : (flip bind f)^[steps] a = b
Arguments: {σ : Type u_1} {f : σ → Option σ} {a : σ} {b : Option σ} (self : Turing.EvalsTo f a b)
Goal: (flip bind f)^[self.steps] (some a) = b
-- Turing.EvalsToInTime.steps_le_m
structure EvalsToInTime {σ : Type*} (f : σ → Option σ) (a : σ) (b : Option σ) (m : ℕ) extends
  EvalsTo f a b where
  steps_le_m : steps ≤ m
Arguments: {σ : Type u_1} {f : σ → Option σ} {a : σ} {b : Option σ} {m : ℕ} (self : Turing.EvalsToInTime f a b m)
Goal: self.steps ≤ m
-- Nat.rfind_spec
theorem rfind_spec {p : ℕ →. Bool} {n : ℕ} (h : n ∈ rfind p) : true ∈ p n 
Arguments: {p : ℕ →. Bool} {n : ℕ} (h : n ∈ Nat.rfind p)
Goal: true ∈ p n
-- Nat.rfind_min
theorem rfind_min {p : ℕ →. Bool} {n : ℕ} (h : n ∈ rfind p) : ∀ {m : ℕ}, m < n → false ∈ p m 
Arguments: {p : ℕ →. Bool} {n : ℕ} (h : n ∈ Nat.rfind p) {m : ℕ}
Goal: m < n → false ∈ p m
-- Nat.rfind_dom
@[simp]
theorem rfind_dom {p : ℕ →. Bool} :
    (rfind p).Dom ↔ ∃ n, true ∈ p n ∧ ∀ {m : ℕ}, m < n → (p m).Dom 
Arguments: {p : ℕ →. Bool}
Goal: (Nat.rfind p).Dom ↔ ∃ n, true ∈ p n ∧ ∀ {m : ℕ}, m < n → (p m).Dom
-- Nat.rfind_dom'
theorem rfind_dom' {p : ℕ →. Bool} :
    (rfind p).Dom ↔ ∃ n, true ∈ p n ∧ ∀ {m : ℕ}, m ≤ n → (p m).Dom 
Arguments: {p : ℕ →. Bool}
Goal: (Nat.rfind p).Dom ↔ ∃ n, true ∈ p n ∧ ∀ {m : ℕ}, m ≤ n → (p m).Dom
-- Nat.mem_rfind
@[simp]
theorem mem_rfind {p : ℕ →. Bool} {n : ℕ} :
    n ∈ rfind p ↔ true ∈ p n ∧ ∀ {m : ℕ}, m < n → false ∈ p m 
Arguments: {p : ℕ →. Bool} {n : ℕ}
Goal: n ∈ Nat.rfind p ↔ true ∈ p n ∧ ∀ {m : ℕ}, m < n → false ∈ p m
-- Nat.rfind_min'
theorem rfind_min' {p : ℕ → Bool} {m : ℕ} (pm : p m) : ∃ n ∈ rfind p, n ≤ m 
Arguments: {p : ℕ → Bool} {m : ℕ} (pm : p m = true)
Goal: ∃ n ∈ Nat.rfind ↑p, n ≤ m
-- Nat.rfind_zero_none
theorem rfind_zero_none (p : ℕ →. Bool) (p0 : p 0 = Part.none) : rfind p = Part.none 
Arguments: (p : ℕ →. Bool) (p0 : p 0 = Part.none)
Goal: Nat.rfind p = Part.none
-- Nat.rfindOpt_spec
theorem rfindOpt_spec {α} {f : ℕ → Option α} {a} (h : a ∈ rfindOpt f) : ∃ n, a ∈ f n 
Arguments: {α : Type u_1} {f : ℕ → Option α} {a : α} (h : a ∈ Nat.rfindOpt f)
Goal: ∃ n, a ∈ f n
-- Nat.rfindOpt_dom
theorem rfindOpt_dom {α} {f : ℕ → Option α} : (rfindOpt f).Dom ↔ ∃ n a, a ∈ f n 
Arguments: {α : Type u_1} {f : ℕ → Option α}
Goal: (Nat.rfindOpt f).Dom ↔ ∃ n a, a ∈ f n
-- Nat.rfindOpt_mono
theorem rfindOpt_mono {α} {f : ℕ → Option α} (H : ∀ {a m n}, m ≤ n → a ∈ f m → a ∈ f n) {a} :
    a ∈ rfindOpt f ↔ ∃ n, a ∈ f n 
Arguments: {α : Type u_1} {f : ℕ → Option α} (H : ∀ {a : α} {m n : ℕ}, m ≤ n → a ∈ f m → a ∈ f n) {a : α}
Goal: a ∈ Nat.rfindOpt f ↔ ∃ n, a ∈ f n
-- Nat.Partrec.of_eq
theorem of_eq {f g : ℕ →. ℕ} (hf : Partrec f) (H : ∀ n, f n = g n) : Partrec g 
Arguments: {f g : ℕ →. ℕ} (hf : Nat.Partrec f) (H : ∀ (n : ℕ), f n = g n)
Goal: Nat.Partrec g
-- Nat.Partrec.of_eq_tot
theorem of_eq_tot {f : ℕ →. ℕ} {g : ℕ → ℕ} (hf : Partrec f) (H : ∀ n, g n ∈ f n) : Partrec g 
Arguments: {f : ℕ →. ℕ} {g : ℕ → ℕ} (hf : Nat.Partrec f) (H : ∀ (n : ℕ), g n ∈ f n)
Goal: Nat.Partrec ↑g
-- Nat.Partrec.of_primrec
theorem of_primrec {f : ℕ → ℕ} (hf : Nat.Primrec f) : Partrec f 
Arguments: {f : ℕ → ℕ} (hf : Nat.Primrec f)
Goal: Nat.Partrec ↑f
-- Nat.Partrec.some
protected theorem some : Partrec some 
Goal: Nat.Partrec Part.some
-- Nat.Partrec.none
theorem none : Partrec fun _ => none 
Goal: Nat.Partrec fun x => Part.none
-- Nat.Partrec.prec'
theorem prec' {f g h} (hf : Partrec f) (hg : Partrec g) (hh : Partrec h) :
    Partrec fun a => (f a).bind fun n => n.rec (g a)
      fun y IH => do {let i ← IH; h (Nat.pair a (Nat.pair y i))} 
Arguments: {f g h : ℕ →. ℕ} (hf : Nat.Partrec f) (hg : Nat.Partrec g) (hh : Nat.Partrec h)
Goal: Nat.Partrec fun a =>
  (f a).bind fun n =>
    Nat.rec (g a)
      (fun y IH => do
        let i ← IH
        h (Nat.pair a (Nat.pair y i)))
      n
-- Nat.Partrec.ppred
theorem ppred : Partrec fun n => ppred n 
Goal: Nat.Partrec fun n => ↑n.ppred
-- Primrec.to_comp
theorem Primrec.to_comp {α σ} [Primcodable α] [Primcodable σ] {f : α → σ} (hf : Primrec f) :
    Computable f 
Arguments: {α : Type u_1} {σ : Type u_2} [Primcodable α] [Primcodable σ] {f : α → σ} (hf : Primrec f)
Goal: Computable f
-- Primrec₂.to_comp
nonrec theorem Primrec₂.to_comp {α β σ} [Primcodable α] [Primcodable β] [Primcodable σ]
    {f : α → β → σ} (hf : Primrec₂ f) : Computable₂ f 
Arguments: {α : Type u_1} {β : Type u_2} {σ : Type u_3} [Primcodable α] [Primcodable β] [Primcodable σ] {f : α → β → σ} (hf : Primrec₂ f)
Goal: Computable₂ f
-- Computable.partrec
protected theorem Computable.partrec {α σ} [Primcodable α] [Primcodable σ] {f : α → σ}
    (hf : Computable f) : Partrec (f : α →. σ) 
Arguments: {α : Type u_1} {σ : Type u_2} [Primcodable α] [Primcodable σ] {f : α → σ} (hf : Computable f)
Goal: Partrec ↑f
-- Computable₂.partrec₂
protected theorem Computable₂.partrec₂ {α β σ} [Primcodable α] [Primcodable β] [Primcodable σ]
    {f : α → β → σ} (hf : Computable₂ f) : Partrec₂ fun a => (f a : β →. σ) 
Arguments: {α : Type u_1} {β : Type u_2} {σ : Type u_3} [Primcodable α] [Primcodable β] [Primcodable σ] {f : α → β → σ} (hf : Computable₂ f)
Goal: Partrec₂ fun a => ↑(f a)
-- Computable.of_eq
theorem of_eq {f g : α → σ} (hf : Computable f) (H : ∀ n, f n = g n) : Computable g 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {f g : α → σ} (hf : Computable f) (H : ∀ (n : α), f n = g n)
Goal: Computable g
-- Computable.const
theorem const (s : σ) : Computable fun _ : α => s 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] (s : σ)
Goal: Computable fun x => s
-- Computable.ofOption
theorem ofOption {f : α → Option β} (hf : Computable f) : Partrec fun a => (f a : Part β) 
Arguments: {α : Type u_1} {β : Type u_2} [Primcodable α] [Primcodable β] {f : α → Option β} (hf : Computable f)
Goal: Partrec fun a => ↑(f a)
-- Computable.to₂
theorem to₂ {f : α × β → σ} (hf : Computable f) : Computable₂ fun a b => f (a, b) 
Arguments: {α : Type u_1} {β : Type u_2} {σ : Type u_4} [Primcodable α] [Primcodable β] [Primcodable σ] {f : α × β → σ} (hf : Computable f)
Goal: Computable₂ fun a b => f (a, b)
-- Computable.id
protected theorem id : Computable (@id α) 
Arguments: {α : Type u_1} [Primcodable α]
Goal: Computable id
-- Computable.fst
theorem fst : Computable (@Prod.fst α β) 
Arguments: {α : Type u_1} {β : Type u_2} [Primcodable α] [Primcodable β]
Goal: Computable Prod.fst
-- Computable.snd
theorem snd : Computable (@Prod.snd α β) 
Arguments: {α : Type u_1} {β : Type u_2} [Primcodable α] [Primcodable β]
Goal: Computable Prod.snd
-- Computable.pair
nonrec theorem pair {f : α → β} {g : α → γ} (hf : Computable f) (hg : Computable g) :
    Computable fun a => (f a, g a) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Primcodable α] [Primcodable β] [Primcodable γ] {f : α → β} {g : α → γ} (hf : Computable f) (hg : Computable g)
Goal: Computable fun a => (f a, g a)
-- Computable.unpair
theorem unpair : Computable Nat.unpair 
Goal: Computable Nat.unpair
-- Computable.succ
theorem succ : Computable Nat.succ 
Goal: Computable Nat.succ
-- Computable.pred
theorem pred : Computable Nat.pred 
Goal: Computable Nat.pred
-- Computable.nat_bodd
theorem nat_bodd : Computable Nat.bodd 
Goal: Computable Nat.bodd
-- Computable.nat_div2
theorem nat_div2 : Computable Nat.div2 
Goal: Computable Nat.div2
-- Computable.sum_inl
theorem sum_inl : Computable (@Sum.inl α β) 
Arguments: {α : Type u_1} {β : Type u_2} [Primcodable α] [Primcodable β]
Goal: Computable Sum.inl
-- Computable.sum_inr
theorem sum_inr : Computable (@Sum.inr α β) 
Arguments: {α : Type u_1} {β : Type u_2} [Primcodable α] [Primcodable β]
Goal: Computable Sum.inr
-- Computable.list_cons
theorem list_cons : Computable₂ (@List.cons α) 
Arguments: {α : Type u_1} [Primcodable α]
Goal: Computable₂ List.cons
-- Computable.list_reverse
theorem list_reverse : Computable (@List.reverse α) 
Arguments: {α : Type u_1} [Primcodable α]
Goal: Computable List.reverse
-- Computable.list_get?
theorem list_get? : Computable₂ (@List.get? α) 
Arguments: {α : Type u_1} [Primcodable α]
Goal: Computable₂ List.get?
-- Computable.list_append
theorem list_append : Computable₂ ((· ++ ·) : List α → List α → List α) 
Arguments: {α : Type u_1} [Primcodable α]
Goal: Computable₂ fun x x_1 => x ++ x_1
-- Computable.list_concat
theorem list_concat : Computable₂ fun l (a : α) => l ++ [a] 
Arguments: {α : Type u_1} [Primcodable α]
Goal: Computable₂ fun l a => l ++ [a]
-- Computable.list_length
theorem list_length : Computable (@List.length α) 
Arguments: {α : Type u_1} [Primcodable α]
Goal: Computable List.length
-- Computable.vector_cons
theorem vector_cons {n} : Computable₂ (@Vector.cons α n) 
Arguments: {α : Type u_1} [Primcodable α] {n : ℕ}
Goal: Computable₂ Mathlib.Vector.cons
-- Computable.vector_toList
theorem vector_toList {n} : Computable (@Vector.toList α n) 
Arguments: {α : Type u_1} [Primcodable α] {n : ℕ}
Goal: Computable Mathlib.Vector.toList
-- Computable.vector_length
theorem vector_length {n} : Computable (@Vector.length α n) 
Arguments: {α : Type u_1} [Primcodable α] {n : ℕ}
Goal: Computable Mathlib.Vector.length
-- Computable.vector_head
theorem vector_head {n} : Computable (@Vector.head α n) 
Arguments: {α : Type u_1} [Primcodable α] {n : ℕ}
Goal: Computable Mathlib.Vector.head
-- Computable.vector_tail
theorem vector_tail {n} : Computable (@Vector.tail α n) 
Arguments: {α : Type u_1} [Primcodable α] {n : ℕ}
Goal: Computable Mathlib.Vector.tail
-- Computable.vector_get
theorem vector_get {n} : Computable₂ (@Vector.get α n) 
Arguments: {α : Type u_1} [Primcodable α] {n : ℕ}
Goal: Computable₂ Mathlib.Vector.get
-- Computable.vector_ofFn'
theorem vector_ofFn' {n} : Computable (@Vector.ofFn α n) 
Arguments: {α : Type u_1} [Primcodable α] {n : ℕ}
Goal: Computable Mathlib.Vector.ofFn
-- Computable.fin_app
theorem fin_app {n} : Computable₂ (@id (Fin n → σ)) 
Arguments: {σ : Type u_4} [Primcodable σ] {n : ℕ}
Goal: Computable₂ id
-- Computable.encode
protected theorem encode : Computable (@encode α _) 
Arguments: {α : Type u_1} [Primcodable α]
Goal: Computable Encodable.encode
-- Computable.decode
protected theorem decode : Computable (decode (α := α)) 
Arguments: {α : Type u_1} [Primcodable α]
Goal: Computable Encodable.decode
-- Computable.ofNat
protected theorem ofNat (α) [Denumerable α] : Computable (ofNat α) 
Arguments: (α : Type u_5) [Denumerable α]
Goal: Computable (Denumerable.ofNat α)
-- Computable.encode_iff
theorem encode_iff {f : α → σ} : (Computable fun a => encode (f a)) ↔ Computable f 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {f : α → σ}
Goal: (Computable fun a => Encodable.encode (f a)) ↔ Computable f
-- Computable.option_some
theorem option_some : Computable (@Option.some α) 
Arguments: {α : Type u_1} [Primcodable α]
Goal: Computable some
-- Partrec.of_eq
theorem of_eq {f g : α →. σ} (hf : Partrec f) (H : ∀ n, f n = g n) : Partrec g 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {f g : α →. σ} (hf : Partrec f) (H : ∀ (n : α), f n = g n)
Goal: Partrec g
-- Partrec.of_eq_tot
theorem of_eq_tot {f : α →. σ} {g : α → σ} (hf : Partrec f) (H : ∀ n, g n ∈ f n) : Computable g 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {f : α →. σ} {g : α → σ} (hf : Partrec f) (H : ∀ (n : α), g n ∈ f n)
Goal: Computable g
-- Partrec.none
theorem none : Partrec fun _ : α => @Part.none σ 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ]
Goal: Partrec fun x => Part.none
-- Partrec.some
protected theorem some : Partrec (@Part.some α) 
Arguments: {α : Type u_1} [Primcodable α]
Goal: Partrec Part.some
-- Decidable.Partrec.const'
theorem _root_.Decidable.Partrec.const' (s : Part σ) [Decidable s.Dom] : Partrec fun _ : α => s 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] (s : Part σ) [Decidable s.Dom]
Goal: Partrec fun x => s
-- Partrec.const'
theorem const' (s : Part σ) : Partrec fun _ : α => s 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] (s : Part σ)
Goal: Partrec fun x => s
-- Partrec.bind
protected theorem bind {f : α →. β} {g : α → β →. σ} (hf : Partrec f) (hg : Partrec₂ g) :
    Partrec fun a => (f a).bind (g a) 
Arguments: {α : Type u_1} {β : Type u_2} {σ : Type u_4} [Primcodable α] [Primcodable β] [Primcodable σ] {f : α →. β} {g : α → β →. σ} (hf : Partrec f) (hg : Partrec₂ g)
Goal: Partrec fun a => (f a).bind (g a)
-- Partrec.map
theorem map {f : α →. β} {g : α → β → σ} (hf : Partrec f) (hg : Computable₂ g) :
    Partrec fun a => (f a).map (g a) 
Arguments: {α : Type u_1} {β : Type u_2} {σ : Type u_4} [Primcodable α] [Primcodable β] [Primcodable σ] {f : α →. β} {g : α → β → σ} (hf : Partrec f) (hg : Computable₂ g)
Goal: Partrec fun a => Part.map (g a) (f a)
-- Partrec.to₂
theorem to₂ {f : α × β →. σ} (hf : Partrec f) : Partrec₂ fun a b => f (a, b) 
Arguments: {α : Type u_1} {β : Type u_2} {σ : Type u_4} [Primcodable α] [Primcodable β] [Primcodable σ] {f : α × β →. σ} (hf : Partrec f)
Goal: Partrec₂ fun a b => f (a, b)
-- Partrec.nat_rec
theorem nat_rec {f : α → ℕ} {g : α →. σ} {h : α → ℕ × σ →. σ} (hf : Computable f) (hg : Partrec g)
    (hh : Partrec₂ h) : Partrec fun a => (f a).rec (g a) fun y IH => IH.bind fun i => h a (y, i) 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {f : α → ℕ} {g : α →. σ} {h : α → ℕ × σ →. σ} (hf : Computable f) (hg : Partrec g) (hh : Partrec₂ h)
Goal: Partrec fun a => Nat.rec (g a) (fun y IH => IH.bind fun i => h a (y, i)) (f a)
-- Partrec.comp
nonrec theorem comp {f : β →. σ} {g : α → β} (hf : Partrec f) (hg : Computable g) :
    Partrec fun a => f (g a) 
Arguments: {α : Type u_1} {β : Type u_2} {σ : Type u_4} [Primcodable α] [Primcodable β] [Primcodable σ] {f : β →. σ} {g : α → β} (hf : Partrec f) (hg : Computable g)
Goal: Partrec fun a => f (g a)
-- Partrec.nat_iff
theorem nat_iff {f : ℕ →. ℕ} : Partrec f ↔ Nat.Partrec f 
Arguments: {f : ℕ →. ℕ}
Goal: Partrec f ↔ Nat.Partrec f
-- Partrec.map_encode_iff
theorem map_encode_iff {f : α →. σ} : (Partrec fun a => (f a).map encode) ↔ Partrec f 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {f : α →. σ}
Goal: (Partrec fun a => Part.map Encodable.encode (f a)) ↔ Partrec f
-- Partrec₂.unpaired
theorem unpaired {f : ℕ → ℕ →. α} : Partrec (Nat.unpaired f) ↔ Partrec₂ f 
Arguments: {α : Type u_1} [Primcodable α] {f : ℕ → ℕ →. α}
Goal: Partrec (Nat.unpaired f) ↔ Partrec₂ f
-- Partrec₂.unpaired'
theorem unpaired' {f : ℕ → ℕ →. ℕ} : Nat.Partrec (Nat.unpaired f) ↔ Partrec₂ f 
Arguments: {f : ℕ → ℕ →. ℕ}
Goal: Nat.Partrec (Nat.unpaired f) ↔ Partrec₂ f
-- Partrec₂.comp
nonrec theorem comp {f : β → γ →. σ} {g : α → β} {h : α → γ} (hf : Partrec₂ f) (hg : Computable g)
    (hh : Computable h) : Partrec fun a => f (g a) (h a) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {σ : Type u_5} [Primcodable α] [Primcodable β] [Primcodable γ] [Primcodable σ] {f : β → γ →. σ} {g : α → β} {h : α → γ} (hf : Partrec₂ f) (hg : Computable g) (hh : Computable h)
Goal: Partrec fun a => f (g a) (h a)
-- Partrec₂.comp₂
theorem comp₂ {f : γ → δ →. σ} {g : α → β → γ} {h : α → β → δ} (hf : Partrec₂ f)
    (hg : Computable₂ g) (hh : Computable₂ h) : Partrec₂ fun a b => f (g a b) (h a b) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {σ : Type u_5} [Primcodable α] [Primcodable β] [Primcodable γ] [Primcodable δ] [Primcodable σ] {f : γ → δ →. σ} {g : α → β → γ} {h : α → β → δ} (hf : Partrec₂ f) (hg : Computable₂ g) (hh : Computable₂ h)
Goal: Partrec₂ fun a b => f (g a b) (h a b)
-- Computable.comp
nonrec theorem comp {f : β → σ} {g : α → β} (hf : Computable f) (hg : Computable g) :
    Computable fun a => f (g a) 
Arguments: {α : Type u_1} {β : Type u_2} {σ : Type u_4} [Primcodable α] [Primcodable β] [Primcodable σ] {f : β → σ} {g : α → β} (hf : Computable f) (hg : Computable g)
Goal: Computable fun a => f (g a)
-- Computable.comp₂
theorem comp₂ {f : γ → σ} {g : α → β → γ} (hf : Computable f) (hg : Computable₂ g) :
    Computable₂ fun a b => f (g a b) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {σ : Type u_4} [Primcodable α] [Primcodable β] [Primcodable γ] [Primcodable σ] {f : γ → σ} {g : α → β → γ} (hf : Computable f) (hg : Computable₂ g)
Goal: Computable₂ fun a b => f (g a b)
-- Computable₂.mk
theorem mk {f : α → β → σ} (hf : Computable fun p : α × β => f p.1 p.2) : Computable₂ f 
Arguments: {α : Type u_1} {β : Type u_2} {σ : Type u_5} [Primcodable α] [Primcodable β] [Primcodable σ] {f : α → β → σ} (hf : Computable fun p => f p.1 p.2)
Goal: Computable₂ f
-- Computable₂.comp
nonrec theorem comp {f : β → γ → σ} {g : α → β} {h : α → γ} (hf : Computable₂ f)
    (hg : Computable g) (hh : Computable h) : Computable fun a => f (g a) (h a) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {σ : Type u_5} [Primcodable α] [Primcodable β] [Primcodable γ] [Primcodable σ] {f : β → γ → σ} {g : α → β} {h : α → γ} (hf : Computable₂ f) (hg : Computable g) (hh : Computable h)
Goal: Computable fun a => f (g a) (h a)
-- Computable₂.comp₂
theorem comp₂ {f : γ → δ → σ} {g : α → β → γ} {h : α → β → δ} (hf : Computable₂ f)
    (hg : Computable₂ g) (hh : Computable₂ h) : Computable₂ fun a b => f (g a b) (h a b) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {σ : Type u_5} [Primcodable α] [Primcodable β] [Primcodable γ] [Primcodable δ] [Primcodable σ] {f : γ → δ → σ} {g : α → β → γ} {h : α → β → δ} (hf : Computable₂ f) (hg : Computable₂ g) (hh : Computable₂ h)
Goal: Computable₂ fun a b => f (g a b) (h a b)
-- Partrec.rfind
theorem rfind {p : α → ℕ →. Bool} (hp : Partrec₂ p) : Partrec fun a => Nat.rfind (p a) 
Arguments: {α : Type u_1} [Primcodable α] {p : α → ℕ →. Bool} (hp : Partrec₂ p)
Goal: Partrec fun a => Nat.rfind (p a)
-- Partrec.rfindOpt
theorem rfindOpt {f : α → ℕ → Option σ} (hf : Computable₂ f) :
    Partrec fun a => Nat.rfindOpt (f a) 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {f : α → ℕ → Option σ} (hf : Computable₂ f)
Goal: Partrec fun a => Nat.rfindOpt (f a)
-- Partrec.nat_casesOn_right
theorem nat_casesOn_right {f : α → ℕ} {g : α → σ} {h : α → ℕ →. σ} (hf : Computable f)
    (hg : Computable g) (hh : Partrec₂ h) : Partrec fun a => (f a).casesOn (some (g a)) (h a) 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {f : α → ℕ} {g : α → σ} {h : α → ℕ →. σ} (hf : Computable f) (hg : Computable g) (hh : Partrec₂ h)
Goal: Partrec fun a => Nat.casesOn (f a) (Part.some (g a)) (h a)
-- Partrec.bind_decode₂_iff
theorem bind_decode₂_iff {f : α →. σ} :
    Partrec f ↔ Nat.Partrec fun n => Part.bind (decode₂ α n) fun a => (f a).map encode 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {f : α →. σ}
Goal: Partrec f ↔ Nat.Partrec fun n => (↑(Encodable.decode₂ α n)).bind fun a => Part.map Encodable.encode (f a)
-- Partrec.vector_mOfFn
theorem vector_mOfFn :
    ∀ {n} {f : Fin n → α →. σ},
      (∀ i, Partrec (f i)) → Partrec fun a : α => Vector.mOfFn fun i => f i a
  
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {n : ℕ} {f : Fin n → α →. σ}
Goal: (∀ (i : Fin n), Partrec (f i)) → Partrec fun a => Mathlib.Vector.mOfFn fun i => f i a
-- Vector.mOfFn_part_some
@[simp]
theorem Vector.mOfFn_part_some {α n} :
    ∀ f : Fin n → α, (Vector.mOfFn fun i => Part.some (f i)) = Part.some (Vector.ofFn f) 
Arguments: {α : Type u_1} {n : ℕ} (f : Fin n → α)
Goal: (Mathlib.Vector.mOfFn fun i => Part.some (f i)) = Part.some (Mathlib.Vector.ofFn f)
-- Computable.option_some_iff
theorem option_some_iff {f : α → σ} : (Computable fun a => Option.some (f a)) ↔ Computable f 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {f : α → σ}
Goal: (Computable fun a => some (f a)) ↔ Computable f
-- Computable.bind_decode_iff
theorem bind_decode_iff {f : α → β → Option σ} :
    (Computable₂ fun a n => (decode (α := β) n).bind (f a)) ↔ Computable₂ f 
Arguments: {α : Type u_1} {β : Type u_2} {σ : Type u_4} [Primcodable α] [Primcodable β] [Primcodable σ] {f : α → β → Option σ}
Goal: (Computable₂ fun a n => (Encodable.decode n).bind (f a)) ↔ Computable₂ f
-- Computable.map_decode_iff
theorem map_decode_iff {f : α → β → σ} :
    (Computable₂ fun a n => (decode (α := β) n).map (f a)) ↔ Computable₂ f 
Arguments: {α : Type u_1} {β : Type u_2} {σ : Type u_4} [Primcodable α] [Primcodable β] [Primcodable σ] {f : α → β → σ}
Goal: (Computable₂ fun a n => Option.map (f a) (Encodable.decode n)) ↔ Computable₂ f
-- Computable.nat_rec
theorem nat_rec {f : α → ℕ} {g : α → σ} {h : α → ℕ × σ → σ} (hf : Computable f) (hg : Computable g)
    (hh : Computable₂ h) :
    Computable fun a => Nat.rec (motive := fun _ => σ) (g a) (fun y IH => h a (y, IH)) (f a) 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {f : α → ℕ} {g : α → σ} {h : α → ℕ × σ → σ} (hf : Computable f) (hg : Computable g) (hh : Computable₂ h)
Goal: Computable fun a => Nat.rec (g a) (fun y IH => h a (y, IH)) (f a)
-- Computable.nat_casesOn
theorem nat_casesOn {f : α → ℕ} {g : α → σ} {h : α → ℕ → σ} (hf : Computable f) (hg : Computable g)
    (hh : Computable₂ h) :
    Computable fun a => Nat.casesOn (motive := fun _ => σ) (f a) (g a) (h a) 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {f : α → ℕ} {g : α → σ} {h : α → ℕ → σ} (hf : Computable f) (hg : Computable g) (hh : Computable₂ h)
Goal: Computable fun a => Nat.casesOn (f a) (g a) (h a)
-- Computable.cond
theorem cond {c : α → Bool} {f : α → σ} {g : α → σ} (hc : Computable c) (hf : Computable f)
    (hg : Computable g) : Computable fun a => cond (c a) (f a) (g a) 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {c : α → Bool} {f g : α → σ} (hc : Computable c) (hf : Computable f) (hg : Computable g)
Goal: Computable fun a => bif c a then f a else g a
-- Computable.option_casesOn
theorem option_casesOn {o : α → Option β} {f : α → σ} {g : α → β → σ} (ho : Computable o)
    (hf : Computable f) (hg : Computable₂ g) :
    @Computable _ σ _ _ fun a => Option.casesOn (o a) (f a) (g a) 
Arguments: {α : Type u_1} {β : Type u_2} {σ : Type u_4} [Primcodable α] [Primcodable β] [Primcodable σ] {o : α → Option β} {f : α → σ} {g : α → β → σ} (ho : Computable o) (hf : Computable f) (hg : Computable₂ g)
Goal: Computable fun a => Option.casesOn (o a) (f a) (g a)
-- Computable.option_bind
theorem option_bind {f : α → Option β} {g : α → β → Option σ} (hf : Computable f)
    (hg : Computable₂ g) : Computable fun a => (f a).bind (g a) 
Arguments: {α : Type u_1} {β : Type u_2} {σ : Type u_4} [Primcodable α] [Primcodable β] [Primcodable σ] {f : α → Option β} {g : α → β → Option σ} (hf : Computable f) (hg : Computable₂ g)
Goal: Computable fun a => (f a).bind (g a)
-- Computable.option_map
theorem option_map {f : α → Option β} {g : α → β → σ} (hf : Computable f) (hg : Computable₂ g) :
    Computable fun a => (f a).map (g a) 
Arguments: {α : Type u_1} {β : Type u_2} {σ : Type u_4} [Primcodable α] [Primcodable β] [Primcodable σ] {f : α → Option β} {g : α → β → σ} (hf : Computable f) (hg : Computable₂ g)
Goal: Computable fun a => Option.map (g a) (f a)
-- Computable.option_getD
theorem option_getD {f : α → Option β} {g : α → β} (hf : Computable f) (hg : Computable g) :
    Computable fun a => (f a).getD (g a) 
Arguments: {α : Type u_1} {β : Type u_2} [Primcodable α] [Primcodable β] {f : α → Option β} {g : α → β} (hf : Computable f) (hg : Computable g)
Goal: Computable fun a => (f a).getD (g a)