File: Mathlib/Logic/Basic.lean

full_name: hidden
code: /-- An identity function with its main argument implicit. This will be printed as `hidden` even
if it is applied to a large term, so it can be used for elision,
as done in the `elide` and `unelide` tactics. -/
abbrev hidden {α : Sort*} {a : α} 
goal: α

full_name: decidableEq_of_subsingleton
code: instance (priority := 10) decidableEq_of_subsingleton [Subsingleton α] : DecidableEq α 
goal: DecidableEq α

full_name: instSubsingletonSubtype_mathlib
code: instance [Subsingleton α] (p : α → Prop) : Subsingleton (Subtype p) 
goal: Subsingleton (Subtype p)

full_name: congr_heq
code: theorem congr_heq {α β γ : Sort _} {f : α → γ} {g : β → γ} {x : α} {y : β}
    (h₁ : HEq f g) (h₂ : HEq x y) : f x = g y 
goal: f x = g y

full_name: congr_arg_heq
code: theorem congr_arg_heq {β : α → Sort*} (f : ∀ a, β a) :
    ∀ {a₁ a₂ : α}, a₁ = a₂ → HEq (f a₁) (f a₂)
  
goal: a₁ = a₂ → HEq (f a₁) (f a₂)

full_name: eq_iff_eq_cancel_left
code: @[simp] theorem eq_iff_eq_cancel_left {b c : α} : (∀ {a}, a = b ↔ a = c) ↔ b = c 
goal: (∀ {a : α}, a = b ↔ a = c) ↔ b = c

full_name: eq_iff_eq_cancel_right
code: @[simp] theorem eq_iff_eq_cancel_right {a b : α} : (∀ {c}, a = c ↔ b = c) ↔ a = b 
goal: (∀ {c : α}, a = c ↔ b = c) ↔ a = b

full_name: ne_and_eq_iff_right
code: lemma ne_and_eq_iff_right {a b c : α} (h : b ≠ c) : a ≠ b ∧ a = c ↔ a = c 
goal: a ≠ b ∧ a = c ↔ a = c

full_name: Fact.out
code: /-- Wrapper for adding elementary propositions to the type class systems.
Warning: this can easily be abused. See the rest of this docstring for details.

Certain propositions should not be treated as a class globally,
but sometimes it is very convenient to be able to use the type class system
in specific circumstances.

For example, `ZMod p` is a field if and only if `p` is a prime number.
In order to be able to find this field instance automatically by type class search,
we have to turn `p.prime` into an instance implicit assumption.

On the other hand, making `Nat.prime` a class would require a major refactoring of the library,
and it is questionable whether making `Nat.prime` a class is desirable at all.
The compromise is to add the assumption `[Fact p.prime]` to `ZMod.field`.

In particular, this class is not intended for turning the type class system
into an automated theorem prover for first order logic. -/
class Fact (p : Prop) : Prop where
  /-- `Fact.out` contains the unwrapped witness for the fact represented by the instance of
  `Fact p`. -/
  out : p
goal: p

full_name: Fact
code: /-- Wrapper for adding elementary propositions to the type class systems.
Warning: this can easily be abused. See the rest of this docstring for details.

Certain propositions should not be treated as a class globally,
but sometimes it is very convenient to be able to use the type class system
in specific circumstances.

For example, `ZMod p` is a field if and only if `p` is a prime number.
In order to be able to find this field instance automatically by type class search,
we have to turn `p.prime` into an instance implicit assumption.

On the other hand, making `Nat.prime` a class would require a major refactoring of the library,
and it is questionable whether making `Nat.prime` a class is desirable at all.
The compromise is to add the assumption `[Fact p.prime]` to `ZMod.field`.

In particular, this class is not intended for turning the type class system
into an automated theorem prover for first order logic. -/
class Fact (p : Prop) : Prop where
  /-- `Fact.out` contains the unwrapped witness for the fact represented by the instance of
  `Fact p`. -/
  out : p
goal: Prop

full_name: Fact.elim
code: theorem Fact.elim {p : Prop} (h : Fact p) : p 
goal: p

full_name: fact_iff
code: theorem fact_iff {p : Prop} : Fact p ↔ p 
goal: Fact p ↔ p

full_name: instDecidableFact
code: instance {p : Prop} [Decidable p] : Decidable (Fact p) 
goal: Decidable (Fact p)

full_name: Function.swap₂
code: /-- Swaps two pairs of arguments to a function. -/
abbrev Function.swap₂ {ι₁ ι₂ : Sort*} {κ₁ : ι₁ → Sort*} {κ₂ : ι₂ → Sort*}
    {φ : ∀ i₁, κ₁ i₁ → ∀ i₂, κ₂ i₂ → Sort*} (f : ∀ i₁ j₁ i₂ j₂, φ i₁ j₁ i₂ j₂)
    (i₂ j₂ i₁ j₁) : φ i₁ j₁ i₂ j₂ 
goal: φ i₁ j₁ i₂ j₂

full_name: instIsReflPropIff
code: instance : IsRefl Prop Iff 
goal: IsRefl Prop Iff

full_name: instIsTransPropIff
code: instance : IsTrans Prop Iff 
goal: IsTrans Prop Iff

full_name: imp_iff_right_iff
code: theorem imp_iff_right_iff {a b : Prop} : (a → b ↔ b) ↔ a ∨ b 
goal: (a → b ↔ b) ↔ a ∨ b

full_name: and_or_imp
code: theorem and_or_imp {a b c : Prop} : a ∧ b ∨ (a → c) ↔ a → b ∨ c 
goal: a ∧ b ∨ (a → c) ↔ a → b ∨ c

full_name: Function.mt
code: /-- Provide modus tollens (`mt`) as dot notation for implications. -/
protected theorem Function.mt {a b : Prop} : (a → b) → ¬b → ¬a 
goal: (a → b) → ¬b → ¬a

full_name: dec_em'
code: theorem dec_em' (p : Prop) [Decidable p] : ¬p ∨ p 
goal: ¬p ∨ p

full_name: em'
code: theorem em' (p : Prop) : ¬p ∨ p 
goal: ¬p ∨ p

full_name: or_not
code: theorem or_not {p : Prop} : p ∨ ¬p 
goal: p ∨ ¬p

full_name: Decidable.eq_or_ne
code: theorem Decidable.eq_or_ne {α : Sort*} (x y : α) [Decidable (x = y)] : x = y ∨ x ≠ y 
goal: x = y ∨ x ≠ y

full_name: Decidable.ne_or_eq
code: theorem Decidable.ne_or_eq {α : Sort*} (x y : α) [Decidable (x = y)] : x ≠ y ∨ x = y 
goal: x ≠ y ∨ x = y

full_name: eq_or_ne
code: theorem eq_or_ne {α : Sort*} (x y : α) : x = y ∨ x ≠ y 
goal: x = y ∨ x ≠ y

full_name: ne_or_eq
code: theorem ne_or_eq {α : Sort*} (x y : α) : x ≠ y ∨ x = y 
goal: x ≠ y ∨ x = y

