ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Computable.subtype_mk
theorem subtype_mk {f : α → β} {p : β → Prop} [DecidablePred p] {h : ∀ a, p (f a)}
    (hp : PrimrecPred p) (hf : Computable f) :
    @Computable _ _ _ (Primcodable.subtype hp) fun a => (⟨f a, h a⟩ : Subtype p) 
Arguments: {α : Type u_1} {β : Type u_2} [Primcodable α] [Primcodable β] {f : α → β} {p : β → Prop} [DecidablePred p] {h : ∀ (a : α), p (f a)} (hp : PrimrecPred p) (hf : Computable f)
Goal: Computable fun a => ⟨f a, ⋯⟩
-- Computable.sum_casesOn
theorem sum_casesOn {f : α → β ⊕ γ} {g : α → β → σ} {h : α → γ → σ} (hf : Computable f)
    (hg : Computable₂ g) (hh : Computable₂ h) :
    @Computable _ σ _ _ fun a => Sum.casesOn (f a) (g a) (h a) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {σ : Type u_4} [Primcodable α] [Primcodable β] [Primcodable γ] [Primcodable σ] {f : α → β ⊕ γ} {g : α → β → σ} {h : α → γ → σ} (hf : Computable f) (hg : Computable₂ g) (hh : Computable₂ h)
Goal: Computable fun a => Sum.casesOn (f a) (g a) (h a)
-- Computable.nat_strong_rec
theorem nat_strong_rec (f : α → ℕ → σ) {g : α → List σ → Option σ} (hg : Computable₂ g)
    (H : ∀ a n, g a ((List.range n).map (f a)) = Option.some (f a n)) : Computable₂ f 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] (f : α → ℕ → σ) {g : α → List σ → Option σ} (hg : Computable₂ g) (H : ∀ (a : α) (n : ℕ), g a (List.map (f a) (List.range n)) = some (f a n))
Goal: Computable₂ f
-- Computable.list_ofFn
theorem list_ofFn :
    ∀ {n} {f : Fin n → α → σ},
      (∀ i, Computable (f i)) → Computable fun a => List.ofFn fun i => f i a
  
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {n : ℕ} {f : Fin n → α → σ}
Goal: (∀ (i : Fin n), Computable (f i)) → Computable fun a => List.ofFn fun i => f i a
-- Computable.vector_ofFn
theorem vector_ofFn {n} {f : Fin n → α → σ} (hf : ∀ i, Computable (f i)) :
    Computable fun a => Vector.ofFn fun i => f i a 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {n : ℕ} {f : Fin n → α → σ} (hf : ∀ (i : Fin n), Computable (f i))
