ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- forall₃_imp
theorem forall₃_imp {p q : ∀ a b, γ a b → Prop} (h : ∀ a b c, p a b c → q a b c) :
    (∀ a b c, p a b c) → ∀ a b c, q a b c 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {γ : (a : α) → β a → Sort u_3} {p q : (a : α) → (b : β a) → γ a b → Prop} (h : ∀ (a : α) (b : β a) (c : γ a b), p a b c → q a b c)
Goal: (∀ (a : α) (b : β a) (c : γ a b), p a b c) → ∀ (a : α) (b : β a) (c : γ a b), q a b c
-- Exists₂.imp
theorem Exists₂.imp {p q : ∀ a, β a → Prop} (h : ∀ a b, p a b → q a b) :
    (∃ a b, p a b) → ∃ a b, q a b 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {p q : (a : α) → β a → Prop} (h : ∀ (a : α) (b : β a), p a b → q a b)
Goal: (∃ a b, p a b) → ∃ a b, q a b
-- Exists₃.imp
theorem Exists₃.imp {p q : ∀ a b, γ a b → Prop} (h : ∀ a b c, p a b c → q a b c) :
    (∃ a b c, p a b c) → ∃ a b c, q a b c 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {γ : (a : α) → β a → Sort u_3} {p q : (a : α) → (b : β a) → γ a b → Prop} (h : ∀ (a : α) (b : β a) (c : γ a b), p a b c → q a b c)
Goal: (∃ a b c, p a b c) → ∃ a b c, q a b c
-- forall_swap
theorem forall_swap {p : α → β → Prop} : (∀ x y, p x y) ↔ ∀ y x, p x y 
Arguments: {α : Sort u_1} {β : Sort u_2} {p : α → β → Prop}
Goal: (∀ (x : α) (y : β), p x y) ↔ ∀ (y : β) (x : α), p x y
-- forall₂_swap
theorem forall₂_swap
    {ι₁ ι₂ : Sort*} {κ₁ : ι₁ → Sort*} {κ₂ : ι₂ → Sort*} {p : ∀ i₁, κ₁ i₁ → ∀ i₂, κ₂ i₂ → Prop} :
    (∀ i₁ j₁ i₂ j₂, p i₁ j₁ i₂ j₂) ↔ ∀ i₂ j₂ i₁ j₁, p i₁ j₁ i₂ j₂ 
Arguments: {ι₁ : Sort u_3} {ι₂ : Sort u_4} {κ₁ : ι₁ → Sort u_5} {κ₂ : ι₂ → Sort u_6} {p : (i₁ : ι₁) → κ₁ i₁ → (i₂ : ι₂) → κ₂ i₂ → Prop}
Goal: (∀ (i₁ : ι₁) (j₁ : κ₁ i₁) (i₂ : ι₂) (j₂ : κ₂ i₂), p i₁ j₁ i₂ j₂) ↔
  ∀ (i₂ : ι₂) (j₂ : κ₂ i₂) (i₁ : ι₁) (j₁ : κ₁ i₁), p i₁ j₁ i₂ j₂
-- imp_forall_iff
theorem imp_forall_iff {α : Type*} {p : Prop} {q : α → Prop} : (p → ∀ x, q x) ↔ ∀ x, p → q x 
Arguments: {α : Type u_3} {p : Prop} {q : α → Prop}
Goal: (p → ∀ (x : α), q x) ↔ ∀ (x : α), p → q x
-- exists_swap
theorem exists_swap {p : α → β → Prop} : (∃ x y, p x y) ↔ ∃ y x, p x y 
Arguments: {α : Sort u_1} {β : Sort u_2} {p : α → β → Prop}
Goal: (∃ x y, p x y) ↔ ∃ y x, p x y
-- not_forall_not
theorem not_forall_not : (¬∀ x, ¬p x) ↔ ∃ x, p x 
Arguments: {α : Sort u_1} {p : α → Prop}
Goal: (¬∀ (x : α), ¬p x) ↔ ∃ x, p x
-- forall_or_exists_not
lemma forall_or_exists_not (P : α → Prop) : (∀ a, P a) ∨ ∃ a, ¬ P a 
Arguments: {α : Sort u_1} (P : α → Prop)
Goal: (∀ (a : α), P a) ∨ ∃ a, ¬P a
-- exists_or_forall_not
lemma exists_or_forall_not (P : α → Prop) : (∃ a, P a) ∨ ∀ a, ¬ P a 
Arguments: {α : Sort u_1} (P : α → Prop)
Goal: (∃ a, P a) ∨ ∀ (a : α), ¬P a
-- forall_imp_iff_exists_imp
theorem forall_imp_iff_exists_imp {α : Sort*} {p : α → Prop} {b : Prop} [ha : Nonempty α] :
    (∀ x, p x) → b ↔ ∃ x, p x → b 