full_name: by_contradiction
code: theorem by_contradiction {p : Prop} : (¬p → False) → p 
goal: (¬p → False) → p

full_name: by_cases
code: theorem by_cases {p q : Prop} (hpq : p → q) (hnpq : ¬p → q) : q 
goal: q

full_name: of_not_not
code: theorem of_not_not {a : Prop} : ¬¬a → a 
goal: ¬¬a → a

full_name: not_ne_iff
code: theorem not_ne_iff {α : Sort*} {a b : α} : ¬a ≠ b ↔ a = b 
goal: ¬a ≠ b ↔ a = b

full_name: of_not_imp
code: theorem of_not_imp : ¬(a → b) → a 
goal: ¬(a → b) → a

full_name: Not.imp_symm
code: theorem Not.imp_symm : (¬a → b) → ¬b → a 
goal: (¬a → b) → ¬b → a

full_name: not_imp_comm
code: theorem not_imp_comm : ¬a → b ↔ ¬b → a 
goal: ¬a → b ↔ ¬b → a

full_name: not_imp_self
code: @[simp] theorem not_imp_self : ¬a → a ↔ a 
goal: ¬a → a ↔ a

full_name: Imp.swap
code: theorem Imp.swap {a b : Sort*} {c : Prop} : a → b → c ↔ b → a → c 
goal: a → b → c ↔ b → a → c

full_name: Iff.not_left
code: theorem Iff.not_left (h : a ↔ ¬b) : ¬a ↔ b 
goal: ¬a ↔ b

full_name: Iff.not_right
code: theorem Iff.not_right (h : ¬a ↔ b) : a ↔ ¬b 
goal: a ↔ ¬b

full_name: Iff.ne
code: protected lemma Iff.ne {α β : Sort*} {a b : α} {c d : β} : (a = b ↔ c = d) → (a ≠ b ↔ c ≠ d) 
goal: (a = b ↔ c = d) → (a ≠ b ↔ c ≠ d)

full_name: Iff.ne_left
code: lemma Iff.ne_left {α β : Sort*} {a b : α} {c d : β} : (a = b ↔ c ≠ d) → (a ≠ b ↔ c = d) 
goal: (a = b ↔ c ≠ d) → (a ≠ b ↔ c = d)

full_name: Iff.ne_right
code: lemma Iff.ne_right {α β : Sort*} {a b : α} {c d : β} : (a ≠ b ↔ c = d) → (a = b ↔ c ≠ d) 
goal: (a ≠ b ↔ c = d) → (a = b ↔ c ≠ d)

full_name: xor_true
code: @[simp] theorem xor_true : Xor' True = Not 
goal: Xor' True = Not

full_name: xor_false
code: @[simp] theorem xor_false : Xor' False = id 
goal: Xor' False = id

full_name: xor_comm
code: theorem xor_comm (a b : Prop) : Xor' a b = Xor' b a 
goal: Xor' a b = Xor' b a

full_name: instCommutativeXor'
code: instance : Std.Commutative Xor' 
goal: Std.Commutative Xor'

full_name: xor_self
code: @[simp] theorem xor_self (a : Prop) : Xor' a a = False 
goal: Xor' a a = False

full_name: xor_not_left
code: @[simp] theorem xor_not_left : Xor' (¬a) b ↔ (a ↔ b) 
goal: Xor' (¬a) b ↔ (a ↔ b)

full_name: xor_not_right
code: @[simp] theorem xor_not_right : Xor' a (¬b) ↔ (a ↔ b) 
goal: Xor' a ¬b ↔ (a ↔ b)

full_name: xor_not_not
code: theorem xor_not_not : Xor' (¬a) (¬b) ↔ Xor' a b 
goal: Xor' (¬a) ¬b ↔ Xor' a b

full_name: Xor'.or
code: protected theorem Xor'.or (h : Xor' a b) : a ∨ b 
goal: a ∨ b

full_name: and_symm_right
code: theorem and_symm_right {α : Sort*} (a b : α) (p : Prop) : p ∧ a = b ↔ p ∧ b = a 
goal: p ∧ a = b ↔ p ∧ b = a

full_name: and_symm_left
code: theorem and_symm_left {α : Sort*} (a b : α) (p : Prop) : a = b ∧ p ↔ b = a ∧ p 
goal: a = b ∧ p ↔ b = a ∧ p

full_name: Or.elim3
code: theorem Or.elim3 {c d : Prop} (h : a ∨ b ∨ c) (ha : a → d) (hb : b → d) (hc : c → d) : d 
goal: d

full_name: Or.imp3
code: theorem Or.imp3 {d e c f : Prop} (had : a → d) (hbe : b → e) (hcf : c → f) :
    a ∨ b ∨ c → d ∨ e ∨ f 
goal: a ∨ b ∨ c → d ∨ e ∨ f

full_name: not_or_of_imp
code: theorem not_or_of_imp : (a → b) → ¬a ∨ b 
goal: (a → b) → ¬a ∨ b

full_name: Decidable.or_not_of_imp
code: protected theorem Decidable.or_not_of_imp [Decidable a] (h : a → b) : b ∨ ¬a 
goal: b ∨ ¬a

full_name: or_not_of_imp
code: theorem or_not_of_imp : (a → b) → b ∨ ¬a 
goal: (a → b) → b ∨ ¬a

full_name: imp_iff_not_or
code: theorem imp_iff_not_or : a → b ↔ ¬a ∨ b 
goal: a → b ↔ ¬a ∨ b

full_name: imp_iff_or_not
code: theorem imp_iff_or_not {b a : Prop} : b → a ↔ a ∨ ¬b 
goal: b → a ↔ a ∨ ¬b

full_name: not_imp_not
code: theorem not_imp_not : ¬a → ¬b ↔ b → a 
goal: ¬a → ¬b ↔ b → a

full_name: imp_and_neg_imp_iff
code: theorem imp_and_neg_imp_iff (p q : Prop) : (p → q) ∧ (¬p → q) ↔ q 
goal: (p → q) ∧ (¬p → q) ↔ q

full_name: Function.mtr
code: /-- Provide the reverse of modus tollens (`mt`) as dot notation for implications. -/
protected theorem Function.mtr : (¬a → ¬b) → b → a 
goal: (¬a → ¬b) → b → a

full_name: or_congr_left'
code: theorem or_congr_left' {c a b : Prop} (h : ¬c → (a ↔ b)) : a ∨ c ↔ b ∨ c 
goal: a ∨ c ↔ b ∨ c

full_name: or_congr_right'
code: theorem or_congr_right' {c : Prop} (h : ¬a → (b ↔ c)) : a ∨ b ↔ a ∨ c 
goal: a ∨ b ↔ a ∨ c

full_name: iff_mpr_iff_true_intro
code: theorem iff_mpr_iff_true_intro {P : Prop} (h : P) : Iff.mpr (iff_true_intro h) True.intro = h 
goal: ⋯ = h

full_name: imp_or
code: theorem imp_or {a b c : Prop} : a → b ∨ c ↔ (a → b) ∨ (a → c) 
goal: a → b ∨ c ↔ (a → b) ∨ (a → c)