Goal: Computable fun a => Mathlib.Vector.ofFn fun i => f i a
-- Partrec.option_some_iff
theorem option_some_iff {f : α →. σ} : (Partrec fun a => (f a).map Option.some) ↔ Partrec f 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {f : α →. σ}
Goal: (Partrec fun a => Part.map some (f a)) ↔ Partrec f
-- Partrec.option_casesOn_right
theorem option_casesOn_right {o : α → Option β} {f : α → σ} {g : α → β →. σ} (ho : Computable o)
    (hf : Computable f) (hg : Partrec₂ g) :
    @Partrec _ σ _ _ fun a => Option.casesOn (o a) (Part.some (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 : Partrec₂ g)
Goal: Partrec fun a => Option.casesOn (o a) (Part.some (f a)) (g a)
-- Partrec.sum_casesOn_right
theorem sum_casesOn_right {f : α → β ⊕ γ} {g : α → β → σ} {h : α → γ →. σ} (hf : Computable f)
    (hg : Computable₂ g) (hh : Partrec₂ h) :
    @Partrec _ σ _ _ fun a => Sum.casesOn (f a) (fun b => Part.some (g a b)) (h a) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {σ : Type u_4} [Primcodable α] [Primcodable β] [Primcodable γ] [Primcodable σ] {f : α → β ⊕ γ} {g : α → β → σ} {h : α → γ →. σ} (hf : Computable f) (hg : Computable₂ g) (hh : Partrec₂ h)
Goal: Partrec fun a => Sum.casesOn (f a) (fun b => Part.some (g a b)) (h a)
-- Partrec.sum_casesOn_left
theorem sum_casesOn_left {f : α → β ⊕ γ} {g : α → β →. σ} {h : α → γ → σ} (hf : Computable f)
    (hg : Partrec₂ g) (hh : Computable₂ h) :
    @Partrec _ σ _ _ fun a => Sum.casesOn (f a) (g a) fun c => Part.some (h a c) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {σ : Type u_4} [Primcodable α] [Primcodable β] [Primcodable γ] [Primcodable σ] {f : α → β ⊕ γ} {g : α → β →. σ} {h : α → γ → σ} (hf : Computable f) (hg : Partrec₂ g) (hh : Computable₂ h)
Goal: Partrec fun a => Sum.casesOn (f a) (g a) fun c => Part.some (h a c)
-- Partrec.fix_aux
theorem fix_aux {α σ} (f : α →. σ ⊕ α) (a : α) (b : σ) :
    let F : α → ℕ →. σ ⊕ α := fun a n =>
      n.rec (some (Sum.inr a)) fun _ IH => IH.bind fun s => Sum.casesOn s (fun _ => Part.some s) f
    (∃ n : ℕ,
        ((∃ b' : σ, Sum.inl b' ∈ F a n) ∧ ∀ {m : ℕ}, m < n → ∃ b : α, Sum.inr b ∈ F a m) ∧
          Sum.inl b ∈ F a n) ↔
      b ∈ PFun.fix f a 
Arguments: {α : Type u_5} {σ : Type u_6} (f : α →. σ ⊕ α) (a : α) (b : σ)
Goal: let F := fun a n =>
  Nat.rec (Part.some (Sum.inr a)) (fun x IH => IH.bind fun s => Sum.casesOn s (fun x => Part.some s) f) n;
(∃ n, ((∃ b', Sum.inl b' ∈ F a n) ∧ ∀ {m : ℕ}, m < n → ∃ b, Sum.inr b ∈ F a m) ∧ Sum.inl b ∈ F a n) ↔ b ∈ f.fix a
-- Partrec.fix
theorem fix {f : α →. σ ⊕ α} (hf : Partrec f) : Partrec (PFun.fix f) 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {f : α →. σ ⊕ α} (hf : Partrec f)
Goal: Partrec f.fix
-- ack_zero
@[simp]
theorem ack_zero (n : ℕ) : ack 0 n = n + 1 
Arguments: (n : ℕ)
Goal: ack 0 n = n + 1
-- ack_succ_zero
@[simp]
theorem ack_succ_zero (m : ℕ) : ack (m + 1) 0 = ack m 1 
Arguments: (m : ℕ)
Goal: ack (m + 1) 0 = ack m 1
-- ack_succ_succ
@[simp]
theorem ack_succ_succ (m n : ℕ) : ack (m + 1) (n + 1) = ack m (ack (m + 1) n) 
Arguments: (m n : ℕ)
Goal: ack (m + 1) (n + 1) = ack m (ack (m + 1) n)
-- ack_one
@[simp]
theorem ack_one (n : ℕ) : ack 1 n = n + 2 
Arguments: (n : ℕ)
Goal: ack 1 n = n + 2
-- ack_two
@[simp]
theorem ack_two (n : ℕ) : ack 2 n = 2 * n + 3 
Arguments: (n : ℕ)
Goal: ack 2 n = 2 * n + 3
-- ack_three
@[simp]
theorem ack_three (n : ℕ) : ack 3 n = 2 ^ (n + 3) - 3 
Arguments: (n : ℕ)
Goal: ack 3 n = 2 ^ (n + 3) - 3
-- ack_pos
theorem ack_pos : ∀ m n, 0 < ack m n
  
Arguments: (m n : ℕ)
Goal: 0 < ack m n
-- one_lt_ack_succ_left
theorem one_lt_ack_succ_left : ∀ m n, 1 < ack (m + 1) n
  
Arguments: (m n : ℕ)
Goal: 1 < ack (m + 1) n
-- one_lt_ack_succ_right
theorem one_lt_ack_succ_right : ∀ m n, 1 < ack m (n + 1)
  
Arguments: (m n : ℕ)
Goal: 1 < ack m (n + 1)
-- ack_strictMono_right
theorem ack_strictMono_right : ∀ m, StrictMono (ack m)
  
Arguments: (m : ℕ)
Goal: StrictMono (ack m)
-- ack_mono_right
theorem ack_mono_right (m : ℕ) : Monotone (ack m) 
Arguments: (m : ℕ)
Goal: Monotone (ack m)
-- ack_injective_right
theorem ack_injective_right (m : ℕ) : Function.Injective (ack m) 
Arguments: (m : ℕ)
Goal: Function.Injective (ack m)
-- ack_lt_iff_right
@[simp]
theorem ack_lt_iff_right {m n₁ n₂ : ℕ} : ack m n₁ < ack m n₂ ↔ n₁ < n₂ 
Arguments: {m n₁ n₂ : ℕ}
Goal: ack m n₁ < ack m n₂ ↔ n₁ < n₂
-- ack_le_iff_right
@[simp]
theorem ack_le_iff_right {m n₁ n₂ : ℕ} : ack m n₁ ≤ ack m n₂ ↔ n₁ ≤ n₂ 
Arguments: {m n₁ n₂ : ℕ}
Goal: ack m n₁ ≤ ack m n₂ ↔ n₁ ≤ n₂
-- ack_inj_right
@[simp]
theorem ack_inj_right {m n₁ n₂ : ℕ} : ack m n₁ = ack m n₂ ↔ n₁ = n₂ 
Arguments: {m n₁ n₂ : ℕ}
Goal: ack m n₁ = ack m n₂ ↔ n₁ = n₂
-- max_ack_right
theorem max_ack_right (m n₁ n₂ : ℕ) : ack m (max n₁ n₂) = max (ack m n₁) (ack m n₂) 
Arguments: (m n₁ n₂ : ℕ)
Goal: ack m (max n₁ n₂) = max (ack m n₁) (ack m n₂)
-- add_lt_ack
theorem add_lt_ack : ∀ m n, m + n < ack m n
  
Arguments: (m n : ℕ)
Goal: m + n < ack m n
-- add_add_one_le_ack
theorem add_add_one_le_ack (m n : ℕ) : m + n + 1 ≤ ack m n 
Arguments: (m n : ℕ)
Goal: m + n + 1 ≤ ack m n
-- lt_ack_left
theorem lt_ack_left (m n : ℕ) : m < ack m n 
Arguments: (m n : ℕ)
Goal: m < ack m n
-- lt_ack_right
theorem lt_ack_right (m n : ℕ) : n < ack m n 
Arguments: (m n : ℕ)
Goal: n < ack m n
-- _private.Mathlib.Computability.Ackermann.0.ack_strict_mono_left'
private theorem ack_strict_mono_left' : ∀ {m₁ m₂} (n), m₁ < m₂ → ack m₁ n < ack m₂ n
  
Arguments: {m₁ m₂ : ℕ} (n : ℕ)
Goal: m₁ < m₂ → ack m₁ n < ack m₂ n
-- ack_strictMono_left
theorem ack_strictMono_left (n : ℕ) : StrictMono fun m => ack m n 
Arguments: (n : ℕ)
Goal: StrictMono fun m => ack m n
-- ack_mono_left
theorem ack_mono_left (n : ℕ) : Monotone fun m => ack m n 
Arguments: (n : ℕ)
Goal: Monotone fun m => ack m n
-- ack_injective_left
theorem ack_injective_left (n : ℕ) : Function.Injective fun m => ack m n 
Arguments: (n : ℕ)
Goal: Function.Injective fun m => ack m n
-- ack_lt_iff_left
@[simp]
theorem ack_lt_iff_left {m₁ m₂ n : ℕ} : ack m₁ n < ack m₂ n ↔ m₁ < m₂ 
Arguments: {m₁ m₂ n : ℕ}
Goal: ack m₁ n < ack m₂ n ↔ m₁ < m₂
-- ack_le_iff_left
@[simp]
theorem ack_le_iff_left {m₁ m₂ n : ℕ} : ack m₁ n ≤ ack m₂ n ↔ m₁ ≤ m₂ 
Arguments: {m₁ m₂ n : ℕ}
Goal: ack m₁ n ≤ ack m₂ n ↔ m₁ ≤ m₂
-- ack_inj_left
@[simp]
theorem ack_inj_left {m₁ m₂ n : ℕ} : ack m₁ n = ack m₂ n ↔ m₁ = m₂ 
Arguments: {m₁ m₂ n : ℕ}
Goal: ack m₁ n = ack m₂ n ↔ m₁ = m₂
-- max_ack_left
theorem max_ack_left (m₁ m₂ n : ℕ) : ack (max m₁ m₂) n = max (ack m₁ n) (ack m₂ n) 
Arguments: (m₁ m₂ n : ℕ)
Goal: ack (max m₁ m₂) n = max (ack m₁ n) (ack m₂ n)
-- ack_le_ack
theorem ack_le_ack {m₁ m₂ n₁ n₂ : ℕ} (hm : m₁ ≤ m₂) (hn : n₁ ≤ n₂) : ack m₁ n₁ ≤ ack m₂ n₂ 
Arguments: {m₁ m₂ n₁ n₂ : ℕ} (hm : m₁ ≤ m₂) (hn : n₁ ≤ n₂)
Goal: ack m₁ n₁ ≤ ack m₂ n₂
-- ack_succ_right_le_ack_succ_left
theorem ack_succ_right_le_ack_succ_left (m n : ℕ) : ack m (n + 1) ≤ ack (m + 1) n 
Arguments: (m n : ℕ)
Goal: ack m (n + 1) ≤ ack (m + 1) n
-- _private.Mathlib.Computability.Ackermann.0.sq_le_two_pow_add_one_minus_three
private theorem sq_le_two_pow_add_one_minus_three (n : ℕ) : n ^ 2 ≤ 2 ^ (n + 1) - 3 
Arguments: (n : ℕ)
Goal: n ^ 2 ≤ 2 ^ (n + 1) - 3
-- ack_add_one_sq_lt_ack_add_three
theorem ack_add_one_sq_lt_ack_add_three : ∀ m n, (ack m n + 1) ^ 2 ≤ ack (m + 3) n
  
Arguments: (m n : ℕ)
Goal: (ack m n + 1) ^ 2 ≤ ack (m + 3) n
-- ack_ack_lt_ack_max_add_two
theorem ack_ack_lt_ack_max_add_two (m n k : ℕ) : ack m (ack n k) < ack (max m n + 2) k 
Arguments: (m n k : ℕ)
Goal: ack m (ack n k) < ack (max m n + 2) k
-- ack_add_one_sq_lt_ack_add_four
theorem ack_add_one_sq_lt_ack_add_four (m n : ℕ) : ack m ((n + 1) ^ 2) < ack (m + 4) n 
Arguments: (m n : ℕ)
Goal: ack m ((n + 1) ^ 2) < ack (m + 4) n
-- ack_pair_lt
theorem ack_pair_lt (m n k : ℕ) : ack m (pair n k) < ack (m + 4) (max n k) 
Arguments: (m n k : ℕ)
Goal: ack m (Nat.pair n k) < ack (m + 4) (max n k)
-- exists_lt_ack_of_nat_primrec
theorem exists_lt_ack_of_nat_primrec {f : ℕ → ℕ} (hf : Nat.Primrec f) :
    ∃ m, ∀ n, f n < ack m n 
Arguments: {f : ℕ → ℕ} (hf : Nat.Primrec f)
Goal: ∃ m, ∀ (n : ℕ), f n < ack m n
-- not_nat_primrec_ack_self
theorem not_nat_primrec_ack_self : ¬Nat.Primrec fun n => ack n n 
Goal: ¬Nat.Primrec fun n => ack n n
-- not_primrec_ack_self
theorem not_primrec_ack_self : ¬Primrec fun n => ack n n 
Goal: ¬Primrec fun n => ack n n
-- not_primrec₂_ack
theorem not_primrec₂_ack : ¬Primrec₂ ack 
Goal: ¬Primrec₂ ack
-- Nat.Partrec.merge'
theorem merge' {f g} (hf : Nat.Partrec f) (hg : Nat.Partrec g) :
    ∃ h, Nat.Partrec h ∧
      ∀ a, (∀ x ∈ h a, x ∈ f a ∨ x ∈ g a) ∧ ((h a).Dom ↔ (f a).Dom ∨ (g a).Dom) 
Arguments: {f g : ℕ →. ℕ} (hf : Nat.Partrec f) (hg : Nat.Partrec g)
Goal: ∃ h, Nat.Partrec h ∧ ∀ (a : ℕ), (∀ x ∈ h a, x ∈ f a ∨ x ∈ g a) ∧ ((h a).Dom ↔ (f a).Dom ∨ (g a).Dom)
-- Partrec.merge'
theorem merge' {f g : α →. σ} (hf : Partrec f) (hg : Partrec g) :
    ∃ k : α →. σ,
      Partrec k ∧ ∀ a, (∀ x ∈ k a, x ∈ f a ∨ x ∈ g a) ∧ ((k a).Dom ↔ (f a).Dom ∨ (g a).Dom) 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {f g : α →. σ} (hf : Partrec f) (hg : Partrec g)
Goal: ∃ k, Partrec k ∧ ∀ (a : α), (∀ x ∈ k a, x ∈ f a ∨ x ∈ g a) ∧ ((k a).Dom ↔ (f a).Dom ∨ (g a).Dom)
-- Partrec.merge
theorem merge {f g : α →. σ} (hf : Partrec f) (hg : Partrec g)
    (H : ∀ (a), ∀ x ∈ f a, ∀ y ∈ g a, x = y) :
    ∃ k : α →. σ, Partrec k ∧ ∀ a x, x ∈ k a ↔ x ∈ f a ∨ x ∈ g a 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {f g : α →. σ} (hf : Partrec f) (hg : Partrec g) (H : ∀ (a : α), ∀ x ∈ f a, ∀ y ∈ g a, x = y)
Goal: ∃ k, Partrec k ∧ ∀ (a : α) (x : σ), x ∈ k a ↔ x ∈ f a ∨ x ∈ g a
-- Partrec.cond
theorem cond {c : α → Bool} {f : α →. σ} {g : α →. σ} (hc : Computable c) (hf : Partrec f)
    (hg : Partrec g) : Partrec 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 : Partrec f) (hg : Partrec g)