Arguments: {α : Sort u_3} {p : α → Prop} {b : Prop} [ha : Nonempty α]
Goal: (∀ (x : α), p x) → b ↔ ∃ x, p x → b
-- forall_true_iff
@[mfld_simps]
theorem forall_true_iff : (α → True) ↔ True 
Arguments: {α : Sort u_1}
Goal: α → True ↔ True
-- forall_true_iff'
theorem forall_true_iff' (h : ∀ a, p a ↔ True) : (∀ a, p a) ↔ True 
Arguments: {α : Sort u_1} {p : α → Prop} (h : ∀ (a : α), p a ↔ True)
Goal: (∀ (a : α), p a) ↔ True
-- forall₂_true_iff
theorem forall₂_true_iff {β : α → Sort*} : (∀ a, β a → True) ↔ True 
Arguments: {α : Sort u_1} {β : α → Sort u_3}
Goal: (∀ (a : α), β a → True) ↔ True
-- forall₃_true_iff
theorem forall₃_true_iff {β : α → Sort*} {γ : ∀ a, β a → Sort*} :
    (∀ (a) (b : β a), γ a b → True) ↔ True 
Arguments: {α : Sort u_1} {β : α → Sort u_3} {γ : (a : α) → β a → Sort u_4}
Goal: (∀ (a : α) (b : β a), γ a b → True) ↔ True
-- exists_unique_iff_exists
@[simp] theorem exists_unique_iff_exists [Subsingleton α] {p : α → Prop} :
    (∃! x, p x) ↔ ∃ x, p x 
Arguments: {α : Sort u_1} [Subsingleton α] {p : α → Prop}
Goal: (∃! x, p x) ↔ ∃ x, p x
-- exists_unique_const
theorem exists_unique_const {b : Prop} (α : Sort*) [i : Nonempty α] [Subsingleton α] :
    (∃! _ : α, b) ↔ b 
Arguments: {b : Prop} (α : Sort u_3) [i : Nonempty α] [Subsingleton α]
Goal: (∃! x, b) ↔ b
-- Decidable.and_forall_ne
theorem Decidable.and_forall_ne [DecidableEq α] (a : α) {p : α → Prop} :
    (p a ∧ ∀ b, b ≠ a → p b) ↔ ∀ b, p b 
Arguments: {α : Sort u_1} [DecidableEq α] (a : α) {p : α → Prop}
Goal: (p a ∧ ∀ (b : α), b ≠ a → p b) ↔ ∀ (b : α), p b
-- and_forall_ne
theorem and_forall_ne (a : α) : (p a ∧ ∀ b, b ≠ a → p b) ↔ ∀ b, p b 
Arguments: {α : Sort u_1} {p : α → Prop} (a : α)
Goal: (p a ∧ ∀ (b : α), b ≠ a → p b) ↔ ∀ (b : α), p b
-- Ne.ne_or_ne
theorem Ne.ne_or_ne {x y : α} (z : α) (h : x ≠ y) : x ≠ z ∨ y ≠ z 
Arguments: {α : Sort u_1} {x y : α} (z : α) (h : x ≠ y)
Goal: x ≠ z ∨ y ≠ z
-- exists_unique_eq
@[simp] theorem exists_unique_eq {a' : α} : ∃! a, a = a' 
Arguments: {α : Sort u_1} {a' : α}
Goal: ∃! a, a = a'
-- exists_unique_eq'
@[simp] theorem exists_unique_eq' {a' : α} : ∃! a, a' = a 
Arguments: {α : Sort u_1} {a' : α}
Goal: ∃! a, a' = a
-- exists_apply_eq_apply'
@[simp]
theorem exists_apply_eq_apply' (f : α → β) (a' : α) : ∃ a, f a' = f a 
Arguments: {α : Sort u_1} {β : Sort u_2} (f : α → β) (a' : α)
Goal: ∃ a, f a' = f a
-- exists_apply_eq_apply2
@[simp]
lemma exists_apply_eq_apply2 {α β γ} {f : α → β → γ} {a : α} {b : β} : ∃ x y, f x y = f a b 
Arguments: {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} {f : α → β → γ} {a : α} {b : β}
Goal: ∃ x y, f x y = f a b
-- exists_apply_eq_apply2'
@[simp]
lemma exists_apply_eq_apply2' {α β γ} {f : α → β → γ} {a : α} {b : β} : ∃ x y, f a b = f x y 
Arguments: {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} {f : α → β → γ} {a : α} {b : β}
Goal: ∃ x y, f a b = f x y
-- exists_apply_eq_apply3
@[simp]
lemma exists_apply_eq_apply3 {α β γ δ} {f : α → β → γ → δ} {a : α} {b : β} {c : γ} :
    ∃ x y z, f x y z = f a b c 
Arguments: {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} {δ : Sort u_6} {f : α → β → γ → δ} {a : α} {b : β} {c : γ}
Goal: ∃ x y z, f x y z = f a b c
-- exists_apply_eq_apply3'
@[simp]
lemma exists_apply_eq_apply3' {α β γ δ} {f : α → β → γ → δ} {a : α} {b : β} {c : γ} :
    ∃ x y z, f a b c = f x y z 
Arguments: {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} {δ : Sort u_6} {f : α → β → γ → δ} {a : α} {b : β} {c : γ}
Goal: ∃ x y z, f a b c = f x y z
-- exists_apply_eq
theorem exists_apply_eq (a : α) (b : β) : ∃ f : α → β, f a = b 
Arguments: {α : Sort u_1} {β : Sort u_2} (a : α) (b : β)
Goal: ∃ f, f a = b
-- exists_exists_and_eq_and
@[simp] theorem exists_exists_and_eq_and {f : α → β} {p : α → Prop} {q : β → Prop} :
    (∃ b, (∃ a, p a ∧ f a = b) ∧ q b) ↔ ∃ a, p a ∧ q (f a) 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} {p : α → Prop} {q : β → Prop}
Goal: (∃ b, (∃ a, p a ∧ f a = b) ∧ q b) ↔ ∃ a, p a ∧ q (f a)
-- exists_exists_eq_and
@[simp] theorem exists_exists_eq_and {f : α → β} {p : β → Prop} :
    (∃ b, (∃ a, f a = b) ∧ p b) ↔ ∃ a, p (f a) 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} {p : β → Prop}
