ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- forall₃_congr
theorem forall₃_congr {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₃_congr
theorem exists₃_congr {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₄_congr
theorem forall₄_congr {p q : ∀ a b c, δ a b c → Prop} (h : ∀ a b c d, p a b c d ↔ q a b c d) :
    (∀ a b c d, p a b c d) ↔ ∀ a b c d, q a b c d 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {γ : (a : α) → β a → Sort u_3} {δ : (a : α) → (b : β a) → γ a b → Sort u_4} {p q : (a : α) → (b : β a) → (c : γ a b) → δ a b c → Prop} (h : ∀ (a : α) (b : β a) (c : γ a b) (d : δ a b c), p a b c d ↔ q a b c d)
Goal: (∀ (a : α) (b : β a) (c : γ a b) (d : δ a b c), p a b c d) ↔ ∀ (a : α) (b : β a) (c : γ a b) (d : δ a b c), q a b c d
-- exists₄_congr
theorem exists₄_congr {p q : ∀ a b c, δ a b c → Prop} (h : ∀ a b c d, p a b c d ↔ q a b c d) :
    (∃ a b c d, p a b c d) ↔ ∃ a b c d, q a b c d 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {γ : (a : α) → β a → Sort u_3} {δ : (a : α) → (b : β a) → γ a b → Sort u_4} {p q : (a : α) → (b : β a) → (c : γ a b) → δ a b c → Prop} (h : ∀ (a : α) (b : β a) (c : γ a b) (d : δ a b c), p a b c d ↔ q a b c d)
Goal: (∃ a b c d, p a b c d) ↔ ∃ a b c d, q a b c d
-- forall₅_congr
theorem forall₅_congr {p q : ∀ a b c d, ε a b c d → Prop}
    (h : ∀ a b c d e, p a b c d e ↔ q a b c d e) :
    (∀ a b c d e, p a b c d e) ↔ ∀ a b c d e, q a b c d e 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {γ : (a : α) → β a → Sort u_3} {δ : (a : α) → (b : β a) → γ a b → Sort u_4} {ε : (a : α) → (b : β a) → (c : γ a b) → δ a b c → Sort u_5} {p q : (a : α) → (b : β a) → (c : γ a b) → (d : δ a b c) → ε a b c d → Prop} (h : ∀ (a : α) (b : β a) (c : γ a b) (d : δ a b c) (e : ε a b c d), p a b c d e ↔ q a b c d e)
Goal: (∀ (a : α) (b : β a) (c : γ a b) (d : δ a b c) (e : ε a b c d), p a b c d e) ↔
  ∀ (a : α) (b : β a) (c : γ a b) (d : δ a b c) (e : ε a b c d), q a b c d e
-- exists₅_congr
theorem exists₅_congr {p q : ∀ a b c d, ε a b c d → Prop}
    (h : ∀ a b c d e, p a b c d e ↔ q a b c d e) :
    (∃ a b c d e, p a b c d e) ↔ ∃ a b c d e, q a b c d e 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {γ : (a : α) → β a → Sort u_3} {δ : (a : α) → (b : β a) → γ a b → Sort u_4} {ε : (a : α) → (b : β a) → (c : γ a b) → δ a b c → Sort u_5} {p q : (a : α) → (b : β a) → (c : γ a b) → (d : δ a b c) → ε a b c d → Prop} (h : ∀ (a : α) (b : β a) (c : γ a b) (d : δ a b c) (e : ε a b c d), p a b c d e ↔ q a b c d e)
Goal: (∃ a b c d e, p a b c d e) ↔ ∃ a b c d e, q a b c d e
-- not_exists
@[simp] theorem not_exists : (¬∃ x, p x) ↔ ∀ x, ¬p x 
Arguments: {α : Sort u_1} {p : α → Prop}
Goal: (¬∃ x, p x) ↔ ∀ (x : α), ¬p x
-- forall_and
theorem forall_and : (∀ x, p x ∧ q x) ↔ (∀ x, p x) ∧ (∀ x, q x) 
Arguments: {α : Sort u_1} {p q : α → Prop}
Goal: (∀ (x : α), p x ∧ q x) ↔ (∀ (x : α), p x) ∧ ∀ (x : α), q x
-- exists_or
theorem exists_or : (∃ x, p x ∨ q x) ↔ (∃ x, p x) ∨ ∃ x, q x 
Arguments: {α : Sort u_1} {p q : α → Prop}
Goal: (∃ x, p x ∨ q x) ↔ (∃ x, p x) ∨ ∃ x, q x
-- exists_false
@[simp] theorem exists_false : ¬(∃ _a : α, False) 
Arguments: {α : Sort u_1}
Goal: ¬∃ _a, False
-- forall_const
@[simp] theorem forall_const (α : Sort _) [i : Nonempty α] : (α → b) ↔ b 
Arguments: {b : Prop} (α : Sort u_1) [i : Nonempty α]
Goal: α → b ↔ b
-- Exists.nonempty
theorem Exists.nonempty : (∃ x, p x) → Nonempty α 
Arguments: {α : Sort u_1} {p : α → Prop}
Goal: (∃ x, p x) → Nonempty α
-- not_forall_of_exists_not
theorem not_forall_of_exists_not {p : α → Prop} : (∃ x, ¬p x) → ¬∀ x, p x
  
Arguments: {α : Sort u_1} {p : α → Prop}
Goal: (∃ x, ¬p x) → ¬∀ (x : α), p x
-- forall_eq
@[simp] theorem forall_eq {p : α → Prop} {a' : α} : (∀ a, a = a' → p a) ↔ p a' 
Arguments: {α : Sort u_1} {p : α → Prop} {a' : α}
Goal: (∀ (a : α), a = a' → p a) ↔ p a'
-- forall_eq'
@[simp] theorem forall_eq' {a' : α} : (∀ a, a' = a → p a) ↔ p a' 
Arguments: {α : Sort u_1} {p : α → Prop} {a' : α}
Goal: (∀ (a : α), a' = a → p a) ↔ p a'
-- exists_eq
@[simp] theorem exists_eq : ∃ a, a = a' 
Goal: ∀ {α : Sort u_1} {a' : α}, ∃ a, a = a'
-- exists_eq'
@[simp] theorem exists_eq' : ∃ a, a' = a 
Goal: ∀ {α : Sort u_1} {a' : α}, ∃ a, a' = a
-- exists_eq_left
@[simp] theorem exists_eq_left : (∃ a, a = a' ∧ p a) ↔ p a' 
Arguments: {α : Sort u_1} {p : α → Prop} {a' : α}
Goal: (∃ a, a = a' ∧ p a) ↔ p a'
-- exists_eq_right
@[simp] theorem exists_eq_right : (∃ a, p a ∧ a = a') ↔ p a' 
Arguments: {α : Sort u_1} {p : α → Prop} {a' : α}
Goal: (∃ a, p a ∧ a = a') ↔ p a'
-- exists_and_left
@[simp] theorem exists_and_left : (∃ x, b ∧ p x) ↔ b ∧ (∃ x, p x) 
Arguments: {α : Sort u_1} {p : α → Prop} {b : Prop}
Goal: (∃ x, b ∧ p x) ↔ b ∧ ∃ x, p x
-- exists_and_right
@[simp] theorem exists_and_right : (∃ x, p x ∧ b) ↔ (∃ x, p x) ∧ b 
Arguments: {α : Sort u_1} {p : α → Prop} {b : Prop}
Goal: (∃ x, p x ∧ b) ↔ (∃ x, p x) ∧ b
-- exists_eq_left'
@[simp] theorem exists_eq_left' : (∃ a, a' = a ∧ p a) ↔ p a' 
Arguments: {α : Sort u_1} {p : α → Prop} {a' : α}
Goal: (∃ a, a' = a ∧ p a) ↔ p a'
-- forall_eq_or_imp
@[simp] theorem forall_eq_or_imp : (∀ a, a = a' ∨ q a → p a) ↔ p a' ∧ ∀ a, q a → p a 
Arguments: {α : Sort u_1} {p q : α → Prop} {a' : α}
Goal: (∀ (a : α), a = a' ∨ q a → p a) ↔ p a' ∧ ∀ (a : α), q a → p a
-- exists_eq_or_imp
@[simp] theorem exists_eq_or_imp : (∃ a, (a = a' ∨ q a) ∧ p a) ↔ p a' ∨ ∃ a, q a ∧ p a 
Arguments: {α : Sort u_1} {p q : α → Prop} {a' : α}
Goal: (∃ a, (a = a' ∨ q a) ∧ p a) ↔ p a' ∨ ∃ a, q a ∧ p a
-- exists_eq_right_right
@[simp] theorem exists_eq_right_right : (∃ (a : α), p a ∧ q a ∧ a = a') ↔ p a' ∧ q a' 
Arguments: {α : Sort u_1} {p q : α → Prop} {a' : α}
Goal: (∃ a, p a ∧ q a ∧ a = a') ↔ p a' ∧ q a'
-- exists_eq_right_right'
@[simp] theorem exists_eq_right_right' : (∃ (a : α), p a ∧ q a ∧ a' = a) ↔ p a' ∧ q a' 
Arguments: {α : Sort u_1} {p q : α → Prop} {a' : α}
Goal: (∃ a, p a ∧ q a ∧ a' = a) ↔ p a' ∧ q a'
-- exists_prop
@[simp] theorem exists_prop : (∃ _h : a, b) ↔ a ∧ b 
Arguments: {b a : Prop}
Goal: (∃ _h, b) ↔ a ∧ b
-- exists_apply_eq_apply
@[simp] theorem exists_apply_eq_apply (f : α → β) (a' : α) : ∃ a, f a = f a' 
Arguments: {α : Sort u_2} {β : Sort u_1} (f : α → β) (a' : α)
Goal: ∃ a, f a = f a'
-- forall_prop_of_true
theorem forall_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' : p), q h') ↔ q h
-- forall_comm
theorem forall_comm {p : α → β → Prop} : (∀ a b, p a b) ↔ (∀ b a, p a b) 
Arguments: {α : Sort u_2} {β : Sort u_1} {p : α → β → Prop}
Goal: (∀ (a : α) (b : β), p a b) ↔ ∀ (b : β) (a : α), p a b
-- exists_comm
theorem exists_comm {p : α → β → Prop} : (∃ a b, p a b) ↔ (∃ b a, p a b) 
Arguments: {α : Sort u_2} {β : Sort u_1} {p : α → β → Prop}
Goal: (∃ a b, p a b) ↔ ∃ b a, p a b
-- forall_apply_eq_imp_iff
@[simp] theorem forall_apply_eq_imp_iff {f : α → β} {p : β → Prop} :
    (∀ b a, f a = b → p b) ↔ ∀ a, p (f a) 
Arguments: {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : β → Prop}
Goal: (∀ (b : β) (a : α), f a = b → p b) ↔ ∀ (a : α), p (f a)
-- forall_eq_apply_imp_iff
@[simp] theorem forall_eq_apply_imp_iff {f : α → β} {p : β → Prop} :
    (∀ b a, b = f a → p b) ↔ ∀ a, p (f a) 
Arguments: {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : β → Prop}
Goal: (∀ (b : β) (a : α), b = f a → p b) ↔ ∀ (a : α), p (f a)
-- forall_apply_eq_imp_iff₂
@[simp] theorem forall_apply_eq_imp_iff₂ {f : α → β} {p : α → Prop} {q : β → Prop} :
    (∀ b a, p a → f a = b → q b) ↔ ∀ a, p a → q (f a) 
Arguments: {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : α → Prop} {q : β → Prop}
Goal: (∀ (b : β) (a : α), p a → f a = b → q b) ↔ ∀ (a : α), p a → q (f a)
-- forall_prop_of_false
theorem forall_prop_of_false {p : Prop} {q : p → Prop} (hn : ¬p) : (∀ h' : p, q h') ↔ True 
Arguments: {p : Prop} {q : p → Prop} (hn : ¬p)
Goal: (∀ (h' : p), q h') ↔ True
-- Decidable.not_not
@[simp] theorem Decidable.not_not [Decidable p] : ¬¬p ↔ p 
Arguments: {p : Prop} [Decidable p]
Goal: ¬¬p ↔ p
-- Decidable.not_or_self
theorem Decidable.not_or_self (p : Prop) [h : Decidable p] : ¬p ∨ p 
Arguments: (p : Prop) [h : Decidable p]
Goal: ¬p ∨ p
-- Decidable.by_contra
theorem Decidable.by_contra [Decidable p] : (¬p → False) → p 
Arguments: {p : Prop} [Decidable p]
Goal: (¬p → False) → p
-- decide_eq_true_iff
theorem decide_eq_true_iff (p : Prop) [Decidable p] : (decide p = true) ↔ p 
Arguments: (p : Prop) [Decidable p]
Goal: decide p = true ↔ p
-- decide_eq_false_iff_not
@[simp] theorem decide_eq_false_iff_not (p : Prop) {_ : Decidable p} : (decide p = false) ↔ ¬p 
Arguments: (p : Prop)
Goal: ∀ {x : Decidable p}, decide p = false ↔ ¬p
-- decide_eq_decide
@[simp] theorem decide_eq_decide {p q : Prop} {_ : Decidable p} {_ : Decidable q} :
    decide p = decide q ↔ (p ↔ q) 
Arguments: {p q : Prop}
Goal: ∀ {x : Decidable p} {x_1 : Decidable q}, decide p = decide q ↔ (p ↔ q)
-- Decidable.of_not_imp
theorem Decidable.of_not_imp [Decidable a] (h : ¬(a → b)) : a 
Arguments: {a b : Prop} [Decidable a] (h : ¬(a → b))
Goal: a
-- Decidable.not_imp_symm
theorem Decidable.not_imp_symm [Decidable a] (h : ¬a → b) (hb : ¬b) : a 
Arguments: {a b : Prop} [Decidable a] (h : ¬a → b) (hb : ¬b)
Goal: a
-- Decidable.not_imp_comm
theorem Decidable.not_imp_comm [Decidable a] [Decidable b] : (¬a → b) ↔ (¬b → a) 
Arguments: {a b : Prop} [Decidable a] [Decidable b]
Goal: ¬a → b ↔ ¬b → a
-- Decidable.not_imp_self
@[simp] theorem Decidable.not_imp_self [Decidable a] : (¬a → a) ↔ a 
Arguments: {a : Prop} [Decidable a]
Goal: ¬a → a ↔ a
-- Decidable.or_iff_not_imp_left
theorem Decidable.or_iff_not_imp_left [Decidable a] : a ∨ b ↔ (¬a → b) 
Arguments: {a b : Prop} [Decidable a]
Goal: a ∨ b ↔ ¬a → b
-- Decidable.or_iff_not_imp_right
theorem Decidable.or_iff_not_imp_right [Decidable b] : a ∨ b ↔ (¬b → a) 
Arguments: {b a : Prop} [Decidable b]
Goal: a ∨ b ↔ ¬b → a
-- Decidable.not_imp_not
theorem Decidable.not_imp_not [Decidable a] : (¬a → ¬b) ↔ (b → a) 
Arguments: {a b : Prop} [Decidable a]
Goal: ¬a → ¬b ↔ b → a
-- Decidable.not_or_of_imp
theorem Decidable.not_or_of_imp [Decidable a] (h : a → b) : ¬a ∨ b 
Arguments: {a b : Prop} [Decidable a] (h : a → b)
Goal: ¬a ∨ b
-- Decidable.imp_iff_not_or
theorem Decidable.imp_iff_not_or [Decidable a] : (a → b) ↔ (¬a ∨ b) 
Arguments: {a b : Prop} [Decidable a]
Goal: a → b ↔ ¬a ∨ b
-- Decidable.imp_iff_or_not
theorem Decidable.imp_iff_or_not [Decidable b] : b → a ↔ a ∨ ¬b 
Arguments: {b a : Prop} [Decidable b]
Goal: b → a ↔ a ∨ ¬b
-- Decidable.imp_or
theorem Decidable.imp_or [h : Decidable a] : (a → b ∨ c) ↔ (a → b) ∨ (a → c) 
Arguments: {a b c : Prop} [h : Decidable a]
Goal: a → b ∨ c ↔ (a → b) ∨ (a → c)
-- Decidable.imp_or'
theorem Decidable.imp_or' [Decidable b] : (a → b ∨ c) ↔ (a → b) ∨ (a → c) 
Arguments: {b : Prop} {a : Sort u_1} {c : Prop} [Decidable b]
Goal: a → b ∨ c ↔ (a → b) ∨ (a → c)
-- Decidable.not_imp_iff_and_not
theorem Decidable.not_imp_iff_and_not [Decidable a] : ¬(a → b) ↔ a ∧ ¬b 
Arguments: {a b : Prop} [Decidable a]
Goal: ¬(a → b) ↔ a ∧ ¬b
-- Decidable.peirce
theorem Decidable.peirce (a b : Prop) [Decidable a] : ((a → b) → a) → a 
Arguments: (a b : Prop) [Decidable a]
Goal: ((a → b) → a) → a
-- peirce'
theorem peirce' {a : Prop} (H : ∀ b : Prop, (a → b) → a) : a 
Arguments: {a : Prop} (H : ∀ (b : Prop), (a → b) → a)
Goal: a
-- Decidable.not_iff_not
theorem Decidable.not_iff_not [Decidable a] [Decidable b] : (¬a ↔ ¬b) ↔ (a ↔ b) 
Arguments: {a b : Prop} [Decidable a] [Decidable b]
Goal: (¬a ↔ ¬b) ↔ (a ↔ b)
-- Decidable.not_iff_comm
theorem Decidable.not_iff_comm [Decidable a] [Decidable b] : (¬a ↔ b) ↔ (¬b ↔ a) 
Arguments: {a b : Prop} [Decidable a] [Decidable b]
Goal: (¬a ↔ b) ↔ (¬b ↔ a)
-- Decidable.not_iff
theorem Decidable.not_iff [Decidable b] : ¬(a ↔ b) ↔ (¬a ↔ b) 
Arguments: {b a : Prop} [Decidable b]
Goal: ¬(a ↔ b) ↔ (¬a ↔ b)
-- Decidable.iff_not_comm
theorem Decidable.iff_not_comm [Decidable a] [Decidable b] : (a ↔ ¬b) ↔ (b ↔ ¬a) 
Arguments: {a b : Prop} [Decidable a] [Decidable b]
Goal: (a ↔ ¬b) ↔ (b ↔ ¬a)
-- Decidable.iff_iff_and_or_not_and_not
theorem Decidable.iff_iff_and_or_not_and_not {a b : Prop} [Decidable b] :
    (a ↔ b) ↔ (a ∧ b) ∨ (¬a ∧ ¬b) 
Arguments: {a b : Prop} [Decidable b]
Goal: (a ↔ b) ↔ a ∧ b ∨ ¬a ∧ ¬b
-- Decidable.iff_iff_not_or_and_or_not
theorem Decidable.iff_iff_not_or_and_or_not [Decidable a] [Decidable b] :
    (a ↔ b) ↔ (¬a ∨ b) ∧ (a ∨ ¬b) 
Arguments: {a b : Prop} [Decidable a] [Decidable b]
Goal: (a ↔ b) ↔ (¬a ∨ b) ∧ (a ∨ ¬b)
-- Decidable.not_and_not_right
theorem Decidable.not_and_not_right [Decidable b] : ¬(a ∧ ¬b) ↔ (a → b) 
Arguments: {b a : Prop} [Decidable b]
Goal: ¬(a ∧ ¬b) ↔ a → b
-- Decidable.not_and_iff_or_not_not
theorem Decidable.not_and_iff_or_not_not [Decidable a] : ¬(a ∧ b) ↔ ¬a ∨ ¬b 
Arguments: {a b : Prop} [Decidable a]
Goal: ¬(a ∧ b) ↔ ¬a ∨ ¬b
-- Decidable.not_and_iff_or_not_not'
theorem Decidable.not_and_iff_or_not_not' [Decidable b] : ¬(a ∧ b) ↔ ¬a ∨ ¬b 
Arguments: {b a : Prop} [Decidable b]
Goal: ¬(a ∧ b) ↔ ¬a ∨ ¬b
-- Decidable.or_iff_not_and_not
theorem Decidable.or_iff_not_and_not [Decidable a] [Decidable b] : a ∨ b ↔ ¬(¬a ∧ ¬b) 
Arguments: {a b : Prop} [Decidable a] [Decidable b]
Goal: a ∨ b ↔ ¬(¬a ∧ ¬b)
-- Decidable.and_iff_not_or_not
theorem Decidable.and_iff_not_or_not [Decidable a] [Decidable b] : a ∧ b ↔ ¬(¬a ∨ ¬b) 
Arguments: {a b : Prop} [Decidable a] [Decidable b]
Goal: a ∧ b ↔ ¬(¬a ∨ ¬b)
-- Decidable.imp_iff_right_iff
theorem Decidable.imp_iff_right_iff [Decidable a] : (a → b ↔ b) ↔ a ∨ b 
Arguments: {a b : Prop} [Decidable a]
Goal: (a → b ↔ b) ↔ a ∨ b
-- Decidable.imp_iff_left_iff
theorem Decidable.imp_iff_left_iff  [Decidable a] : (b ↔ a → b) ↔ a ∨ b 
Arguments: {a b : Prop} [Decidable a]
Goal: (b ↔ a → b) ↔ a ∨ b
-- Decidable.and_or_imp
theorem Decidable.and_or_imp [Decidable a] : a ∧ b ∨ (a → c) ↔ a → b ∨ c 
Arguments: {a b c : Prop} [Decidable a]
Goal: a ∧ b ∨ (a → c) ↔ a → b ∨ c
-- Decidable.or_congr_left'
theorem Decidable.or_congr_left' [Decidable c] (h : ¬c → (a ↔ b)) : a ∨ c ↔ b ∨ c 
Arguments: {c a b : Prop} [Decidable c] (h : ¬c → (a ↔ b))
Goal: a ∨ c ↔ b ∨ c
-- Decidable.or_congr_right'
theorem Decidable.or_congr_right' [Decidable a] (h : ¬a → (b ↔ c)) : a ∨ b ↔ a ∨ c 
Arguments: {a b c : Prop} [Decidable a] (h : ¬a → (b ↔ c))
Goal: a ∨ b ↔ a ∨ c
-- Decidable.not_forall
protected theorem Decidable.not_forall {p : α → Prop} [Decidable (∃ x, ¬p x)]
    [∀ x, Decidable (p x)] : (¬∀ x, p x) ↔ ∃ x, ¬p x 
Arguments: {α : Sort u_1} {p : α → Prop} [Decidable (∃ x, ¬p x)] [(x : α) → Decidable (p x)]
Goal: (¬∀ (x : α), p x) ↔ ∃ x, ¬p x
-- Decidable.not_forall_not
protected theorem Decidable.not_forall_not {p : α → Prop} [Decidable (∃ x, p x)] :
    (¬∀ x, ¬p x) ↔ ∃ x, p x 
Arguments: {α : Sort u_1} {p : α → Prop} [Decidable (∃ x, p x)]
Goal: (¬∀ (x : α), ¬p x) ↔ ∃ x, p x
-- Decidable.not_exists_not
protected theorem Decidable.not_exists_not {p : α → Prop} [∀ x, Decidable (p x)] :
    (¬∃ x, ¬p x) ↔ ∀ x, p x 
Arguments: {α : Sort u_1} {p : α → Prop} [(x : α) → Decidable (p x)]
Goal: (¬∃ x, ¬p x) ↔ ∀ (x : α), p x
-- decide_implies
@[simp]
theorem decide_implies (u v : Prop)
    [duv : Decidable (u → v)] [du : Decidable u] {dv : u → Decidable v}
  : decide (u → v) = dite u (fun h => @decide v (dv h)) (fun _ => true) 
Arguments: (u v : Prop) [duv : Decidable (u → v)] [du : Decidable u] {dv : u → Decidable v}
Goal: decide (u → v) = if h : u then decide v else true
-- decide_ite
@[simp]
theorem decide_ite (u : Prop) [du : Decidable u] (p q : Prop)
      [dpq : Decidable (ite u p q)] [dp : Decidable p] [dq : Decidable q] :
    decide (ite u p q) = ite u (decide p) (decide q) 
Arguments: (u : Prop) [du : Decidable u] (p q : Prop) [dpq : Decidable (if u then p else q)] [dp : Decidable p] [dq : Decidable q]
Goal: decide (if u then p else q) = if u then decide p else decide q
-- ite_true_decide_same
@[simp] theorem ite_true_decide_same (p : Prop) [h : Decidable p] (b : Bool) :
  (if p then decide p else b) = (decide p || b) 
Arguments: (p : Prop) [h : Decidable p] (b : Bool)
Goal: (if p then decide p else b) = (decide p || b)
-- ite_false_decide_same
@[simp] theorem ite_false_decide_same (p : Prop) [h : Decidable p] (b : Bool) :
  (if p then b else decide p) = (decide p && b) 
Arguments: (p : Prop) [h : Decidable p] (b : Bool)
Goal: (if p then b else decide p) = (decide p && b)
-- id_eq
@[simp] theorem id_eq (a : α) : Eq (id a) a 
Arguments: {α : Sort u_1} (a : α)
Goal: Eq (id a) a
-- Eq.subst
theorem Eq.subst {α : Sort u} {motive : α → Prop} {a b : α} (h₁ : Eq a b) (h₂ : motive a) : motive b 
Arguments: {α : Sort u} {motive : α → Prop} {a b : α} (h₁ : Eq a b) (h₂ : motive a)
Goal: motive b
-- Eq.symm
theorem Eq.symm {α : Sort u} {a b : α} (h : Eq a b) : Eq b a 
Arguments: {α : Sort u} {a b : α} (h : Eq a b)
Goal: Eq b a
-- Eq.trans
theorem Eq.trans {α : Sort u} {a b c : α} (h₁ : Eq a b) (h₂ : Eq b c) : Eq a c 
Arguments: {α : Sort u} {a b c : α} (h₁ : Eq a b) (h₂ : Eq b c)
Goal: Eq a c
-- congrArg
theorem congrArg {α : Sort u} {β : Sort v} {a₁ a₂ : α} (f : α → β) (h : Eq a₁ a₂) : Eq (f a₁) (f a₂) 
Arguments: {α : Sort u} {β : Sort v} {a₁ a₂ : α} (f : α → β) (h : Eq a₁ a₂)
Goal: Eq (f a₁) (f a₂)
-- congr
theorem congr {α : Sort u} {β : Sort v} {f₁ f₂ : α → β} {a₁ a₂ : α} (h₁ : Eq f₁ f₂) (h₂ : Eq a₁ a₂) : Eq (f₁ a₁) (f₂ a₂) 
Arguments: {α : Sort u} {β : Sort v} {f₁ f₂ : α → β} {a₁ a₂ : α} (h₁ : Eq f₁ f₂) (h₂ : Eq a₁ a₂)
Goal: Eq (f₁ a₁) (f₂ a₂)
-- congrFun
theorem congrFun {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x} (h : Eq f g) (a : α) : Eq (f a) (g a) 
Arguments: {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x} (h : Eq f g) (a : α)
Goal: Eq (f a) (g a)
-- eq_of_heq
theorem eq_of_heq {α : Sort u} {a a' : α} (h : HEq a a') : Eq a a' 
Arguments: {α : Sort u} {a a' : α} (h : HEq a a')
Goal: Eq a a'
-- And.right
@[pp_using_anonymous_constructor]
structure And (a b : Prop) : Prop where
    intro ::
    left : a
    right : b
Arguments: {a b : Prop} (self : And a b)
Goal: b
-- And.left
@[pp_using_anonymous_constructor]
structure And (a b : Prop) : Prop where
    intro ::
    left : a
    right : b
Arguments: {a b : Prop} (self : And a b)
Goal: a
-- Or.intro_left
theorem Or.intro_left (b : Prop) (h : a) : Or a b 
Arguments: {a : Prop} (b : Prop) (h : a)
Goal: Or a b
-- Or.intro_right
theorem Or.intro_right (a : Prop) (h : b) : Or a b 
Arguments: {b : Prop} (a : Prop) (h : b)
Goal: Or a b
-- Or.elim
theorem Or.elim {c : Prop} (h : Or a b) (left : a → c) (right : b → c) : c 
Arguments: {a b c : Prop} (h : Or a b) (left : a → c) (right : b → c)
Goal: c
-- Or.resolve_left
theorem Or.resolve_left  (h: Or a b) (na : Not a) : b 
Arguments: {a b : Prop} (h : Or a b) (na : Not a)
Goal: b
-- Or.resolve_right
theorem Or.resolve_right (h: Or a b) (nb : Not b) : a 
Arguments: {a b : Prop} (h : Or a b) (nb : Not b)
Goal: a
-- Or.neg_resolve_left
theorem Or.neg_resolve_left  (h : Or (Not a) b) (ha : a) : b 
Arguments: {a b : Prop} (h : Or (Not a) b) (ha : a)
Goal: b
-- Or.neg_resolve_right
theorem Or.neg_resolve_right (h : Or a (Not b)) (nb : b) : a 
Arguments: {a b : Prop} (h : Or a (Not b)) (nb : b)
Goal: a
-- Subtype.property
@[pp_using_anonymous_constructor]
structure Subtype {α : Sort u} (p : α → Prop) where
    val : α
    property : p val
Arguments: {α : Sort u} {p : α → Prop} (self : Subtype p)
Goal: p self.val
-- eq_false_of_ne_true
theorem eq_false_of_ne_true : {b : Bool} → Not (Eq b true) → Eq b false
  
Arguments: {b : Bool}
Goal: Not (Eq b true) → Eq b false
-- eq_true_of_ne_false
theorem eq_true_of_ne_false : {b : Bool} → Not (Eq b false) → Eq b true
  
Arguments: {b : Bool}
Goal: Not (Eq b false) → Eq b true
-- ne_false_of_eq_true
theorem ne_false_of_eq_true : {b : Bool} → Eq b true → Not (Eq b false)
  
Arguments: {b : Bool}
Goal: Eq b true → Not (Eq b false)
-- ne_true_of_eq_false
theorem ne_true_of_eq_false : {b : Bool} → Eq b false → Not (Eq b true)
  
Arguments: {b : Bool}
Goal: Eq b false → Not (Eq b true)
-- Nonempty.elim
protected theorem Nonempty.elim {α : Sort u} {p : Prop} (h₁ : Nonempty α) (h₂ : α → p) : p 
Arguments: {α : Sort u} {p : Prop} (h₁ : Nonempty α) (h₂ : α → p)
Goal: p
-- PLift.up_down
theorem PLift.up_down {α : Sort u} (b : PLift α) : Eq (up (down b)) b 
Arguments: {α : Sort u} (b : PLift α)
Goal: Eq { down := b.down } b
-- PLift.down_up
theorem PLift.down_up {α : Sort u} (a : α) : Eq (down (up a)) a 
Arguments: {α : Sort u} (a : α)
Goal: Eq { down := a }.down a
-- ULift.up_down
theorem ULift.up_down {α : Type u} (b : ULift.{v} α) : Eq (up (down b)) b 
Arguments: {α : Type u} (b : ULift α)
Goal: Eq { down := b.down } b
-- ULift.down_up
theorem ULift.down_up {α : Type u} (a : α) : Eq (down (up.{v} a)) a 
Arguments: {α : Type u} (a : α)
Goal: Eq { down := a }.down a
-- decide_eq_true
theorem decide_eq_true : [inst : Decidable p] → p → Eq (decide p) true
  
Arguments: {p : Prop} [inst : Decidable p]
Goal: p → Eq (decide p) true
-- decide_eq_false
theorem decide_eq_false : [Decidable p] → Not p → Eq (decide p) false
  
Arguments: {p : Prop} [Decidable p]
Goal: Not p → Eq (decide p) false
-- of_decide_eq_true
theorem of_decide_eq_true [inst : Decidable p] : Eq (decide p) true → p 
Arguments: {p : Prop} [inst : Decidable p]
Goal: Eq (decide p) true → p
-- of_decide_eq_false
theorem of_decide_eq_false [inst : Decidable p] : Eq (decide p) false → Not p 
Arguments: {p : Prop} [inst : Decidable p]
Goal: Eq (decide p) false → Not p
-- of_decide_eq_self_eq_true
theorem of_decide_eq_self_eq_true [inst : DecidableEq α] (a : α) : Eq (decide (Eq a a)) true 
Arguments: {α : Sort u_1} [inst : DecidableEq α] (a : α)
Goal: Eq (decide (Eq a a)) true
-- Nat.eq_of_beq_eq_true
theorem Nat.eq_of_beq_eq_true : {n m : Nat} → Eq (beq n m) true → Eq n m
  
Arguments: {n m : Nat}
Goal: Eq (n.beq m) true → Eq n m
-- Nat.ne_of_beq_eq_false
theorem Nat.ne_of_beq_eq_false : {n m : Nat} → Eq (beq n m) false → Not (Eq n m)
  
Arguments: {n m : Nat}
Goal: Eq (n.beq m) false → Not (Eq n m)
-- Nat.not_succ_le_zero
theorem Nat.not_succ_le_zero : ∀ (n : Nat), LE.le (succ n) 0 → False
  
Arguments: (n : Nat)
Goal: LE.le n.succ 0 → False
-- Nat.not_lt_zero
theorem Nat.not_lt_zero (n : Nat) : Not (LT.lt n 0) 
Arguments: (n : Nat)
Goal: Not (LT.lt n 0)
-- Nat.zero_le
theorem Nat.zero_le : (n : Nat) → LE.le 0 n
  
Arguments: (n : Nat)
Goal: LE.le 0 n
-- Nat.succ_le_succ
theorem Nat.succ_le_succ : LE.le n m → LE.le (succ n) (succ m)
  
Arguments: {n m : Nat}
Goal: LE.le n m → LE.le n.succ m.succ
-- Nat.zero_lt_succ
theorem Nat.zero_lt_succ (n : Nat) : LT.lt 0 (succ n) 
Arguments: (n : Nat)
Goal: LT.lt 0 n.succ
-- Nat.le_step
theorem Nat.le_step (h : LE.le n m) : LE.le n (succ m) 
Arguments: {n m : Nat} (h : LE.le n m)
Goal: LE.le n m.succ
-- Nat.le_trans
protected theorem Nat.le_trans {n m k : Nat} : LE.le n m → LE.le m k → LE.le n k
  
Arguments: {n m k : Nat}
Goal: LE.le n m → LE.le m k → LE.le n k
-- Nat.lt_trans
protected theorem Nat.lt_trans {n m k : Nat} (h₁ : LT.lt n m) : LT.lt m k → LT.lt n k 
Arguments: {n m k : Nat} (h₁ : LT.lt n m)
Goal: LT.lt m k → LT.lt n k
-- Nat.le_succ
theorem Nat.le_succ (n : Nat) : LE.le n (succ n) 
Arguments: (n : Nat)
Goal: LE.le n n.succ
-- Nat.le_succ_of_le
theorem Nat.le_succ_of_le {n m : Nat} (h : LE.le n m) : LE.le n (succ m) 
Arguments: {n m : Nat} (h : LE.le n m)
Goal: LE.le n m.succ
-- Nat.le_refl
protected theorem Nat.le_refl (n : Nat) : LE.le n n 
Arguments: (n : Nat)
Goal: LE.le n n
-- Nat.succ_pos
theorem Nat.succ_pos (n : Nat) : LT.lt 0 (succ n) 
Arguments: (n : Nat)
Goal: LT.lt 0 n.succ
-- Nat.pred_le_pred
theorem Nat.pred_le_pred : {n m : Nat} → LE.le n m → LE.le (pred n) (pred m)
  
Arguments: {n m : Nat}
Goal: LE.le n m → LE.le n.pred m.pred
-- Nat.le_of_succ_le_succ
theorem Nat.le_of_succ_le_succ {n m : Nat} : LE.le (succ n) (succ m) → LE.le n m 
Arguments: {n m : Nat}
Goal: LE.le n.succ m.succ → LE.le n m