Goal: Partrec fun a => bif c a then f a else g a
-- Partrec.sum_casesOn
nonrec theorem sum_casesOn {f : α → β ⊕ γ} {g : α → β →. σ} {h : α → γ →. σ} (hf : Computable f)
    (hg : Partrec₂ g) (hh : Partrec₂ h) : @Partrec _ σ _ _ fun a => Sum.casesOn (f a) (g a) (h a) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {σ : Type u_4} [Primcodable α] [Primcodable β] [Primcodable γ] [Primcodable σ] {f : α → β ⊕ γ} {g : α → β →. σ} {h : α → γ →. σ} (hf : Computable f) (hg : Partrec₂ g) (hh : Partrec₂ h)
Goal: Partrec fun a => Sum.casesOn (f a) (g a) (h a)
-- RePred.of_eq
theorem RePred.of_eq {α} [Primcodable α] {p q : α → Prop} (hp : RePred p) (H : ∀ a, p a ↔ q a) :
    RePred q 
Arguments: {α : Type u_1} [Primcodable α] {p q : α → Prop} (hp : RePred p) (H : ∀ (a : α), p a ↔ q a)
Goal: RePred q
-- Partrec.dom_re
theorem Partrec.dom_re {α β} [Primcodable α] [Primcodable β] {f : α →. β} (h : Partrec f) :
    RePred fun a => (f a).Dom 