Goal: (∃ b, (∃ a, f a = b) ∧ p b) ↔ ∃ a, p (f a)
-- exists_exists_and_exists_and_eq_and
@[simp] theorem exists_exists_and_exists_and_eq_and {α β γ : Type*}
    {f : α → β → γ} {p : α → Prop} {q : β → Prop} {r : γ → Prop} :
    (∃ c, (∃ a, p a ∧ ∃ b, q b ∧ f a b = c) ∧ r c) ↔ ∃ a, p a ∧ ∃ b, q b ∧ r (f a b) 
Arguments: {α : Type u_3} {β : Type u_4} {γ : Type u_5} {f : α → β → γ} {p : α → Prop} {q : β → Prop} {r : γ → Prop}
Goal: (∃ c, (∃ a, p a ∧ ∃ b, q b ∧ f a b = c) ∧ r c) ↔ ∃ a, p a ∧ ∃ b, q b ∧ r (f a b)
-- exists_exists_exists_and_eq
@[simp] theorem exists_exists_exists_and_eq {α β γ : Type*}
    {f : α → β → γ} {p : γ → Prop} :
    (∃ c, (∃ a, ∃ b, f a b = c) ∧ p c) ↔ ∃ a, ∃ b, p (f a b) 
Arguments: {α : Type u_3} {β : Type u_4} {γ : Type u_5} {f : α → β → γ} {p : γ → Prop}
Goal: (∃ c, (∃ a b, f a b = c) ∧ p c) ↔ ∃ a b, p (f a b)
-- exists_or_eq_left
@[simp] theorem exists_or_eq_left (y : α) (p : α → Prop) : ∃ x : α, x = y ∨ p x 
Arguments: {α : Sort u_1} (y : α) (p : α → Prop)
Goal: ∃ x, x = y ∨ p x
-- exists_or_eq_right
@[simp] theorem exists_or_eq_right (y : α) (p : α → Prop) : ∃ x : α, p x ∨ x = y 
Arguments: {α : Sort u_1} (y : α) (p : α → Prop)
Goal: ∃ x, p x ∨ x = y
-- exists_or_eq_left'
@[simp] theorem exists_or_eq_left' (y : α) (p : α → Prop) : ∃ x : α, y = x ∨ p x 
Arguments: {α : Sort u_1} (y : α) (p : α → Prop)
Goal: ∃ x, y = x ∨ p x
-- exists_or_eq_right'
@[simp] theorem exists_or_eq_right' (y : α) (p : α → Prop) : ∃ x : α, p x ∨ y = x 
Arguments: {α : Sort u_1} (y : α) (p : α → Prop)
Goal: ∃ x, p x ∨ y = x
-- forall_apply_eq_imp_iff'
theorem forall_apply_eq_imp_iff' {f : α → β} {p : β → Prop} :
    (∀ a b, f a = b → p b) ↔ ∀ a, p (f a) 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} {p : β → Prop}
Goal: (∀ (a : α) (b : β), f a = b → p b) ↔ ∀ (a : α), p (f a)
-- forall_eq_apply_imp_iff'
theorem forall_eq_apply_imp_iff' {f : α → β} {p : β → Prop} :
    (∀ a b, b = f a → p b) ↔ ∀ a, p (f a) 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} {p : β → Prop}