full_name: imp_or'
code: theorem imp_or' {a : Sort*} {b c : Prop} : a → b ∨ c ↔ (a → b) ∨ (a → c) 
goal: a → b ∨ c ↔ (a → b) ∨ (a → c)

full_name: not_imp
code: theorem not_imp : ¬(a → b) ↔ a ∧ ¬b 
goal: ¬(a → b) ↔ a ∧ ¬b

full_name: peirce
code: theorem peirce (a b : Prop) : ((a → b) → a) → a 
goal: ((a → b) → a) → a

full_name: not_iff_not
code: theorem not_iff_not : (¬a ↔ ¬b) ↔ (a ↔ b) 
goal: (¬a ↔ ¬b) ↔ (a ↔ b)

full_name: not_iff_comm
code: theorem not_iff_comm : (¬a ↔ b) ↔ (¬b ↔ a) 
goal: (¬a ↔ b) ↔ (¬b ↔ a)

full_name: not_iff
code: theorem not_iff : ¬(a ↔ b) ↔ (¬a ↔ b) 
goal: ¬(a ↔ b) ↔ (¬a ↔ b)

full_name: iff_not_comm
code: theorem iff_not_comm : (a ↔ ¬b) ↔ (b ↔ ¬a) 
goal: (a ↔ ¬b) ↔ (b ↔ ¬a)

full_name: iff_iff_and_or_not_and_not
code: theorem iff_iff_and_or_not_and_not : (a ↔ b) ↔ a ∧ b ∨ ¬a ∧ ¬b 
goal: (a ↔ b) ↔ a ∧ b ∨ ¬a ∧ ¬b

full_name: iff_iff_not_or_and_or_not
code: theorem iff_iff_not_or_and_or_not : (a ↔ b) ↔ (¬a ∨ b) ∧ (a ∨ ¬b) 
goal: (a ↔ b) ↔ (¬a ∨ b) ∧ (a ∨ ¬b)

full_name: not_and_not_right
code: theorem not_and_not_right : ¬(a ∧ ¬b) ↔ a → b 
goal: ¬(a ∧ ¬b) ↔ a → b

full_name: not_and_or
code: /-- One of **de Morgan's laws**: the negation of a conjunction is logically equivalent to the
disjunction of the negations. -/
theorem not_and_or : ¬(a ∧ b) ↔ ¬a ∨ ¬b 
goal: ¬(a ∧ b) ↔ ¬a ∨ ¬b

full_name: or_iff_not_and_not
code: theorem or_iff_not_and_not : a ∨ b ↔ ¬(¬a ∧ ¬b) 
goal: a ∨ b ↔ ¬(¬a ∧ ¬b)

full_name: and_iff_not_or_not
code: theorem and_iff_not_or_not : a ∧ b ↔ ¬(¬a ∨ ¬b) 
goal: a ∧ b ↔ ¬(¬a ∨ ¬b)

full_name: not_xor
code: @[simp] theorem not_xor (P Q : Prop) : ¬Xor' P Q ↔ (P ↔ Q) 
goal: ¬Xor' P Q ↔ (P ↔ Q)

full_name: xor_iff_not_iff
code: theorem xor_iff_not_iff (P Q : Prop) : Xor' P Q ↔ ¬ (P ↔ Q) 
goal: Xor' P Q ↔ ¬(P ↔ Q)

full_name: xor_iff_iff_not
code: theorem xor_iff_iff_not : Xor' a b ↔ (a ↔ ¬b) 
goal: Xor' a b ↔ (a ↔ ¬b)

full_name: xor_iff_not_iff'
code: theorem xor_iff_not_iff' : Xor' a b ↔ (¬a ↔ b) 
goal: Xor' a b ↔ (¬a ↔ b)

full_name: forall_cond_comm
code: theorem forall_cond_comm {α} {s : α → Prop} {p : α → α → Prop} :
    (∀ a, s a → ∀ b, s b → p a b) ↔ ∀ a b, s a → s b → p a b 
goal: (∀ (a : α), s a → ∀ (b : α), s b → p a b) ↔ ∀ (a b : α), s a → s b → p a b

full_name: forall_mem_comm
code: theorem forall_mem_comm {α β} [Membership α β] {s : β} {p : α → α → Prop} :
    (∀ a (_ : a ∈ s) b (_ : b ∈ s), p a b) ↔ ∀ a b, a ∈ s → b ∈ s → p a b 
goal: (∀ (a : α), a ∈ s → ∀ (b : α), b ∈ s → p a b) ↔ ∀ (a b : α), a ∈ s → b ∈ s → p a b

full_name: ne_of_eq_of_ne
code: lemma ne_of_eq_of_ne {α : Sort*} {a b c : α} (h₁ : a = b) (h₂ : b ≠ c) : a ≠ c 
goal: a ≠ c

full_name: ne_of_ne_of_eq
code: lemma ne_of_ne_of_eq {α : Sort*} {a b c : α} (h₁ : a ≠ b) (h₂ : b = c) : a ≠ c 
goal: a ≠ c

full_name: eq_equivalence
code: theorem eq_equivalence {α : Sort*} : Equivalence (@Eq α) 
goal: Equivalence Eq

full_name: congr_refl_left
code: theorem congr_refl_left {α β : Sort*} (f : α → β) {a b : α} (h : a = b) :
    congr (Eq.refl f) h = congr_arg f h 
goal: ⋯ = ⋯

full_name: congr_refl_right
code: theorem congr_refl_right {α β : Sort*} {f g : α → β} (h : f = g) (a : α) :
    congr h (Eq.refl a) = congr_fun h a 
goal: ⋯ = ⋯

full_name: congr_arg_refl
code: theorem congr_arg_refl {α β : Sort*} (f : α → β) (a : α) :
    congr_arg f (Eq.refl a) = Eq.refl (f a) 
goal: ⋯ = ⋯

full_name: congr_fun_rfl
code: theorem congr_fun_rfl {α β : Sort*} (f : α → β) (a : α) : congr_fun (Eq.refl f) a = Eq.refl (f a) 
goal: ⋯ = ⋯

full_name: congr_fun_congr_arg
code: theorem congr_fun_congr_arg {α β γ : Sort*} (f : α → β → γ) {a a' : α} (p : a = a') (b : β) :
    congr_fun (congr_arg f p) b = congr_arg (fun a ↦ f a b) p 
goal: ⋯ = ⋯

full_name: Eq.rec_eq_cast
code: theorem Eq.rec_eq_cast {α : Sort _} {P : α → Sort _} {x y : α} (h : x = y) (z : P x) :
    h ▸ z = cast (congr_arg P h) z 
goal: h ▸ z = cast ⋯ z