Arguments: {α : Type u_1} {β : Type u_2} [Primcodable α] [Primcodable β] {f : α →. β} (h : Partrec f)
Goal: RePred fun a => (f a).Dom
-- ComputablePred.of_eq
theorem ComputablePred.of_eq {α} [Primcodable α] {p q : α → Prop} (hp : ComputablePred p)
    (H : ∀ a, p a ↔ q a) : ComputablePred q 
Arguments: {α : Type u_1} [Primcodable α] {p q : α → Prop} (hp : ComputablePred p) (H : ∀ (a : α), p a ↔ q a)
Goal: ComputablePred q
-- ComputablePred.computable_iff
theorem computable_iff {p : α → Prop} :
    ComputablePred p ↔ ∃ f : α → Bool, Computable f ∧ p = fun a => (f a : Prop) 
Arguments: {α : Type u_1} [Primcodable α] {p : α → Prop}
Goal: ComputablePred p ↔ ∃ f, Computable f ∧ p = fun a => f a = true
-- ComputablePred.not
protected theorem not {p : α → Prop} (hp : ComputablePred p) : ComputablePred fun a => ¬p a 
Arguments: {α : Type u_1} [Primcodable α] {p : α → Prop} (hp : ComputablePred p)
Goal: ComputablePred fun a => ¬p a
-- ComputablePred.to_re
theorem to_re {p : α → Prop} (hp : ComputablePred p) : RePred p 
Arguments: {α : Type u_1} [Primcodable α] {p : α → Prop} (hp : ComputablePred p)
Goal: RePred p
-- ComputablePred.rice
theorem rice (C : Set (ℕ →. ℕ)) (h : ComputablePred fun c => eval c ∈ C) {f g} (hf : Nat.Partrec f)
    (hg : Nat.Partrec g) (fC : f ∈ C) : g ∈ C 