Goal: (∀ (a : α) (b : β), b = f a → p b) ↔ ∀ (a : α), p (f a)
-- exists_eq_right'
@[simp] theorem exists_eq_right' {a' : α} : (∃ a, p a ∧ a' = a) ↔ p a' 
Arguments: {α : Sort u_1} {p : α → Prop} {a' : α}
Goal: (∃ a, p a ∧ a' = a) ↔ p a'
-- exists₂_comm
theorem exists₂_comm
    {ι₁ ι₂ : Sort*} {κ₁ : ι₁ → Sort*} {κ₂ : ι₂ → Sort*} {p : ∀ i₁, κ₁ i₁ → ∀ i₂, κ₂ i₂ → Prop} :
    (∃ i₁ j₁ i₂ j₂, p i₁ j₁ i₂ j₂) ↔ ∃ i₂ j₂ i₁ j₁, p i₁ j₁ i₂ j₂ 
Arguments: {ι₁ : Sort u_3} {ι₂ : Sort u_4} {κ₁ : ι₁ → Sort u_5} {κ₂ : ι₂ → Sort u_6} {p : (i₁ : ι₁) → κ₁ i₁ → (i₂ : ι₂) → κ₂ i₂ → Prop}
Goal: (∃ i₁ j₁ i₂ j₂, p i₁ j₁ i₂ j₂) ↔ ∃ i₂ j₂ i₁ j₁, p i₁ j₁ i₂ j₂
-- And.exists
theorem And.exists {p q : Prop} {f : p ∧ q → Prop} : (∃ h, f h) ↔ ∃ hp hq, f ⟨hp, hq⟩ 
Arguments: {p q : Prop} {f : p ∧ q → Prop}
Goal: (∃ h, f h) ↔ ∃ hp hq, f ⋯
-- forall_or_of_or_forall
theorem forall_or_of_or_forall {α : Sort*} {p : α → Prop} {b : Prop} (h : b ∨ ∀ x, p x) (x : α) :
    b ∨ p x 
Arguments: {α : Sort u_3} {p : α → Prop} {b : Prop} (h : b ∨ ∀ (x : α), p x) (x : α)
Goal: b ∨ p x
-- Decidable.forall_or_left
protected theorem Decidable.forall_or_left {q : Prop} {p : α → Prop} [Decidable q] :
    (∀ x, q ∨ p x) ↔ q ∨ ∀ x, p x 
Arguments: {α : Sort u_1} {q : Prop} {p : α → Prop} [Decidable q]
Goal: (∀ (x : α), q ∨ p x) ↔ q ∨ ∀ (x : α), p x
-- forall_or_left
theorem forall_or_left {q} {p : α → Prop} : (∀ x, q ∨ p x) ↔ q ∨ ∀ x, p x 
Arguments: {α : Sort u_1} {q : Prop} {p : α → Prop}
Goal: (∀ (x : α), q ∨ p x) ↔ q ∨ ∀ (x : α), p x
-- Decidable.forall_or_right
protected theorem Decidable.forall_or_right {q} {p : α → Prop} [Decidable q] :
    (∀ x, p x ∨ q) ↔ (∀ x, p x) ∨ q 
Arguments: {α : Sort u_1} {q : Prop} {p : α → Prop} [Decidable q]
Goal: (∀ (x : α), p x ∨ q) ↔ (∀ (x : α), p x) ∨ q
-- forall_or_right
theorem forall_or_right {q} {p : α → Prop} : (∀ x, p x ∨ q) ↔ (∀ x, p x) ∨ q 
Arguments: {α : Sort u_1} {q : Prop} {p : α → Prop}
Goal: (∀ (x : α), p x ∨ q) ↔ (∀ (x : α), p x) ∨ q
-- exists_unique_prop
theorem exists_unique_prop {p q : Prop} : (∃! _ : p, q) ↔ p ∧ q 
Arguments: {p q : Prop}
Goal: (∃! x, q) ↔ p ∧ q
-- exists_unique_false
@[simp] theorem exists_unique_false : ¬∃! _ : α, False 
Arguments: {α : Sort u_1}
Goal: ¬∃! x, False
-- Exists.fst
theorem Exists.fst {b : Prop} {p : b → Prop} : Exists p → b
  
Arguments: {b : Prop} {p : b → Prop}
Goal: Exists p → b
-- Exists.snd
theorem Exists.snd {b : Prop} {p : b → Prop} : ∀ h : Exists p, p h.fst
  
Arguments: {b : Prop} {p : b → Prop} (h : Exists p)
Goal: p ⋯
-- Prop.exists_iff
theorem Prop.exists_iff {p : Prop → Prop} : (∃ h, p h) ↔ p False ∨ p True 
Arguments: {p : Prop → Prop}
Goal: (∃ h, p h) ↔ p False ∨ p True
-- Prop.forall_iff
theorem Prop.forall_iff {p : Prop → Prop} : (∀ h, p h) ↔ p False ∧ p True 
Arguments: {p : Prop → Prop}
Goal: (∀ (h : Prop), p h) ↔ p False ∧ p True
-- exists_prop_of_true
theorem exists_prop_of_true {p : Prop} {q : p → Prop} (h : p) : (∃ h' : p, q h') ↔ q h 
Arguments: {p : Prop} {q : p → Prop} (h : p)
Goal: (∃ h', q h') ↔ q h
-- exists_iff_of_forall
theorem exists_iff_of_forall {p : Prop} {q : p → Prop} (h : ∀ h, q h) : (∃ h, q h) ↔ p 
Arguments: {p : Prop} {q : p → Prop} (h : ∀ (h : p), q h)
Goal: (∃ h, q h) ↔ p
-- exists_unique_prop_of_true
theorem exists_unique_prop_of_true {p : Prop} {q : p → Prop} (h : p) : (∃! h' : p, q h') ↔ q h 
Arguments: {p : Prop} {q : p → Prop} (h : p)
Goal: (∃! h', q h') ↔ q h
-- exists_prop_of_false
theorem exists_prop_of_false {p : Prop} {q : p → Prop} : ¬p → ¬∃ h' : p, q h' 
Arguments: {p : Prop} {q : p → Prop}
Goal: ¬p → ¬∃ h', q h'
-- exists_prop_congr
@[congr]
theorem exists_prop_congr {p p' : Prop} {q q' : p → Prop} (hq : ∀ h, q h ↔ q' h) (hp : p ↔ p') :
    Exists q ↔ ∃ h : p', q' (hp.2 h) 
Arguments: {p p' : Prop} {q q' : p → Prop} (hq : ∀ (h : p), q h ↔ q' h) (hp : p ↔ p')
Goal: Exists q ↔ ∃ h, q' ⋯
-- exists_true_left
@[simp] theorem exists_true_left (p : True → Prop) : (∃ x, p x) ↔ p True.intro 
Arguments: (p : True → Prop)
Goal: (∃ x, p x) ↔ p True.intro
-- forall_prop_congr
theorem forall_prop_congr {p p' : Prop} {q q' : p → Prop} (hq : ∀ h, q h ↔ q' h) (hp : p ↔ p') :
    (∀ h, q h) ↔ ∀ h : p', q' (hp.2 h) 
Arguments: {p p' : Prop} {q q' : p → Prop} (hq : ∀ (h : p), q h ↔ q' h) (hp : p ↔ p')
Goal: (∀ (h : p), q h) ↔ ∀ (h : p'), q' ⋯
-- forall_prop_congr'
theorem forall_prop_congr' {p p' : Prop} {q q' : p → Prop} (hq : ∀ h, q h ↔ q' h) (hp : p ↔ p') :
    (∀ h, q h) = ∀ h : p', q' (hp.2 h) 
Arguments: {p p' : Prop} {q q' : p → Prop} (hq : ∀ (h : p), q h ↔ q' h) (hp : p ↔ p')
Goal: (∀ (h : p), q h) = ∀ (h : p'), q' ⋯
-- imp_congr_eq
lemma imp_congr_eq {a b c d : Prop} (h₁ : a = c) (h₂ : b = d) : (a → b) = (c → d) 
Arguments: {a b c d : Prop} (h₁ : a = c) (h₂ : b = d)
Goal: (a → b) = (c → d)
-- imp_congr_ctx_eq
lemma imp_congr_ctx_eq {a b c d : Prop} (h₁ : a = c) (h₂ : c → b = d) : (a → b) = (c → d) 
Arguments: {a b c d : Prop} (h₁ : a = c) (h₂ : c → b = d)
Goal: (a → b) = (c → d)
-- eq_true_intro
lemma eq_true_intro {a : Prop} (h : a) : a = True 
Arguments: {a : Prop} (h : a)
Goal: a = True
-- eq_false_intro
lemma eq_false_intro {a : Prop} (h : ¬a) : a = False 
Arguments: {a : Prop} (h : ¬a)
Goal: a = False
-- iff_eq_eq
lemma iff_eq_eq {a b : Prop} : (a ↔ b) = (a = b) 
Arguments: {a b : Prop}
Goal: (a ↔ b) = (a = b)
-- forall_true_left
@[simp] theorem forall_true_left (p : True → Prop) : (∀ x, p x) ↔ p True.intro 
Arguments: (p : True → Prop)
Goal: (∀ (x : True), p x) ↔ p True.intro
-- ExistsUnique.elim₂
theorem ExistsUnique.elim₂ {α : Sort*} {p : α → Sort*} [∀ x, Subsingleton (p x)]
    {q : ∀ (x) (_ : p x), Prop} {b : Prop} (h₂ : ∃! x, ∃! h : p x, q x h)
    (h₁ : ∀ (x) (h : p x), q x h → (∀ (y) (hy : p y), q y hy → y = x) → b) : b 
Arguments: {α : Sort u_3} {p : α → Sort u_4} [∀ (x : α), Subsingleton (p x)] {q : (x : α) → p x → Prop} {b : Prop} (h₂ : ∃! x, ∃! h, q x h) (h₁ : ∀ (x : α) (h : p x), q x h → (∀ (y : α) (hy : p y), q y hy → y = x) → b)
Goal: b
-- ExistsUnique.intro₂
theorem ExistsUnique.intro₂ {α : Sort*} {p : α → Sort*} [∀ x, Subsingleton (p x)]
    {q : ∀ (x : α) (_ : p x), Prop} (w : α) (hp : p w) (hq : q w hp)
    (H : ∀ (y) (hy : p y), q y hy → y = w) : ∃! x, ∃! hx : p x, q x hx 
Arguments: {α : Sort u_3} {p : α → Sort u_4} [∀ (x : α), Subsingleton (p x)] {q : (x : α) → p x → Prop} (w : α) (hp : p w) (hq : q w hp) (H : ∀ (y : α) (hy : p y), q y hy → y = w)
Goal: ∃! x, ∃! hx, q x hx
-- ExistsUnique.exists₂
theorem ExistsUnique.exists₂ {α : Sort*} {p : α → Sort*} {q : ∀ (x : α) (_ : p x), Prop}
    (h : ∃! x, ∃! hx : p x, q x hx) : ∃ (x : _) (hx : p x), q x hx 
Arguments: {α : Sort u_3} {p : α → Sort u_4} {q : (x : α) → p x → Prop} (h : ∃! x, ∃! hx, q x hx)
Goal: ∃ x hx, q x hx
-- ExistsUnique.unique₂
theorem ExistsUnique.unique₂ {α : Sort*} {p : α → Sort*} [∀ x, Subsingleton (p x)]
    {q : ∀ (x : α) (_ : p x), Prop} (h : ∃! x, ∃! hx : p x, q x hx) {y₁ y₂ : α}
    (hpy₁ : p y₁) (hqy₁ : q y₁ hpy₁) (hpy₂ : p y₂) (hqy₂ : q y₂ hpy₂) : y₁ = y₂ 
Arguments: {α : Sort u_3} {p : α → Sort u_4} [∀ (x : α), Subsingleton (p x)] {q : (x : α) → p x → Prop} (h : ∃! x, ∃! hx, q x hx) {y₁ y₂ : α} (hpy₁ : p y₁) (hqy₁ : q y₁ hpy₁) (hpy₂ : p y₂) (hqy₂ : q y₂ hpy₂)
Goal: y₁ = y₂
-- Classical.some_spec₂
theorem some_spec₂ {α : Sort*} {p : α → Prop} {h : ∃ a, p a} (q : α → Prop)
    (hpq : ∀ a, p a → q a) : q (choose h) 
Arguments: {α : Sort u_2} {p : α → Prop} {h : ∃ a, p a} (q : α → Prop) (hpq : ∀ (a : α), p a → q a)
Goal: q (Classical.choose h)
-- Classical.choose_eq
@[simp] lemma choose_eq (a : α) : @Exists.choose _ (· = a) ⟨a, rfl⟩ = a 
Arguments: {α : Sort u_1} (a : α)
Goal: ⋯.choose = a
-- Classical.choose_eq'
@[simp]
lemma choose_eq' (a : α) : @Exists.choose _ (a = ·) ⟨a, rfl⟩ = a 
Arguments: {α : Sort u_1} (a : α)
Goal: ⋯.choose = a
-- bex_def
theorem bex_def : (∃ (x : _) (_ : p x), q x) ↔ ∃ x, p x ∧ q x 
Arguments: {α : Sort u_1} {p q : α → Prop}
Goal: (∃ x x_1, q x) ↔ ∃ x, p x ∧ q x
-- BEx.elim
theorem BEx.elim {b : Prop} : (∃ x h, P x h) → (∀ a h, P a h → b) → b
  
Arguments: {α : Sort u_1} {p : α → Prop} {P : (x : α) → p x → Prop} {b : Prop}
Goal: (∃ x h, P x h) → (∀ (a : α) (h : p a), P a h → b) → b
-- BEx.intro
theorem BEx.intro (a : α) (h₁ : p a) (h₂ : P a h₁) : ∃ (x : _) (h : p x), P x h 
Arguments: {α : Sort u_1} {p : α → Prop} {P : (x : α) → p x → Prop} (a : α) (h₁ : p a) (h₂ : P a h₁)
Goal: ∃ x h, P x h
-- bex_eq_left
@[deprecated exists_eq_left (since := "2024-04-06")]
theorem bex_eq_left {a : α} : (∃ (x : _) (_ : x = a), p x) ↔ p a 
Arguments: {α : Sort u_1} {p : α → Prop} {a : α}
Goal: (∃ x x_1, p x) ↔ p a
-- BAll.imp_right
theorem BAll.imp_right (H : ∀ x h, P x h → Q x h) (h₁ : ∀ x h, P x h) (x h) : Q x h 
Arguments: {α : Sort u_1} {p : α → Prop} {P Q : (x : α) → p x → Prop} (H : ∀ (x : α) (h : p x), P x h → Q x h) (h₁ : ∀ (x : α) (h : p x), P x h) (x : α) (h : p x)
Goal: Q x h
-- BEx.imp_right
theorem BEx.imp_right (H : ∀ x h, P x h → Q x h) : (∃ x h, P x h) → ∃ x h, Q x h
  
Arguments: {α : Sort u_1} {p : α → Prop} {P Q : (x : α) → p x → Prop} (H : ∀ (x : α) (h : p x), P x h → Q x h)
Goal: (∃ x h, P x h) → ∃ x h, Q x h
-- BAll.imp_left
theorem BAll.imp_left (H : ∀ x, p x → q x) (h₁ : ∀ x, q x → r x) (x) (h : p x) : r x 
Arguments: {α : Sort u_1} {r p q : α → Prop} (H : ∀ (x : α), p x → q x) (h₁ : ∀ (x : α), q x → r x) (x : α) (h : p x)
Goal: r x
-- BEx.imp_left
theorem BEx.imp_left (H : ∀ x, p x → q x) : (∃ (x : _) (_ : p x), r x) → ∃ (x : _) (_ : q x), r x
  
Arguments: {α : Sort u_1} {r p q : α → Prop} (H : ∀ (x : α), p x → q x)
Goal: (∃ x x_1, r x) → ∃ x x_1, r x
-- ball_of_forall
@[deprecated id (since := "2024-03-23")]
theorem ball_of_forall (h : ∀ x, p x) (x) : p x 
Arguments: {α : Sort u_1} {p : α → Prop} (h : ∀ (x : α), p x) (x : α)
Goal: p x
-- forall_of_ball
@[deprecated forall_imp (since := "2024-03-23")]
theorem forall_of_ball (H : ∀ x, p x) (h : ∀ x, p x → q x) (x) : q x 
Arguments: {α : Sort u_1} {p q : α → Prop} (H : ∀ (x : α), p x) (h : ∀ (x : α), p x → q x) (x : α)
Goal: q x
-- exists_mem_of_exists
theorem exists_mem_of_exists (H : ∀ x, p x) : (∃ x, q x) → ∃ (x : _) (_ : p x), q x
  
Arguments: {α : Sort u_1} {p q : α → Prop} (H : ∀ (x : α), p x)
Goal: (∃ x, q x) → ∃ x x_1, q x
-- exists_of_exists_mem
theorem exists_of_exists_mem : (∃ (x : _) (_ : p x), q x) → ∃ x, q x
  
Arguments: {α : Sort u_1} {p q : α → Prop}
Goal: (∃ x x_1, q x) → ∃ x, q x
-- exists₂_imp
theorem exists₂_imp : (∃ x h, P x h) → b ↔ ∀ x h, P x h → b 
Arguments: {α : Sort u_1} {p : α → Prop} {P : (x : α) → p x → Prop} {b : Prop}
Goal: (∃ x h, P x h) → b ↔ ∀ (x : α) (h : p x), P x h → b
-- not_exists_mem
theorem not_exists_mem : (¬∃ x h, P x h) ↔ ∀ x h, ¬P x h 
Arguments: {α : Sort u_1} {p : α → Prop} {P : (x : α) → p x → Prop}
Goal: (¬∃ x h, P x h) ↔ ∀ (x : α) (h : p x), ¬P x h
-- not_forall₂_of_exists₂_not
theorem not_forall₂_of_exists₂_not : (∃ x h, ¬P x h) → ¬∀ x h, P x h
  
Arguments: {α : Sort u_1} {p : α → Prop} {P : (x : α) → p x → Prop}
Goal: (∃ x h, ¬P x h) → ¬∀ (x : α) (h : p x), P x h
-- Decidable.not_forall₂
protected theorem Decidable.not_forall₂ [Decidable (∃ x h, ¬P x h)] [∀ x h, Decidable (P x h)] :
    (¬∀ x h, P x h) ↔ ∃ x h, ¬P x h 
Arguments: {α : Sort u_1} {p : α → Prop} {P : (x : α) → p x → Prop} [Decidable (∃ x h, ¬P x h)] [(x : α) → (h : p x) → Decidable (P x h)]
Goal: (¬∀ (x : α) (h : p x), P x h) ↔ ∃ x h, ¬P x h
-- not_forall₂
theorem not_forall₂ : (¬∀ x h, P x h) ↔ ∃ x h, ¬P x h 
Arguments: {α : Sort u_1} {p : α → Prop} {P : (x : α) → p x → Prop}
Goal: (¬∀ (x : α) (h : p x), P x h) ↔ ∃ x h, ¬P x h
-- forall₂_and
theorem forall₂_and : (∀ x h, P x h ∧ Q x h) ↔ (∀ x h, P x h) ∧ ∀ x h, Q x h 
Arguments: {α : Sort u_1} {p : α → Prop} {P Q : (x : α) → p x → Prop}
Goal: (∀ (x : α) (h : p x), P x h ∧ Q x h) ↔ (∀ (x : α) (h : p x), P x h) ∧ ∀ (x : α) (h : p x), Q x h
-- forall_and_left
theorem forall_and_left [Nonempty α] (q : Prop) (p : α → Prop) :
    (∀ x, q ∧ p x) ↔ (q ∧ ∀ x, p x) 
Arguments: {α : Sort u_1} [Nonempty α] (q : Prop) (p : α → Prop)
Goal: (∀ (x : α), q ∧ p x) ↔ q ∧ ∀ (x : α), p x
-- forall_and_right
theorem forall_and_right [Nonempty α] (p : α → Prop) (q : Prop) :
    (∀ x, p x ∧ q) ↔ (∀ x, p x) ∧ q 
Arguments: {α : Sort u_1} [Nonempty α] (p : α → Prop) (q : Prop)
Goal: (∀ (x : α), p x ∧ q) ↔ (∀ (x : α), p x) ∧ q
-- exists_mem_or
theorem exists_mem_or : (∃ x h, P x h ∨ Q x h) ↔ (∃ x h, P x h) ∨ ∃ x h, Q x h 
Arguments: {α : Sort u_1} {p : α → Prop} {P Q : (x : α) → p x → Prop}
Goal: (∃ x h, P x h ∨ Q x h) ↔ (∃ x h, P x h) ∨ ∃ x h, Q x h
-- forall₂_or_left
theorem forall₂_or_left : (∀ x, p x ∨ q x → r x) ↔ (∀ x, p x → r x) ∧ ∀ x, q x → r x 
Arguments: {α : Sort u_1} {r p q : α → Prop}
Goal: (∀ (x : α), p x ∨ q x → r x) ↔ (∀ (x : α), p x → r x) ∧ ∀ (x : α), q x → r x
-- exists_mem_or_left
theorem exists_mem_or_left :
    (∃ (x : _) (_ : p x ∨ q x), r x) ↔ (∃ (x : _) (_ : p x), r x) ∨ ∃ (x : _) (_ : q x), r x 
Arguments: {α : Sort u_1} {r p q : α → Prop}
Goal: (∃ x x_1, r x) ↔ (∃ x x_1, r x) ∨ ∃ x x_1, r x
-- dite_eq_iff
theorem dite_eq_iff : dite P A B = c ↔ (∃ h, A h = c) ∨ ∃ h, B h = c 
Arguments: {α : Sort u_1} {P : Prop} [Decidable P] {c : α} {A : P → α} {B : ¬P → α}
Goal: dite P A B = c ↔ (∃ h, A h = c) ∨ ∃ h, B h = c
-- ite_eq_iff
theorem ite_eq_iff : ite P a b = c ↔ P ∧ a = c ∨ ¬P ∧ b = c 
Arguments: {α : Sort u_1} {P : Prop} [Decidable P] {a b c : α}
Goal: (if P then a else b) = c ↔ P ∧ a = c ∨ ¬P ∧ b = c
-- eq_ite_iff
theorem eq_ite_iff : a = ite P b c ↔ P ∧ a = b ∨ ¬P ∧ a = c 
Arguments: {α : Sort u_1} {P : Prop} [Decidable P] {a b c : α}
Goal: (a = if P then b else c) ↔ P ∧ a = b ∨ ¬P ∧ a = c
-- dite_eq_iff'
theorem dite_eq_iff' : dite P A B = c ↔ (∀ h, A h = c) ∧ ∀ h, B h = c 
Arguments: {α : Sort u_1} {P : Prop} [Decidable P] {c : α} {A : P → α} {B : ¬P → α}
Goal: dite P A B = c ↔ (∀ (h : P), A h = c) ∧ ∀ (h : ¬P), B h = c
-- ite_eq_iff'
theorem ite_eq_iff' : ite P a b = c ↔ (P → a = c) ∧ (¬P → b = c) 
Arguments: {α : Sort u_1} {P : Prop} [Decidable P] {a b c : α}
Goal: (if P then a else b) = c ↔ (P → a = c) ∧ (¬P → b = c)
-- dite_ne_left_iff
theorem dite_ne_left_iff : dite P (fun _ ↦ a) B ≠ a ↔ ∃ h, a ≠ B h 
Arguments: {α : Sort u_1} {P : Prop} [Decidable P] {a : α} {B : ¬P → α}
Goal: dite P (fun x => a) B ≠ a ↔ ∃ h, a ≠ B h
-- dite_ne_right_iff
theorem dite_ne_right_iff : (dite P A fun _ ↦ b) ≠ b ↔ ∃ h, A h ≠ b 
Arguments: {α : Sort u_1} {P : Prop} [Decidable P] {b : α} {A : P → α}
Goal: (dite P A fun x => b) ≠ b ↔ ∃ h, A h ≠ b
-- ite_ne_left_iff
theorem ite_ne_left_iff : ite P a b ≠ a ↔ ¬P ∧ a ≠ b 
Arguments: {α : Sort u_1} {P : Prop} [Decidable P] {a b : α}
Goal: (if P then a else b) ≠ a ↔ ¬P ∧ a ≠ b
-- ite_ne_right_iff
theorem ite_ne_right_iff : ite P a b ≠ b ↔ P ∧ a ≠ b 
Arguments: {α : Sort u_1} {P : Prop} [Decidable P] {a b : α}
Goal: (if P then a else b) ≠ b ↔ P ∧ a ≠ b
-- Ne.dite_eq_left_iff
protected theorem Ne.dite_eq_left_iff (h : ∀ h, a ≠ B h) : dite P (fun _ ↦ a) B = a ↔ P 
Arguments: {α : Sort u_1} {P : Prop} [Decidable P] {a : α} {B : ¬P → α} (h : ∀ (h : ¬P), a ≠ B h)
Goal: dite P (fun x => a) B = a ↔ P
-- Ne.dite_eq_right_iff
protected theorem Ne.dite_eq_right_iff (h : ∀ h, A h ≠ b) : (dite P A fun _ ↦ b) = b ↔ ¬P 
Arguments: {α : Sort u_1} {P : Prop} [Decidable P] {b : α} {A : P → α} (h : ∀ (h : P), A h ≠ b)
Goal: (dite P A fun x => b) = b ↔ ¬P
-- Ne.ite_eq_left_iff
protected theorem Ne.ite_eq_left_iff (h : a ≠ b) : ite P a b = a ↔ P 
Arguments: {α : Sort u_1} {P : Prop} [Decidable P] {a b : α} (h : a ≠ b)
Goal: (if P then a else b) = a ↔ P