full_name: eqRec_heq'
code: theorem eqRec_heq' {α : Sort*} {a' : α} {motive : (a : α) → a' = a → Sort*}
    (p : motive a' (rfl : a' = a')) {a : α} (t : a' = a) :
    HEq (@Eq.rec α a' motive p a t) p 
goal: HEq (t ▸ p) p

full_name: rec_heq_of_heq
code: theorem rec_heq_of_heq {C : α → Sort*} {x : C a} {y : β} (e : a = b) (h : HEq x y) :
    HEq (e ▸ x) y 
goal: HEq (e ▸ x) y

full_name: rec_heq_iff_heq
code: theorem rec_heq_iff_heq {C : α → Sort*} {x : C a} {y : β} {e : a = b} :
    HEq (e ▸ x) y ↔ HEq x y 
goal: HEq (e ▸ x) y ↔ HEq x y

full_name: heq_rec_iff_heq
code: theorem heq_rec_iff_heq {C : α → Sort*} {x : β} {y : C a} {e : a = b} :
    HEq x (e ▸ y) ↔ HEq x y 
goal: HEq x (e ▸ y) ↔ HEq x y

full_name: pi_congr
code: theorem pi_congr {β' : α → Sort _} (h : ∀ a, β a = β' a) : (∀ a, β a) = ∀ a, β' a 
goal: ((a : α) → β a) = ((a : α) → β' a)

full_name: forall₂_imp
code: theorem forall₂_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 
goal: (∀ (a : α) (b : β a), p a b) → ∀ (a : α) (b : β a), q a b

full_name: forall₃_imp
code: 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 
goal: (∀ (a : α) (b : β a) (c : γ a b), p a b c) → ∀ (a : α) (b : β a) (c : γ a b), q a b c

full_name: Exists₂.imp
code: 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 
goal: (∃ a b, p a b) → ∃ a b, q a b

full_name: Exists₃.imp
code: 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 
goal: (∃ a b c, p a b c) → ∃ a b c, q a b c

full_name: forall_swap
code: theorem forall_swap {p : α → β → Prop} : (∀ x y, p x y) ↔ ∀ y x, p x y 
goal: (∀ (x : α) (y : β), p x y) ↔ ∀ (y : β) (x : α), p x y

full_name: forall₂_swap
code: 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₂ 
goal: (∀ (i₁ : ι₁) (j₁ : κ₁ i₁) (i₂ : ι₂) (j₂ : κ₂ i₂), p i₁ j₁ i₂ j₂) ↔
  ∀ (i₂ : ι₂) (j₂ : κ₂ i₂) (i₁ : ι₁) (j₁ : κ₁ i₁), p i₁ j₁ i₂ j₂

full_name: imp_forall_iff
code: /-- We intentionally restrict the type of `α` in this lemma so that this is a safer to use in simp
than `forall_swap`. -/
theorem imp_forall_iff {α : Type*} {p : Prop} {q : α → Prop} : (p → ∀ x, q x) ↔ ∀ x, p → q x 
goal: (p → ∀ (x : α), q x) ↔ ∀ (x : α), p → q x

full_name: exists_swap
code: theorem exists_swap {p : α → β → Prop} : (∃ x y, p x y) ↔ ∃ y x, p x y 
goal: (∃ x y, p x y) ↔ ∃ y x, p x y

full_name: not_forall_not
code: theorem not_forall_not : (¬∀ x, ¬p x) ↔ ∃ x, p x 
goal: (¬∀ (x : α), ¬p x) ↔ ∃ x, p x

full_name: forall_or_exists_not
code: lemma forall_or_exists_not (P : α → Prop) : (∀ a, P a) ∨ ∃ a, ¬ P a 
goal: (∀ (a : α), P a) ∨ ∃ a, ¬P a

full_name: exists_or_forall_not
code: lemma exists_or_forall_not (P : α → Prop) : (∃ a, P a) ∨ ∀ a, ¬ P a 
goal: (∃ a, P a) ∨ ∀ (a : α), ¬P a

full_name: forall_imp_iff_exists_imp
code: theorem forall_imp_iff_exists_imp {α : Sort*} {p : α → Prop} {b : Prop} [ha : Nonempty α] :
    (∀ x, p x) → b ↔ ∃ x, p x → b 
goal: (∀ (x : α), p x) → b ↔ ∃ x, p x → b

full_name: forall_true_iff
code: @[mfld_simps]
theorem forall_true_iff : (α → True) ↔ True 
goal: α → True ↔ True

full_name: forall_true_iff'
code: theorem forall_true_iff' (h : ∀ a, p a ↔ True) : (∀ a, p a) ↔ True 
goal: (∀ (a : α), p a) ↔ True

full_name: forall₂_true_iff
code: theorem forall₂_true_iff {β : α → Sort*} : (∀ a, β a → True) ↔ True 
goal: (∀ (a : α), β a → True) ↔ True

full_name: forall₃_true_iff
code: theorem forall₃_true_iff {β : α → Sort*} {γ : ∀ a, β a → Sort*} :
    (∀ (a) (b : β a), γ a b → True) ↔ True 
goal: (∀ (a : α) (b : β a), γ a b → True) ↔ True

full_name: exists_unique_iff_exists
code: @[simp] theorem exists_unique_iff_exists [Subsingleton α] {p : α → Prop} :
    (∃! x, p x) ↔ ∃ x, p x 
goal: (∃! x, p x) ↔ ∃ x, p x

full_name: exists_unique_const
code: theorem exists_unique_const {b : Prop} (α : Sort*) [i : Nonempty α] [Subsingleton α] :
    (∃! _ : α, b) ↔ b 
goal: (∃! x, b) ↔ b

full_name: Decidable.and_forall_ne
code: theorem Decidable.and_forall_ne [DecidableEq α] (a : α) {p : α → Prop} :
    (p a ∧ ∀ b, b ≠ a → p b) ↔ ∀ b, p b 
goal: (p a ∧ ∀ (b : α), b ≠ a → p b) ↔ ∀ (b : α), p b

full_name: and_forall_ne
code: theorem and_forall_ne (a : α) : (p a ∧ ∀ b, b ≠ a → p b) ↔ ∀ b, p b 
goal: (p a ∧ ∀ (b : α), b ≠ a → p b) ↔ ∀ (b : α), p b

full_name: Ne.ne_or_ne
code: theorem Ne.ne_or_ne {x y : α} (z : α) (h : x ≠ y) : x ≠ z ∨ y ≠ z 
goal: x ≠ z ∨ y ≠ z

full_name: exists_unique_eq
code: @[simp] theorem exists_unique_eq {a' : α} : ∃! a, a = a' 
goal: ∃! a, a = a'

full_name: exists_unique_eq'
code: @[simp] theorem exists_unique_eq' {a' : α} : ∃! a, a' = a 
goal: ∃! a, a' = a

full_name: exists_apply_eq_apply'
code: @[simp]
theorem exists_apply_eq_apply' (f : α → β) (a' : α) : ∃ a, f a' = f a 
goal: ∃ a, f a' = f a

full_name: exists_apply_eq_apply2
code: @[simp]
lemma exists_apply_eq_apply2 {α β γ} {f : α → β → γ} {a : α} {b : β} : ∃ x y, f x y = f a b 
goal: ∃ x y, f x y = f a b

full_name: exists_apply_eq_apply2'
code: @[simp]
lemma exists_apply_eq_apply2' {α β γ} {f : α → β → γ} {a : α} {b : β} : ∃ x y, f a b = f x y 
goal: ∃ x y, f a b = f x y

full_name: exists_apply_eq_apply3
code: @[simp]
lemma exists_apply_eq_apply3 {α β γ δ} {f : α → β → γ → δ} {a : α} {b : β} {c : γ} :
    ∃ x y z, f x y z = f a b c 
goal: ∃ x y z, f x y z = f a b c

full_name: exists_apply_eq_apply3'
code: @[simp]
lemma exists_apply_eq_apply3' {α β γ δ} {f : α → β → γ → δ} {a : α} {b : β} {c : γ} :
    ∃ x y z, f a b c = f x y z 
goal: ∃ x y z, f a b c = f x y z

full_name: exists_apply_eq
code: theorem exists_apply_eq (a : α) (b : β) : ∃ f : α → β, f a = b 
goal: ∃ f, f a = b

full_name: exists_exists_and_eq_and
code: @[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) 
goal: (∃ b, (∃ a, p a ∧ f a = b) ∧ q b) ↔ ∃ a, p a ∧ q (f a)

full_name: exists_exists_eq_and
code: @[simp] theorem exists_exists_eq_and {f : α → β} {p : β → Prop} :
    (∃ b, (∃ a, f a = b) ∧ p b) ↔ ∃ a, p (f a) 
goal: (∃ b, (∃ a, f a = b) ∧ p b) ↔ ∃ a, p (f a)

full_name: exists_exists_and_exists_and_eq_and
code: @[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) 
goal: (∃ c, (∃ a, p a ∧ ∃ b, q b ∧ f a b = c) ∧ r c) ↔ ∃ a, p a ∧ ∃ b, q b ∧ r (f a b)

full_name: exists_exists_exists_and_eq
code: @[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) 
goal: (∃ c, (∃ a b, f a b = c) ∧ p c) ↔ ∃ a b, p (f a b)

full_name: exists_or_eq_left
code: @[simp] theorem exists_or_eq_left (y : α) (p : α → Prop) : ∃ x : α, x = y ∨ p x 
goal: ∃ x, x = y ∨ p x

full_name: exists_or_eq_right
code: @[simp] theorem exists_or_eq_right (y : α) (p : α → Prop) : ∃ x : α, p x ∨ x = y 
goal: ∃ x, p x ∨ x = y

full_name: exists_or_eq_left'
code: @[simp] theorem exists_or_eq_left' (y : α) (p : α → Prop) : ∃ x : α, y = x ∨ p x 
goal: ∃ x, y = x ∨ p x

full_name: exists_or_eq_right'
code: @[simp] theorem exists_or_eq_right' (y : α) (p : α → Prop) : ∃ x : α, p x ∨ y = x 
goal: ∃ x, p x ∨ y = x

full_name: forall_apply_eq_imp_iff'
code: theorem forall_apply_eq_imp_iff' {f : α → β} {p : β → Prop} :
    (∀ a b, f a = b → p b) ↔ ∀ a, p (f a) 
goal: (∀ (a : α) (b : β), f a = b → p b) ↔ ∀ (a : α), p (f a)

full_name: forall_eq_apply_imp_iff'
code: theorem forall_eq_apply_imp_iff' {f : α → β} {p : β → Prop} :
    (∀ a b, b = f a → p b) ↔ ∀ a, p (f a) 
goal: (∀ (a : α) (b : β), b = f a → p b) ↔ ∀ (a : α), p (f a)

full_name: exists_eq_right'
code: @[simp] theorem exists_eq_right' {a' : α} : (∃ a, p a ∧ a' = a) ↔ p a' 
goal: (∃ a, p a ∧ a' = a) ↔ p a'

full_name: exists₂_comm
code: 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₂ 
goal: (∃ i₁ j₁ i₂ j₂, p i₁ j₁ i₂ j₂) ↔ ∃ i₂ j₂ i₁ j₁, p i₁ j₁ i₂ j₂

full_name: And.exists
code: theorem And.exists {p q : Prop} {f : p ∧ q → Prop} : (∃ h, f h) ↔ ∃ hp hq, f ⟨hp, hq⟩ 
goal: (∃ h, f h) ↔ ∃ hp hq, f ⋯

full_name: forall_or_of_or_forall
code: theorem forall_or_of_or_forall {α : Sort*} {p : α → Prop} {b : Prop} (h : b ∨ ∀ x, p x) (x : α) :
    b ∨ p x 
goal: b ∨ p x

full_name: Decidable.forall_or_left
code: protected theorem Decidable.forall_or_left {q : Prop} {p : α → Prop} [Decidable q] :
    (∀ x, q ∨ p x) ↔ q ∨ ∀ x, p x 
goal: (∀ (x : α), q ∨ p x) ↔ q ∨ ∀ (x : α), p x

full_name: forall_or_left
code: theorem forall_or_left {q} {p : α → Prop} : (∀ x, q ∨ p x) ↔ q ∨ ∀ x, p x 
goal: (∀ (x : α), q ∨ p x) ↔ q ∨ ∀ (x : α), p x

full_name: Decidable.forall_or_right
code: protected theorem Decidable.forall_or_right {q} {p : α → Prop} [Decidable q] :
    (∀ x, p x ∨ q) ↔ (∀ x, p x) ∨ q 
goal: (∀ (x : α), p x ∨ q) ↔ (∀ (x : α), p x) ∨ q

full_name: forall_or_right
code: theorem forall_or_right {q} {p : α → Prop} : (∀ x, p x ∨ q) ↔ (∀ x, p x) ∨ q 
goal: (∀ (x : α), p x ∨ q) ↔ (∀ (x : α), p x) ∨ q

full_name: exists_unique_prop
code: theorem exists_unique_prop {p q : Prop} : (∃! _ : p, q) ↔ p ∧ q 
goal: (∃! x, q) ↔ p ∧ q

full_name: exists_unique_false
code: @[simp] theorem exists_unique_false : ¬∃! _ : α, False 
goal: ¬∃! x, False

full_name: Exists.fst
code: theorem Exists.fst {b : Prop} {p : b → Prop} : Exists p → b
  
goal: Exists p → b

full_name: Exists.snd
code: theorem Exists.snd {b : Prop} {p : b → Prop} : ∀ h : Exists p, p h.fst
  
goal: p ⋯

full_name: Prop.exists_iff
code: theorem Prop.exists_iff {p : Prop → Prop} : (∃ h, p h) ↔ p False ∨ p True 
goal: (∃ h, p h) ↔ p False ∨ p True

full_name: Prop.forall_iff
code: theorem Prop.forall_iff {p : Prop → Prop} : (∀ h, p h) ↔ p False ∧ p True 
goal: (∀ (h : Prop), p h) ↔ p False ∧ p True

full_name: exists_prop_of_true
code: theorem exists_prop_of_true {p : Prop} {q : p → Prop} (h : p) : (∃ h' : p, q h') ↔ q h 
goal: (∃ h', q h') ↔ q h

full_name: exists_iff_of_forall
code: theorem exists_iff_of_forall {p : Prop} {q : p → Prop} (h : ∀ h, q h) : (∃ h, q h) ↔ p 
goal: (∃ h, q h) ↔ p

full_name: exists_unique_prop_of_true
code: theorem exists_unique_prop_of_true {p : Prop} {q : p → Prop} (h : p) : (∃! h' : p, q h') ↔ q h 
goal: (∃! h', q h') ↔ q h

full_name: exists_prop_of_false
code: theorem exists_prop_of_false {p : Prop} {q : p → Prop} : ¬p → ¬∃ h' : p, q h' 
goal: ¬p → ¬∃ h', q h'

full_name: exists_prop_congr
code: @[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) 
goal: Exists q ↔ ∃ h, q' ⋯

full_name: exists_true_left
code: /-- See `IsEmpty.exists_iff` for the `False` version. -/
@[simp] theorem exists_true_left (p : True → Prop) : (∃ x, p x) ↔ p True.intro 
goal: (∃ x, p x) ↔ p True.intro

full_name: forall_prop_congr
code: 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) 
goal: (∀ (h : p), q h) ↔ ∀ (h : p'), q' ⋯

full_name: forall_prop_congr'
code: 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) 
goal: (∀ (h : p), q h) = ∀ (h : p'), q' ⋯

full_name: imp_congr_eq
code: lemma imp_congr_eq {a b c d : Prop} (h₁ : a = c) (h₂ : b = d) : (a → b) = (c → d) 
goal: (a → b) = (c → d)

full_name: imp_congr_ctx_eq
code: lemma imp_congr_ctx_eq {a b c d : Prop} (h₁ : a = c) (h₂ : c → b = d) : (a → b) = (c → d) 
goal: (a → b) = (c → d)

full_name: eq_true_intro
code: lemma eq_true_intro {a : Prop} (h : a) : a = True 
goal: a = True

full_name: eq_false_intro
code: lemma eq_false_intro {a : Prop} (h : ¬a) : a = False 
goal: a = False

full_name: iff_eq_eq
code: lemma iff_eq_eq {a b : Prop} : (a ↔ b) = (a = b) 
goal: (a ↔ b) = (a = b)

full_name: forall_true_left
code: /-- See `IsEmpty.forall_iff` for the `False` version. -/
@[simp] theorem forall_true_left (p : True → Prop) : (∀ x, p x) ↔ p True.intro 
goal: (∀ (x : True), p x) ↔ p True.intro

full_name: ExistsUnique.elim₂
code: 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 
goal: b

full_name: ExistsUnique.intro₂
code: 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 
goal: ∃! x, ∃! hx, q x hx

full_name: ExistsUnique.exists₂
code: 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 
goal: ∃ x hx, q x hx

full_name: ExistsUnique.unique₂
code: 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₂ 
goal: y₁ = y₂

full_name: Classical.dec
code: /-- Any prop `p` is decidable classically. A shorthand for `Classical.propDecidable`. -/
noncomputable def dec (p : Prop) : Decidable p 
goal: Decidable p

full_name: Classical.decPred
code: /-- Any predicate `p` is decidable classically. -/
noncomputable def decPred (p : α → Prop) : DecidablePred p 
goal: DecidablePred p

full_name: Classical.decRel
code: /-- Any relation `p` is decidable classically. -/
noncomputable def decRel (p : α → α → Prop) : DecidableRel p 
goal: DecidableRel p

full_name: Classical.decEq
code: /-- Any type `α` has decidable equality classically. -/
noncomputable def decEq (α : Sort*) : DecidableEq α 
goal: DecidableEq α

full_name: Classical.existsCases
code: /-- Construct a function from a default value `H0`, and a function to use if there exists a value
satisfying the predicate. -/
-- @[elab_as_elim] -- FIXME
noncomputable def existsCases {α C : Sort*} {p : α → Prop} (H0 : C) (H : ∀ a, p a → C) : C 
goal: C

full_name: Classical.some_spec₂
code: theorem some_spec₂ {α : Sort*} {p : α → Prop} {h : ∃ a, p a} (q : α → Prop)
    (hpq : ∀ a, p a → q a) : q (choose h) 
goal: q (Classical.choose h)

full_name: Classical.subtype_of_exists
code: /-- A version of `Classical.indefiniteDescription` which is definitionally equal to a pair.

In Lean 4, this definition is defeq to `Classical.indefiniteDescription`,
so it is deprecated. -/
@[deprecated Classical.indefiniteDescription (since := "2024-07-04")]
noncomputable def subtype_of_exists {α : Type*} {P : α → Prop} (h : ∃ x, P x) : { x // P x } 
goal: { x // P x }

full_name: Classical.byContradiction'
code: /-- A version of `byContradiction` that uses types instead of propositions. -/
protected noncomputable def byContradiction' {α : Sort*} (H : ¬(α → False)) : α 
goal: α

full_name: Classical.choice_of_byContradiction'
code: /-- `Classical.byContradiction'` is equivalent to lean's axiom `Classical.choice`. -/
def choice_of_byContradiction' {α : Sort*} (contra : ¬(α → False) → α) : Nonempty α → α 
goal: Nonempty α → α

full_name: Classical.choose_eq
code: @[simp] lemma choose_eq (a : α) : @Exists.choose _ (· = a) ⟨a, rfl⟩ = a 
goal: ⋯.choose = a

full_name: Classical.choose_eq'
code: @[simp]
lemma choose_eq' (a : α) : @Exists.choose _ (a = ·) ⟨a, rfl⟩ = a 
goal: ⋯.choose = a

full_name: Exists.classicalRecOn
code: /-- This function has the same type as `Exists.recOn`, and can be used to case on an equality,
but `Exists.recOn` can only eliminate into Prop, while this version eliminates into any universe
using the axiom of choice. -/
-- @[elab_as_elim] -- FIXME
noncomputable def Exists.classicalRecOn {α : Sort*} {p : α → Prop} (h : ∃ a, p a)
    {C : Sort*} (H : ∀ a, p a → C) : C 
goal: C

full_name: bex_def
code: theorem bex_def : (∃ (x : _) (_ : p x), q x) ↔ ∃ x, p x ∧ q x 
goal: (∃ x x_1, q x) ↔ ∃ x, p x ∧ q x

full_name: BEx.elim
code: theorem BEx.elim {b : Prop} : (∃ x h, P x h) → (∀ a h, P a h → b) → b
  
goal: (∃ x h, P x h) → (∀ (a : α) (h : p a), P a h → b) → b

full_name: BEx.intro
code: theorem BEx.intro (a : α) (h₁ : p a) (h₂ : P a h₁) : ∃ (x : _) (h : p x), P x h 
goal: ∃ x h, P x h

full_name: bex_eq_left
code: @[deprecated exists_eq_left (since := "2024-04-06")]
theorem bex_eq_left {a : α} : (∃ (x : _) (_ : x = a), p x) ↔ p a 
goal: (∃ x x_1, p x) ↔ p a

full_name: BAll.imp_right
code: theorem BAll.imp_right (H : ∀ x h, P x h → Q x h) (h₁ : ∀ x h, P x h) (x h) : Q x h 
goal: Q x h

full_name: BEx.imp_right
code: theorem BEx.imp_right (H : ∀ x h, P x h → Q x h) : (∃ x h, P x h) → ∃ x h, Q x h
  
goal: (∃ x h, P x h) → ∃ x h, Q x h

full_name: BAll.imp_left
code: theorem BAll.imp_left (H : ∀ x, p x → q x) (h₁ : ∀ x, q x → r x) (x) (h : p x) : r x 
goal: r x

full_name: BEx.imp_left
code: theorem BEx.imp_left (H : ∀ x, p x → q x) : (∃ (x : _) (_ : p x), r x) → ∃ (x : _) (_ : q x), r x
  
goal: (∃ x x_1, r x) → ∃ x x_1, r x

full_name: ball_of_forall
code: @[deprecated id (since := "2024-03-23")]
theorem ball_of_forall (h : ∀ x, p x) (x) : p x 
goal: p x

full_name: forall_of_ball
code: @[deprecated forall_imp (since := "2024-03-23")]
theorem forall_of_ball (H : ∀ x, p x) (h : ∀ x, p x → q x) (x) : q x 
goal: q x

full_name: exists_mem_of_exists
code: theorem exists_mem_of_exists (H : ∀ x, p x) : (∃ x, q x) → ∃ (x : _) (_ : p x), q x
  
goal: (∃ x, q x) → ∃ x x_1, q x

full_name: exists_of_exists_mem
code: theorem exists_of_exists_mem : (∃ (x : _) (_ : p x), q x) → ∃ x, q x
  
goal: (∃ x x_1, q x) → ∃ x, q x

full_name: exists₂_imp
code: theorem exists₂_imp : (∃ x h, P x h) → b ↔ ∀ x h, P x h → b 
goal: (∃ x h, P x h) → b ↔ ∀ (x : α) (h : p x), P x h → b

full_name: not_exists_mem
code: theorem not_exists_mem : (¬∃ x h, P x h) ↔ ∀ x h, ¬P x h 
goal: (¬∃ x h, P x h) ↔ ∀ (x : α) (h : p x), ¬P x h

full_name: not_forall₂_of_exists₂_not
code: theorem not_forall₂_of_exists₂_not : (∃ x h, ¬P x h) → ¬∀ x h, P x h
  
goal: (∃ x h, ¬P x h) → ¬∀ (x : α) (h : p x), P x h

full_name: Decidable.not_forall₂
code: 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 
goal: (¬∀ (x : α) (h : p x), P x h) ↔ ∃ x h, ¬P x h

full_name: not_forall₂
code: theorem not_forall₂ : (¬∀ x h, P x h) ↔ ∃ x h, ¬P x h 
goal: (¬∀ (x : α) (h : p x), P x h) ↔ ∃ x h, ¬P x h

full_name: forall₂_and
code: theorem forall₂_and : (∀ x h, P x h ∧ Q x h) ↔ (∀ x h, P x h) ∧ ∀ x h, Q x h 
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

full_name: forall_and_left
code: theorem forall_and_left [Nonempty α] (q : Prop) (p : α → Prop) :
    (∀ x, q ∧ p x) ↔ (q ∧ ∀ x, p x) 
goal: (∀ (x : α), q ∧ p x) ↔ q ∧ ∀ (x : α), p x

full_name: forall_and_right
code: theorem forall_and_right [Nonempty α] (p : α → Prop) (q : Prop) :
    (∀ x, p x ∧ q) ↔ (∀ x, p x) ∧ q 
goal: (∀ (x : α), p x ∧ q) ↔ (∀ (x : α), p x) ∧ q

full_name: exists_mem_or
code: theorem exists_mem_or : (∃ x h, P x h ∨ Q x h) ↔ (∃ x h, P x h) ∨ ∃ x h, Q x h 
goal: (∃ x h, P x h ∨ Q x h) ↔ (∃ x h, P x h) ∨ ∃ x h, Q x h

full_name: forall₂_or_left
code: theorem forall₂_or_left : (∀ x, p x ∨ q x → r x) ↔ (∀ x, p x → r x) ∧ ∀ x, q x → r x 
goal: (∀ (x : α), p x ∨ q x → r x) ↔ (∀ (x : α), p x → r x) ∧ ∀ (x : α), q x → r x

full_name: exists_mem_or_left
code: theorem exists_mem_or_left :
    (∃ (x : _) (_ : p x ∨ q x), r x) ↔ (∃ (x : _) (_ : p x), r x) ∨ ∃ (x : _) (_ : q x), r x 
goal: (∃ x x_1, r x) ↔ (∃ x x_1, r x) ∨ ∃ x x_1, r x

full_name: dite_eq_iff
code: theorem dite_eq_iff : dite P A B = c ↔ (∃ h, A h = c) ∨ ∃ h, B h = c 
goal: dite P A B = c ↔ (∃ h, A h = c) ∨ ∃ h, B h = c

full_name: ite_eq_iff
code: theorem ite_eq_iff : ite P a b = c ↔ P ∧ a = c ∨ ¬P ∧ b = c 
goal: (if P then a else b) = c ↔ P ∧ a = c ∨ ¬P ∧ b = c

full_name: eq_ite_iff
code: theorem eq_ite_iff : a = ite P b c ↔ P ∧ a = b ∨ ¬P ∧ a = c 
goal: (a = if P then b else c) ↔ P ∧ a = b ∨ ¬P ∧ a = c

full_name: dite_eq_iff'
code: theorem dite_eq_iff' : dite P A B = c ↔ (∀ h, A h = c) ∧ ∀ h, B h = c 
goal: dite P A B = c ↔ (∀ (h : P), A h = c) ∧ ∀ (h : ¬P), B h = c

full_name: ite_eq_iff'
code: theorem ite_eq_iff' : ite P a b = c ↔ (P → a = c) ∧ (¬P → b = c) 
goal: (if P then a else b) = c ↔ (P → a = c) ∧ (¬P → b = c)

full_name: dite_ne_left_iff
code: theorem dite_ne_left_iff : dite P (fun _ ↦ a) B ≠ a ↔ ∃ h, a ≠ B h 
goal: dite P (fun x => a) B ≠ a ↔ ∃ h, a ≠ B h

full_name: dite_ne_right_iff
code: theorem dite_ne_right_iff : (dite P A fun _ ↦ b) ≠ b ↔ ∃ h, A h ≠ b 
goal: (dite P A fun x => b) ≠ b ↔ ∃ h, A h ≠ b

full_name: ite_ne_left_iff
code: theorem ite_ne_left_iff : ite P a b ≠ a ↔ ¬P ∧ a ≠ b 
goal: (if P then a else b) ≠ a ↔ ¬P ∧ a ≠ b

full_name: ite_ne_right_iff
code: theorem ite_ne_right_iff : ite P a b ≠ b ↔ P ∧ a ≠ b 
goal: (if P then a else b) ≠ b ↔ P ∧ a ≠ b

full_name: Ne.dite_eq_left_iff
code: protected theorem Ne.dite_eq_left_iff (h : ∀ h, a ≠ B h) : dite P (fun _ ↦ a) B = a ↔ P 
goal: dite P (fun x => a) B = a ↔ P

full_name: Ne.dite_eq_right_iff
code: protected theorem Ne.dite_eq_right_iff (h : ∀ h, A h ≠ b) : (dite P A fun _ ↦ b) = b ↔ ¬P 
goal: (dite P A fun x => b) = b ↔ ¬P

full_name: Ne.ite_eq_left_iff
code: protected theorem Ne.ite_eq_left_iff (h : a ≠ b) : ite P a b = a ↔ P 
goal: (if P then a else b) = a ↔ P

full_name: Ne.ite_eq_right_iff
code: protected theorem Ne.ite_eq_right_iff (h : a ≠ b) : ite P a b = b ↔ ¬P 
goal: (if P then a else b) = b ↔ ¬P

full_name: Ne.dite_ne_left_iff
code: protected theorem Ne.dite_ne_left_iff (h : ∀ h, a ≠ B h) : dite P (fun _ ↦ a) B ≠ a ↔ ¬P 
goal: dite P (fun x => a) B ≠ a ↔ ¬P

full_name: Ne.dite_ne_right_iff
code: protected theorem Ne.dite_ne_right_iff (h : ∀ h, A h ≠ b) : (dite P A fun _ ↦ b) ≠ b ↔ P 
goal: (dite P A fun x => b) ≠ b ↔ P

full_name: Ne.ite_ne_left_iff
code: protected theorem Ne.ite_ne_left_iff (h : a ≠ b) : ite P a b ≠ a ↔ ¬P 
goal: (if P then a else b) ≠ a ↔ ¬P

full_name: Ne.ite_ne_right_iff
code: protected theorem Ne.ite_ne_right_iff (h : a ≠ b) : ite P a b ≠ b ↔ P 
goal: (if P then a else b) ≠ b ↔ P

full_name: dite_eq_or_eq
code: theorem dite_eq_or_eq : (∃ h, dite P A B = A h) ∨ ∃ h, dite P A B = B h 
goal: (∃ h, dite P A B = A h) ∨ ∃ h, dite P A B = B h

full_name: ite_eq_or_eq
code: theorem ite_eq_or_eq : ite P a b = a ∨ ite P a b = b 
goal: (if P then a else b) = a ∨ (if P then a else b) = b

full_name: apply_dite₂
code: /-- A two-argument function applied to two `dite`s is a `dite` of that two-argument function
applied to each of the branches. -/
theorem apply_dite₂ {α β γ : Sort*} (f : α → β → γ) (P : Prop) [Decidable P]
    (a : P → α) (b : ¬P → α) (c : P → β) (d : ¬P → β) :
    f (dite P a b) (dite P c d) = dite P (fun h ↦ f (a h) (c h)) fun h ↦ f (b h) (d h) 
goal: f (dite P a b) (dite P c d) = if h : P then f (a h) (c h) else f (b h) (d h)

full_name: apply_ite₂
code: /-- A two-argument function applied to two `ite`s is a `ite` of that two-argument function
applied to each of the branches. -/
theorem apply_ite₂ {α β γ : Sort*} (f : α → β → γ) (P : Prop) [Decidable P] (a b : α) (c d : β) :
    f (ite P a b) (ite P c d) = ite P (f a c) (f b d) 
goal: f (if P then a else b) (if P then c else d) = if P then f a c else f b d

full_name: dite_apply
code: /-- A 'dite' producing a `Pi` type `Π a, σ a`, applied to a value `a : α` is a `dite` that applies
either branch to `a`. -/
theorem dite_apply (f : P → ∀ a, σ a) (g : ¬P → ∀ a, σ a) (a : α) :
    (dite P f g) a = dite P (fun h ↦ f h a) fun h ↦ g h a 
goal: dite P f g a = if h : P then f h a else g h a

full_name: ite_apply
code: /-- A 'ite' producing a `Pi` type `Π a, σ a`, applied to a value `a : α` is a `ite` that applies
either branch to `a`. -/
theorem ite_apply (f g : ∀ a, σ a) (a : α) : (ite P f g) a = ite P (f a) (g a) 
goal: (if P then f else g) a = if P then f a else g a

full_name: ite_and
code: theorem ite_and : ite (P ∧ Q) a b = ite P (ite Q a b) b 
goal: (if P ∧ Q then a else b) = if P then if Q then a else b else b

full_name: dite_dite_comm
code: theorem dite_dite_comm {B : Q → α} {C : ¬P → ¬Q → α} (h : P → ¬Q) :
    (if p : P then A p else if q : Q then B q else C p q) =
     if q : Q then B q else if p : P then A p else C p q 
goal: (if p : P then A p else if q : Q then B q else C p q) = if q : Q then B q else if p : P then A p else C p q

full_name: ite_ite_comm
code: theorem ite_ite_comm (h : P → ¬Q) :
    (if P then a else if Q then b else c) =
     if Q then b else if P then a else c 
goal: (if P then a else if Q then b else c) = if Q then b else if P then a else c

full_name: ite_prop_iff_or
code: theorem ite_prop_iff_or : (if P then Q else R) ↔ (P ∧ Q ∨ ¬ P ∧ R) 
goal: (if P then Q else R) ↔ P ∧ Q ∨ ¬P ∧ R

full_name: dite_prop_iff_or
code: theorem dite_prop_iff_or {Q : P → Prop} {R : ¬P → Prop} [Decidable P] :
    dite P Q R ↔ (∃ p, Q p) ∨ (∃ p, R p) 
goal: dite P Q R ↔ (∃ p, Q p) ∨ ∃ p, R p

full_name: ite_prop_iff_and
code: theorem ite_prop_iff_and : (if P then Q else R) ↔ ((P → Q) ∧ (¬ P → R)) 
goal: (if P then Q else R) ↔ (P → Q) ∧ (¬P → R)

full_name: dite_prop_iff_and
code: theorem dite_prop_iff_and {Q : P → Prop} {R : ¬P → Prop} [Decidable P] :
    dite P Q R ↔ (∀ h, Q h) ∧ (∀ h, R h) 
goal: dite P Q R ↔ (∀ (h : P), Q h) ∧ ∀ (h : ¬P), R h

full_name: not_beq_of_ne
code: theorem not_beq_of_ne {α : Type*} [BEq α] [LawfulBEq α] {a b : α} (ne : a ≠ b) : ¬(a == b) 
goal: ¬(a == b) = true

full_name: beq_eq_decide
code: theorem beq_eq_decide {α : Type*} [BEq α] [LawfulBEq α] {a b : α} : (a == b) = decide (a = b) 
goal: (a == b) = decide (a = b)

full_name: beq_ext
code: @[ext]
theorem beq_ext {α : Type*} (inst1 : BEq α) (inst2 : BEq α)
    (h : ∀ x y, @BEq.beq _ inst1 x y = @BEq.beq _ inst2 x y) :
    inst1 = inst2 
goal: inst1 = inst2

full_name: lawful_beq_subsingleton
code: theorem lawful_beq_subsingleton {α : Type*} (inst1 : BEq α) (inst2 : BEq α)
    [@LawfulBEq α inst1] [@LawfulBEq α inst2] :
    inst1 = inst2 
goal: inst1 = inst2