Arguments: (C : Set (ℕ →. ℕ)) (h : ComputablePred fun c => c.eval ∈ C) {f g : ℕ →. ℕ} (hf : Nat.Partrec f) (hg : Nat.Partrec g) (fC : f ∈ C)
Goal: g ∈ C
-- ComputablePred.rice₂
theorem rice₂ (C : Set Code) (H : ∀ cf cg, eval cf = eval cg → (cf ∈ C ↔ cg ∈ C)) :
    (ComputablePred fun c => c ∈ C) ↔ C = ∅ ∨ C = Set.univ 
Arguments: (C : Set Nat.Partrec.Code) (H : ∀ (cf cg : Nat.Partrec.Code), cf.eval = cg.eval → (cf ∈ C ↔ cg ∈ C))
Goal: (ComputablePred fun c => c ∈ C) ↔ C = ∅ ∨ C = Set.univ
-- ComputablePred.halting_problem_re
theorem halting_problem_re (n) : RePred fun c => (eval c n).Dom 
Arguments: (n : ℕ)
Goal: RePred fun c => (c.eval n).Dom
-- ComputablePred.halting_problem
theorem halting_problem (n) : ¬ComputablePred fun c => (eval c n).Dom
  
Arguments: (n : ℕ)
Goal: ¬ComputablePred fun c => (c.eval n).Dom
-- ComputablePred.computable_iff_re_compl_re
theorem computable_iff_re_compl_re {p : α → Prop} [DecidablePred p] :
    ComputablePred p ↔ RePred p ∧ RePred fun a => ¬p a 
Arguments: {α : Type u_1} [Primcodable α] {p : α → Prop} [DecidablePred p]
Goal: ComputablePred p ↔ RePred p ∧ RePred fun a => ¬p a
-- ComputablePred.computable_iff_re_compl_re'
theorem computable_iff_re_compl_re' {p : α → Prop} :
    ComputablePred p ↔ RePred p ∧ RePred fun a => ¬p a 
Arguments: {α : Type u_1} [Primcodable α] {p : α → Prop}
Goal: ComputablePred p ↔ RePred p ∧ RePred fun a => ¬p a
-- ComputablePred.halting_problem_not_re
theorem halting_problem_not_re (n) : ¬RePred fun c => ¬(eval c n).Dom
  
Arguments: (n : ℕ)
Goal: ¬RePred fun c => ¬(c.eval n).Dom
-- Nat.Partrec'.to_part
theorem to_part {n f} (pf : @Partrec' n f) : _root_.Partrec f 
Arguments: {n : ℕ} {f : Mathlib.Vector ℕ n →. ℕ} (pf : Nat.Partrec' f)
Goal: Partrec f
-- Nat.Partrec'.of_eq
theorem of_eq {n} {f g : Vector ℕ n →. ℕ} (hf : Partrec' f) (H : ∀ i, f i = g i) : Partrec' g 
Arguments: {n : ℕ} {f g : Mathlib.Vector ℕ n →. ℕ} (hf : Nat.Partrec' f) (H : ∀ (i : Mathlib.Vector ℕ n), f i = g i)
Goal: Nat.Partrec' g
-- Nat.Partrec'.of_prim
theorem of_prim {n} {f : Vector ℕ n → ℕ} (hf : Primrec f) : @Partrec' n f 
Arguments: {n : ℕ} {f : Mathlib.Vector ℕ n → ℕ} (hf : Primrec f)
Goal: Nat.Partrec' ↑f
-- Nat.Partrec'.head
theorem head {n : ℕ} : @Partrec' n.succ (@head ℕ n) 
Arguments: {n : ℕ}
Goal: Nat.Partrec' ↑Mathlib.Vector.head
-- Nat.Partrec'.tail
theorem tail {n f} (hf : @Partrec' n f) : @Partrec' n.succ fun v => f v.tail 
Arguments: {n : ℕ} {f : Mathlib.Vector ℕ n →. ℕ} (hf : Nat.Partrec' f)
Goal: Nat.Partrec' fun v => f v.tail
-- Nat.Partrec'.bind
protected theorem bind {n f g} (hf : @Partrec' n f) (hg : @Partrec' (n + 1) g) :
    @Partrec' n fun v => (f v).bind fun a => g (a ::ᵥ v) 
Arguments: {n : ℕ} {f : Mathlib.Vector ℕ n →. ℕ} {g : Mathlib.Vector ℕ (n + 1) →. ℕ} (hf : Nat.Partrec' f) (hg : Nat.Partrec' g)
Goal: Nat.Partrec' fun v => (f v).bind fun a => g (a ::ᵥ v)
-- Nat.Partrec'.map
protected theorem map {n f} {g : Vector ℕ (n + 1) → ℕ} (hf : @Partrec' n f)
    (hg : @Partrec' (n + 1) g) : @Partrec' n fun v => (f v).map fun a => g (a ::ᵥ v) 
Arguments: {n : ℕ} {f : Mathlib.Vector ℕ n →. ℕ} {g : Mathlib.Vector ℕ (n + 1) → ℕ} (hf : Nat.Partrec' f) (hg : Nat.Partrec' ↑g)
Goal: Nat.Partrec' fun v => Part.map (fun a => g (a ::ᵥ v)) (f v)
-- Nat.Partrec'.Vec.prim
nonrec theorem Vec.prim {n m f} (hf : @Nat.Primrec'.Vec n m f) : Vec f 
Arguments: {n m : ℕ} {f : Mathlib.Vector ℕ n → Mathlib.Vector ℕ m} (hf : Nat.Primrec'.Vec f)
Goal: Nat.Partrec'.Vec f
-- Nat.Partrec'.nil
protected theorem nil {n} : @Vec n 0 fun _ => nil 
Arguments: {n : ℕ}
Goal: Nat.Partrec'.Vec fun x => Mathlib.Vector.nil
-- Nat.Partrec'.cons
protected theorem cons {n m} {f : Vector ℕ n → ℕ} {g} (hf : @Partrec' n f) (hg : @Vec n m g) :
    Vec fun v => f v ::ᵥ g v 
Arguments: {n m : ℕ} {f : Mathlib.Vector ℕ n → ℕ} {g : Mathlib.Vector ℕ n → Mathlib.Vector ℕ m} (hf : Nat.Partrec' ↑f) (hg : Nat.Partrec'.Vec g)
Goal: Nat.Partrec'.Vec fun v => f v ::ᵥ g v
-- Nat.Partrec'.idv
theorem idv {n} : @Vec n n id 
Arguments: {n : ℕ}
Goal: Nat.Partrec'.Vec id
-- Nat.Partrec'.comp'
theorem comp' {n m f g} (hf : @Partrec' m f) (hg : @Vec n m g) : Partrec' fun v => f (g v) 
Arguments: {n m : ℕ} {f : Mathlib.Vector ℕ m →. ℕ} {g : Mathlib.Vector ℕ n → Mathlib.Vector ℕ m} (hf : Nat.Partrec' f) (hg : Nat.Partrec'.Vec g)
Goal: Nat.Partrec' fun v => f (g v)
-- Nat.Partrec'.comp₁
theorem comp₁ {n} (f : ℕ →. ℕ) {g : Vector ℕ n → ℕ} (hf : @Partrec' 1 fun v => f v.head)
    (hg : @Partrec' n g) : @Partrec' n fun v => f (g v) 
Arguments: {n : ℕ} (f : ℕ →. ℕ) {g : Mathlib.Vector ℕ n → ℕ} (hf : Nat.Partrec' fun v => f v.head) (hg : Nat.Partrec' ↑g)
Goal: Nat.Partrec' fun v => f (g v)
-- Nat.Partrec'.rfindOpt
theorem rfindOpt {n} {f : Vector ℕ (n + 1) → ℕ} (hf : @Partrec' (n + 1) f) :
    @Partrec' n fun v => Nat.rfindOpt fun a => ofNat (Option ℕ) (f (a ::ᵥ v)) 
Arguments: {n : ℕ} {f : Mathlib.Vector ℕ (n + 1) → ℕ} (hf : Nat.Partrec' ↑f)
Goal: Nat.Partrec' fun v => Nat.rfindOpt fun a => Denumerable.ofNat (Option ℕ) (f (a ::ᵥ v))
-- Nat.Partrec'.of_part
theorem of_part : ∀ {n f}, _root_.Partrec f → @Partrec' n f 
Arguments: {n : ℕ} {f : Mathlib.Vector ℕ n →. ℕ}
Goal: Partrec f → Nat.Partrec' f
-- Nat.Partrec'.part_iff
theorem part_iff {n f} : @Partrec' n f ↔ _root_.Partrec f 
Arguments: {n : ℕ} {f : Mathlib.Vector ℕ n →. ℕ}
Goal: Nat.Partrec' f ↔ Partrec f
-- Nat.Partrec'.part_iff₁
theorem part_iff₁ {f : ℕ →. ℕ} : (@Partrec' 1 fun v => f v.head) ↔ _root_.Partrec f 
Arguments: {f : ℕ →. ℕ}
Goal: (Nat.Partrec' fun v => f v.head) ↔ Partrec f
-- Nat.Partrec'.part_iff₂
theorem part_iff₂ {f : ℕ → ℕ →. ℕ} : (@Partrec' 2 fun v => f v.head v.tail.head) ↔ Partrec₂ f 
Arguments: {f : ℕ → ℕ →. ℕ}
Goal: (Nat.Partrec' fun v => f v.head v.tail.head) ↔ Partrec₂ f
-- Nat.Partrec'.vec_iff
theorem vec_iff {m n f} : @Vec m n f ↔ Computable f 
Arguments: {m n : ℕ} {f : Mathlib.Vector ℕ m → Mathlib.Vector ℕ n}
Goal: Nat.Partrec'.Vec f ↔ Computable f
-- EuclideanGeometry.dist_left_midpoint_eq_dist_right_midpoint
theorem dist_left_midpoint_eq_dist_right_midpoint (p1 p2 : P) :
    dist p1 (midpoint ℝ p1 p2) = dist p2 (midpoint ℝ p1 p2) 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] (p1 p2 : P)
Goal: dist p1 (midpoint ℝ p1 p2) = dist p2 (midpoint ℝ p1 p2)
-- EuclideanGeometry.inner_weightedVSub
theorem inner_weightedVSub {ι₁ : Type*} {s₁ : Finset ι₁} {w₁ : ι₁ → ℝ} (p₁ : ι₁ → P)
    (h₁ : ∑ i ∈ s₁, w₁ i = 0) {ι₂ : Type*} {s₂ : Finset ι₂} {w₂ : ι₂ → ℝ} (p₂ : ι₂ → P)
    (h₂ : ∑ i ∈ s₂, w₂ i = 0) :
    ⟪s₁.weightedVSub p₁ w₁, s₂.weightedVSub p₂ w₂⟫ =
      (-∑ i₁ ∈ s₁, ∑ i₂ ∈ s₂, w₁ i₁ * w₂ i₂ * (dist (p₁ i₁) (p₂ i₂) * dist (p₁ i₁) (p₂ i₂))) /
        2 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] {ι₁ : Type u_3} {s₁ : Finset ι₁} {w₁ : ι₁ → ℝ} (p₁ : ι₁ → P) (h₁ : ∑ i ∈ s₁, w₁ i = 0) {ι₂ : Type u_4} {s₂ : Finset ι₂} {w₂ : ι₂ → ℝ} (p₂ : ι₂ → P) (h₂ : ∑ i ∈ s₂, w₂ i = 0)
Goal: ⟪(s₁.weightedVSub p₁) w₁, (s₂.weightedVSub p₂) w₂⟫_ℝ =
  (-∑ i₁ ∈ s₁, ∑ i₂ ∈ s₂, w₁ i₁ * w₂ i₂ * (dist (p₁ i₁) (p₂ i₂) * dist (p₁ i₁) (p₂ i₂))) / 2
-- EuclideanGeometry.dist_affineCombination
theorem dist_affineCombination {ι : Type*} {s : Finset ι} {w₁ w₂ : ι → ℝ} (p : ι → P)
    (h₁ : ∑ i ∈ s, w₁ i = 1) (h₂ : ∑ i ∈ s, w₂ i = 1) : by
      have a₁ := s.affineCombination ℝ p w₁
      have a₂ := s.affineCombination ℝ p w₂
      exact dist a₁ a₂ * dist a₁ a₂ = (-∑ i₁ ∈ s, ∑ i₂ ∈ s,
        (w₁ - w₂) i₁ * (w₁ - w₂) i₂ * (dist (p i₁) (p i₂) * dist (p i₁) (p i₂))) / 2 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] {ι : Type u_3} {s : Finset ι} {w₁ w₂ : ι → ℝ} (p : ι → P) (h₁ : ∑ i ∈ s, w₁ i = 1) (h₂ : ∑ i ∈ s, w₂ i = 1)
Goal: let_fun a₁ := (Finset.affineCombination ℝ s p) w₁;
let_fun a₂ := (Finset.affineCombination ℝ s p) w₂;
dist a₁ a₂ * dist a₁ a₂ =
  (-∑ i₁ ∈ s, ∑ i₂ ∈ s, (w₁ - w₂) i₁ * (w₁ - w₂) i₂ * (dist (p i₁) (p i₂) * dist (p i₁) (p i₂))) / 2
-- EuclideanGeometry.dist_smul_vadd_sq
theorem dist_smul_vadd_sq (r : ℝ) (v : V) (p₁ p₂ : P) :
    dist (r • v +ᵥ p₁) p₂ * dist (r • v +ᵥ p₁) p₂ =
      ⟪v, v⟫ * r * r + 2 * ⟪v, p₁ -ᵥ p₂⟫ * r + ⟪p₁ -ᵥ p₂, p₁ -ᵥ p₂⟫ 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] (r : ℝ) (v : V) (p₁ p₂ : P)
Goal: dist (r • v +ᵥ p₁) p₂ * dist (r • v +ᵥ p₁) p₂ = ⟪v, v⟫_ℝ * r * r + 2 * ⟪v, p₁ -ᵥ p₂⟫_ℝ * r + ⟪p₁ -ᵥ p₂, p₁ -ᵥ p₂⟫_ℝ
-- EuclideanGeometry.dist_smul_vadd_eq_dist
theorem dist_smul_vadd_eq_dist {v : V} (p₁ p₂ : P) (hv : v ≠ 0) (r : ℝ) :
    dist (r • v +ᵥ p₁) p₂ = dist p₁ p₂ ↔ r = 0 ∨ r = -2 * ⟪v, p₁ -ᵥ p₂⟫ / ⟪v, v⟫ 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] {v : V} (p₁ p₂ : P) (hv : v ≠ 0) (r : ℝ)
Goal: dist (r • v +ᵥ p₁) p₂ = dist p₁ p₂ ↔ r = 0 ∨ r = -2 * ⟪v, p₁ -ᵥ p₂⟫_ℝ / ⟪v, v⟫_ℝ