ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- OneOneEquiv.congr_left
theorem OneOneEquiv.congr_left {α β γ} [Primcodable α] [Primcodable β] [Primcodable γ]
    {p : α → Prop} {q : β → Prop} {r : γ → Prop} (h : OneOneEquiv p q) :
    OneOneEquiv p r ↔ OneOneEquiv q r 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Primcodable α] [Primcodable β] [Primcodable γ] {p : α → Prop} {q : β → Prop} {r : γ → Prop} (h : OneOneEquiv p q)
Goal: OneOneEquiv p r ↔ OneOneEquiv q r
-- OneOneEquiv.congr_right
theorem OneOneEquiv.congr_right {α β γ} [Primcodable α] [Primcodable β] [Primcodable γ]
    {p : α → Prop} {q : β → Prop} {r : γ → Prop} (h : OneOneEquiv q r) :
    OneOneEquiv p q ↔ OneOneEquiv p r 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Primcodable α] [Primcodable β] [Primcodable γ] {p : α → Prop} {q : β → Prop} {r : γ → Prop} (h : OneOneEquiv q r)
Goal: OneOneEquiv p q ↔ OneOneEquiv p r
-- ULower.down_computable
@[simp]
theorem ULower.down_computable {α} [Primcodable α] : (ULower.equiv α).Computable 
Arguments: {α : Type u_1} [Primcodable α]
Goal: (ULower.equiv α).Computable
-- manyOneEquiv_up
theorem manyOneEquiv_up {α} [Primcodable α] {p : α → Prop} : ManyOneEquiv (p ∘ ULower.up) p 
Arguments: {α : Type u_1} [Primcodable α] {p : α → Prop}
Goal: ManyOneEquiv (p ∘ ULower.up) p
-- OneOneReducible.disjoin_left
theorem OneOneReducible.disjoin_left {α β} [Primcodable α] [Primcodable β] {p : α → Prop}
    {q : β → Prop} : p ≤₁ p ⊕' q 
Arguments: {α : Type u_1} {β : Type u_2} [Primcodable α] [Primcodable β] {p : α → Prop} {q : β → Prop}
Goal: p ≤₁ p ⊕' q
-- OneOneReducible.disjoin_right
theorem OneOneReducible.disjoin_right {α β} [Primcodable α] [Primcodable β] {p : α → Prop}
    {q : β → Prop} : q ≤₁ p ⊕' q 
Arguments: {α : Type u_1} {β : Type u_2} [Primcodable α] [Primcodable β] {p : α → Prop} {q : β → Prop}
Goal: q ≤₁ p ⊕' q
-- disjoin_manyOneReducible
theorem disjoin_manyOneReducible {α β γ} [Primcodable α] [Primcodable β] [Primcodable γ]
    {p : α → Prop} {q : β → Prop} {r : γ → Prop} : p ≤₀ r → q ≤₀ r → (p ⊕' q) ≤₀ r
  
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Primcodable α] [Primcodable β] [Primcodable γ] {p : α → Prop} {q : β → Prop} {r : γ → Prop}
Goal: p ≤₀ r → q ≤₀ r → p ⊕' q ≤₀ r
-- disjoin_le
theorem disjoin_le {α β γ} [Primcodable α] [Primcodable β] [Primcodable γ] {p : α → Prop}
    {q : β → Prop} {r : γ → Prop} : (p ⊕' q) ≤₀ r ↔ p ≤₀ r ∧ q ≤₀ r 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Primcodable α] [Primcodable β] [Primcodable γ] {p : α → Prop} {q : β → Prop} {r : γ → Prop}
Goal: p ⊕' q ≤₀ r ↔ p ≤₀ r ∧ q ≤₀ r
-- toNat_manyOneReducible
@[simp]
theorem toNat_manyOneReducible {p : Set α} : toNat p ≤₀ p 
Arguments: {α : Type u} [Primcodable α] [Inhabited α] {p : Set α}
Goal: toNat p ≤₀ p
-- manyOneReducible_toNat
@[simp]
theorem manyOneReducible_toNat {p : Set α} : p ≤₀ toNat p 
Arguments: {α : Type u} [Primcodable α] [Inhabited α] {p : Set α}
Goal: p ≤₀ toNat p
-- manyOneReducible_toNat_toNat
@[simp]
theorem manyOneReducible_toNat_toNat {p : Set α} {q : Set β} : toNat p ≤₀ toNat q ↔ p ≤₀ q 
Arguments: {α : Type u} [Primcodable α] [Inhabited α] {β : Type v} [Primcodable β] [Inhabited β] {p : Set α} {q : Set β}
Goal: toNat p ≤₀ toNat q ↔ p ≤₀ q
-- toNat_manyOneEquiv
@[simp]
theorem toNat_manyOneEquiv {p : Set α} : ManyOneEquiv (toNat p) p 
Arguments: {α : Type u} [Primcodable α] [Inhabited α] {p : Set α}
Goal: ManyOneEquiv (toNat p) p
-- manyOneEquiv_toNat
@[simp]
theorem manyOneEquiv_toNat (p : Set α) (q : Set β) :
    ManyOneEquiv (toNat p) (toNat q) ↔ ManyOneEquiv p q 
Arguments: {α : Type u} [Primcodable α] [Inhabited α] {β : Type v} [Primcodable β] [Inhabited β] (p : Set α) (q : Set β)
Goal: ManyOneEquiv (toNat p) (toNat q) ↔ ManyOneEquiv p q
-- ManyOneDegree.ind_on
@[elab_as_elim]
protected theorem ind_on {C : ManyOneDegree → Prop} (d : ManyOneDegree)
    (h : ∀ p : Set ℕ, C (of p)) : C d 
Arguments: {C : ManyOneDegree → Prop} (d : ManyOneDegree) (h : ∀ (p : Set ℕ), C (ManyOneDegree.of p))
Goal: C d
-- ManyOneDegree.liftOn_eq
@[simp]
protected theorem liftOn_eq {φ} (p : Set ℕ) (f : Set ℕ → φ)
    (h : ∀ p q, ManyOneEquiv p q → f p = f q) : (of p).liftOn f h = f p 
Arguments: {φ : Sort u_1} (p : Set ℕ) (f : Set ℕ → φ) (h : ∀ (p q : ℕ → Prop), ManyOneEquiv p q → f p = f q)
Goal: (ManyOneDegree.of p).liftOn f h = f p
-- ManyOneDegree.liftOn₂_eq
@[simp]
protected theorem liftOn₂_eq {φ} (p q : Set ℕ) (f : Set ℕ → Set ℕ → φ)
    (h : ∀ p₁ p₂ q₁ q₂, ManyOneEquiv p₁ p₂ → ManyOneEquiv q₁ q₂ → f p₁ q₁ = f p₂ q₂) :
    (of p).liftOn₂ (of q) f h = f p q 
Arguments: {φ : Sort u_1} (p q : Set ℕ) (f : Set ℕ → Set ℕ → φ) (h : ∀ (p₁ p₂ q₁ q₂ : ℕ → Prop), ManyOneEquiv p₁ p₂ → ManyOneEquiv q₁ q₂ → f p₁ q₁ = f p₂ q₂)
Goal: (ManyOneDegree.of p).liftOn₂ (ManyOneDegree.of q) f h = f p q
-- ManyOneDegree.of_eq_of
@[simp]
theorem of_eq_of {p : α → Prop} {q : β → Prop} : of p = of q ↔ ManyOneEquiv p q 
Arguments: {α : Type u} [Primcodable α] [Inhabited α] {β : Type v} [Primcodable β] [Inhabited β] {p : α → Prop} {q : β → Prop}
Goal: ManyOneDegree.of p = ManyOneDegree.of q ↔ ManyOneEquiv p q
-- ManyOneDegree.of_le_of
@[simp]
theorem of_le_of {p : α → Prop} {q : β → Prop} : of p ≤ of q ↔ p ≤₀ q 
Arguments: {α : Type u} [Primcodable α] [Inhabited α] {β : Type v} [Primcodable β] [Inhabited β] {p : α → Prop} {q : β → Prop}
Goal: ManyOneDegree.of p ≤ ManyOneDegree.of q ↔ p ≤₀ q
-- _private.Mathlib.Computability.Reduce.0.ManyOneDegree.le_refl
private theorem le_refl (d : ManyOneDegree) : d ≤ d 
Arguments: (d : ManyOneDegree)
Goal: d ≤ d
-- _private.Mathlib.Computability.Reduce.0.ManyOneDegree.le_antisymm
private theorem le_antisymm {d₁ d₂ : ManyOneDegree} : d₁ ≤ d₂ → d₂ ≤ d₁ → d₁ = d₂ 
Arguments: {d₁ d₂ : ManyOneDegree}
Goal: d₁ ≤ d₂ → d₂ ≤ d₁ → d₁ = d₂
-- _private.Mathlib.Computability.Reduce.0.ManyOneDegree.le_trans
private theorem le_trans {d₁ d₂ d₃ : ManyOneDegree} : d₁ ≤ d₂ → d₂ ≤ d₃ → d₁ ≤ d₃ 
Arguments: {d₁ d₂ d₃ : ManyOneDegree}
Goal: d₁ ≤ d₂ → d₂ ≤ d₃ → d₁ ≤ d₃
-- ManyOneDegree.add_of
@[simp]
theorem add_of (p : Set α) (q : Set β) : of (p ⊕' q) = of p + of q 
Arguments: {α : Type u} [Primcodable α] [Inhabited α] {β : Type v} [Primcodable β] [Inhabited β] (p : Set α) (q : Set β)
Goal: ManyOneDegree.of (p ⊕' q) = ManyOneDegree.of p + ManyOneDegree.of q
-- ManyOneDegree.add_le
@[simp]
protected theorem add_le {d₁ d₂ d₃ : ManyOneDegree} : d₁ + d₂ ≤ d₃ ↔ d₁ ≤ d₃ ∧ d₂ ≤ d₃ 
Arguments: {d₁ d₂ d₃ : ManyOneDegree}
Goal: d₁ + d₂ ≤ d₃ ↔ d₁ ≤ d₃ ∧ d₂ ≤ d₃
-- ManyOneDegree.le_add_left
@[simp]
protected theorem le_add_left (d₁ d₂ : ManyOneDegree) : d₁ ≤ d₁ + d₂ 
Arguments: (d₁ d₂ : ManyOneDegree)
Goal: d₁ ≤ d₁ + d₂
-- ManyOneDegree.le_add_right
@[simp]
protected theorem le_add_right (d₁ d₂ : ManyOneDegree) : d₂ ≤ d₁ + d₂ 
Arguments: (d₁ d₂ : ManyOneDegree)
Goal: d₂ ≤ d₁ + d₂
-- iff_assoc
theorem iff_assoc {a b c : Prop} : ((a ↔ b) ↔ c) ↔ (a ↔ (b ↔ c)) 
Arguments: {a b c : Prop}
Goal: ((a ↔ b) ↔ c) ↔ (a ↔ (b ↔ c))
-- iff_left_comm
theorem iff_left_comm {a b c : Prop} : (a ↔ (b ↔ c)) ↔ (b ↔ (a ↔ c)) 
Arguments: {a b c : Prop}
Goal: (a ↔ (b ↔ c)) ↔ (b ↔ (a ↔ c))
-- iff_right_comm
theorem iff_right_comm {a b c : Prop} : ((a ↔ b) ↔ c) ↔ ((a ↔ c) ↔ b) 
Arguments: {a b c : Prop}
Goal: ((a ↔ b) ↔ c) ↔ ((a ↔ c) ↔ b)
-- dite_dite_distrib_left
theorem dite_dite_distrib_left {a : p → α} {b : ¬p → q → α} {c : ¬p → ¬q → α} :
    (dite p a fun hp ↦ dite q (b hp) (c hp)) =
      dite q (fun hq ↦ (dite p a) fun hp ↦ b hp hq) fun hq ↦ (dite p a) fun hp ↦ c hp hq 
Arguments: {α : Sort u_1} {p q : Prop} [Decidable p] [Decidable q] {a : p → α} {b : ¬p → q → α} {c : ¬p → ¬q → α}
Goal: (dite p a fun hp => dite q (b hp) (c hp)) = if hq : q then dite p a fun hp => b hp hq else dite p a fun hp => c hp hq
-- dite_dite_distrib_right
theorem dite_dite_distrib_right {a : p → q → α} {b : p → ¬q → α} {c : ¬p → α} :
    dite p (fun hp ↦ dite q (a hp) (b hp)) c =
      dite q (fun hq ↦ dite p (fun hp ↦ a hp hq) c) fun hq ↦ dite p (fun hp ↦ b hp hq) c 
Arguments: {α : Sort u_1} {p q : Prop} [Decidable p] [Decidable q] {a : p → q → α} {b : p → ¬q → α} {c : ¬p → α}
Goal: dite p (fun hp => dite q (a hp) (b hp)) c =
  if hq : q then dite p (fun hp => a hp hq) c else dite p (fun hp => b hp hq) c
-- ite_dite_distrib_left
theorem ite_dite_distrib_left {a : α} {b : q → α} {c : ¬q → α} :
    ite p a (dite q b c) = dite q (fun hq ↦ ite p a <| b hq) fun hq ↦ ite p a <| c hq 
Arguments: {α : Sort u_1} {p q : Prop} [Decidable p] [Decidable q] {a : α} {b : q → α} {c : ¬q → α}
Goal: (if p then a else dite q b c) = if hq : q then if p then a else b hq else if p then a else c hq
-- ite_dite_distrib_right
theorem ite_dite_distrib_right {a : q → α} {b : ¬q → α} {c : α} :
    ite p (dite q a b) c = dite q (fun hq ↦ ite p (a hq) c) fun hq ↦ ite p (b hq) c 
Arguments: {α : Sort u_1} {p q : Prop} [Decidable p] [Decidable q] {a : q → α} {b : ¬q → α} {c : α}
Goal: (if p then dite q a b else c) = if hq : q then if p then a hq else c else if p then b hq else c
-- dite_ite_distrib_left
theorem dite_ite_distrib_left {a : p → α} {b : ¬p → α} {c : ¬p → α} :
    (dite p a fun hp ↦ ite q (b hp) (c hp)) = ite q (dite p a b) (dite p a c) 
Arguments: {α : Sort u_1} {p q : Prop} [Decidable p] [Decidable q] {a : p → α} {b c : ¬p → α}
Goal: (dite p a fun hp => if q then b hp else c hp) = if q then dite p a b else dite p a c
-- dite_ite_distrib_right
theorem dite_ite_distrib_right {a : p → α} {b : p → α} {c : ¬p → α} :
    dite p (fun hp ↦ ite q (a hp) (b hp)) c = ite q (dite p a c) (dite p b c) 
Arguments: {α : Sort u_1} {p q : Prop} [Decidable p] [Decidable q] {a b : p → α} {c : ¬p → α}
Goal: dite p (fun hp => if q then a hp else b hp) c = if q then dite p a c else dite p b c
-- ite_ite_distrib_left
theorem ite_ite_distrib_left : ite p a (ite q b c) = ite q (ite p a b) (ite p a c) 
Arguments: {α : Sort u_1} {p q : Prop} [Decidable p] [Decidable q] {a b c : α}
Goal: (if p then a else if q then b else c) = if q then if p then a else b else if p then a else c
-- ite_ite_distrib_right
theorem ite_ite_distrib_right : ite p (ite q a b) c = ite q (ite p a c) (ite p b c) 
Arguments: {α : Sort u_1} {p q : Prop} [Decidable p] [Decidable q] {a b c : α}
Goal: (if p then if q then a else b else c) = if q then if p then a else c else if p then b else c
-- Prop.forall
lemma Prop.forall {f : Prop → Prop} : (∀ p, f p) ↔ f True ∧ f False 
Arguments: {f : Prop → Prop}
Goal: (∀ (p : Prop), f p) ↔ f True ∧ f False
-- Prop.exists
lemma Prop.exists {f : Prop → Prop} : (∃ p, f p) ↔ f True ∨ f False 
Arguments: {f : Prop → Prop}
Goal: (∃ p, f p) ↔ f True ∨ f False
-- congr_heq
theorem congr_heq {α β γ : Sort _} {f : α → γ} {g : β → γ} {x : α} {y : β}
    (h₁ : HEq f g) (h₂ : HEq x y) : f x = g y 
Arguments: {α β : Sort u_2} {γ : Sort u_3} {f : α → γ} {g : β → γ} {x : α} {y : β} (h₁ : HEq f g) (h₂ : HEq x y)
Goal: f x = g y
-- congr_arg_heq
theorem congr_arg_heq {β : α → Sort*} (f : ∀ a, β a) :
    ∀ {a₁ a₂ : α}, a₁ = a₂ → HEq (f a₁) (f a₂)
  
Arguments: {α : Sort u_1} {β : α → Sort u_2} (f : (a : α) → β a) {a₁ a₂ : α}
Goal: a₁ = a₂ → HEq (f a₁) (f a₂)
-- eq_iff_eq_cancel_left
@[simp] theorem eq_iff_eq_cancel_left {b c : α} : (∀ {a}, a = b ↔ a = c) ↔ b = c 
Arguments: {α : Sort u_1} {b c : α}
Goal: (∀ {a : α}, a = b ↔ a = c) ↔ b = c
-- eq_iff_eq_cancel_right
@[simp] theorem eq_iff_eq_cancel_right {a b : α} : (∀ {c}, a = c ↔ b = c) ↔ a = b 
Arguments: {α : Sort u_1} {a b : α}
Goal: (∀ {c : α}, a = c ↔ b = c) ↔ a = b
-- ne_and_eq_iff_right
lemma ne_and_eq_iff_right {a b c : α} (h : b ≠ c) : a ≠ b ∧ a = c ↔ a = c 
Arguments: {α : Sort u_1} {a b c : α} (h : b ≠ c)
Goal: a ≠ b ∧ a = c ↔ a = c
-- Fact.out
class Fact (p : Prop) : Prop where
    out : p
Arguments: {p : Prop} [self : Fact p]
Goal: p
-- Fact.elim
theorem Fact.elim {p : Prop} (h : Fact p) : p 
Arguments: {p : Prop} (h : Fact p)
Goal: p
-- fact_iff
theorem fact_iff {p : Prop} : Fact p ↔ p 
Arguments: {p : Prop}
Goal: Fact p ↔ p
-- imp_iff_right_iff
theorem imp_iff_right_iff {a b : Prop} : (a → b ↔ b) ↔ a ∨ b 
Arguments: {a b : Prop}
Goal: (a → b ↔ b) ↔ a ∨ b
-- and_or_imp
theorem and_or_imp {a b c : Prop} : a ∧ b ∨ (a → c) ↔ a → b ∨ c 
Arguments: {a b c : Prop}
Goal: a ∧ b ∨ (a → c) ↔ a → b ∨ c
-- Function.mt
protected theorem Function.mt {a b : Prop} : (a → b) → ¬b → ¬a 
Arguments: {a b : Prop}
Goal: (a → b) → ¬b → ¬a
-- dec_em'
theorem dec_em' (p : Prop) [Decidable p] : ¬p ∨ p 
Arguments: (p : Prop) [Decidable p]
Goal: ¬p ∨ p
-- em'
theorem em' (p : Prop) : ¬p ∨ p 
Arguments: (p : Prop)
Goal: ¬p ∨ p
-- or_not
theorem or_not {p : Prop} : p ∨ ¬p 
Arguments: {p : Prop}
Goal: p ∨ ¬p
-- Decidable.eq_or_ne
theorem Decidable.eq_or_ne {α : Sort*} (x y : α) [Decidable (x = y)] : x = y ∨ x ≠ y 
Arguments: {α : Sort u_1} (x y : α) [Decidable (x = y)]
Goal: x = y ∨ x ≠ y
-- Decidable.ne_or_eq
theorem Decidable.ne_or_eq {α : Sort*} (x y : α) [Decidable (x = y)] : x ≠ y ∨ x = y 
Arguments: {α : Sort u_1} (x y : α) [Decidable (x = y)]
Goal: x ≠ y ∨ x = y
-- eq_or_ne
theorem eq_or_ne {α : Sort*} (x y : α) : x = y ∨ x ≠ y 
Arguments: {α : Sort u_1} (x y : α)
Goal: x = y ∨ x ≠ y
-- ne_or_eq
theorem ne_or_eq {α : Sort*} (x y : α) : x ≠ y ∨ x = y 
Arguments: {α : Sort u_1} (x y : α)
Goal: x ≠ y ∨ x = y
-- by_contradiction
theorem by_contradiction {p : Prop} : (¬p → False) → p 
Arguments: {p : Prop}
Goal: (¬p → False) → p
-- by_cases
theorem by_cases {p q : Prop} (hpq : p → q) (hnpq : ¬p → q) : q 
Arguments: {p q : Prop} (hpq : p → q) (hnpq : ¬p → q)
Goal: q
-- of_not_not
theorem of_not_not {a : Prop} : ¬¬a → a 
Arguments: {a : Prop}
Goal: ¬¬a → a
-- not_ne_iff
theorem not_ne_iff {α : Sort*} {a b : α} : ¬a ≠ b ↔ a = b 
Arguments: {α : Sort u_1} {a b : α}
Goal: ¬a ≠ b ↔ a = b
-- of_not_imp
theorem of_not_imp : ¬(a → b) → a 
Arguments: {a b : Prop}
Goal: ¬(a → b) → a
-- Not.imp_symm
theorem Not.imp_symm : (¬a → b) → ¬b → a 
Arguments: {a b : Prop}
Goal: (¬a → b) → ¬b → a
-- not_imp_comm
theorem not_imp_comm : ¬a → b ↔ ¬b → a 
Arguments: {a b : Prop}
Goal: ¬a → b ↔ ¬b → a
-- not_imp_self
@[simp] theorem not_imp_self : ¬a → a ↔ a 
Arguments: {a : Prop}
Goal: ¬a → a ↔ a
-- Imp.swap
theorem Imp.swap {a b : Sort*} {c : Prop} : a → b → c ↔ b → a → c 
Arguments: {a : Sort u_1} {b : Sort u_2} {c : Prop}
Goal: a → b → c ↔ b → a → c
-- Iff.not_left
theorem Iff.not_left (h : a ↔ ¬b) : ¬a ↔ b 
Arguments: {a b : Prop} (h : a ↔ ¬b)
Goal: ¬a ↔ b
-- Iff.not_right
theorem Iff.not_right (h : ¬a ↔ b) : a ↔ ¬b 
Arguments: {a b : Prop} (h : ¬a ↔ b)
Goal: a ↔ ¬b
-- Iff.ne
protected lemma Iff.ne {α β : Sort*} {a b : α} {c d : β} : (a = b ↔ c = d) → (a ≠ b ↔ c ≠ d) 
Arguments: {α : Sort u_1} {β : Sort u_2} {a b : α} {c d : β}
Goal: (a = b ↔ c = d) → (a ≠ b ↔ c ≠ d)
-- Iff.ne_left
lemma Iff.ne_left {α β : Sort*} {a b : α} {c d : β} : (a = b ↔ c ≠ d) → (a ≠ b ↔ c = d) 
Arguments: {α : Sort u_1} {β : Sort u_2} {a b : α} {c d : β}
Goal: (a = b ↔ c ≠ d) → (a ≠ b ↔ c = d)
-- Iff.ne_right
lemma Iff.ne_right {α β : Sort*} {a b : α} {c d : β} : (a ≠ b ↔ c = d) → (a = b ↔ c ≠ d) 
Arguments: {α : Sort u_1} {β : Sort u_2} {a b : α} {c d : β}
Goal: (a ≠ b ↔ c = d) → (a = b ↔ c ≠ d)
-- xor_true
@[simp] theorem xor_true : Xor' True = Not 
Goal: Xor' True = Not
-- xor_false
@[simp] theorem xor_false : Xor' False = id 
Goal: Xor' False = id
-- xor_comm
theorem xor_comm (a b : Prop) : Xor' a b = Xor' b a 
Arguments: (a b : Prop)
Goal: Xor' a b = Xor' b a
-- xor_self
@[simp] theorem xor_self (a : Prop) : Xor' a a = False 
Arguments: (a : Prop)
Goal: Xor' a a = False
-- xor_not_left
@[simp] theorem xor_not_left : Xor' (¬a) b ↔ (a ↔ b) 
Arguments: {a b : Prop}
Goal: Xor' (¬a) b ↔ (a ↔ b)
-- xor_not_right
@[simp] theorem xor_not_right : Xor' a (¬b) ↔ (a ↔ b) 
Arguments: {a b : Prop}
Goal: Xor' a ¬b ↔ (a ↔ b)
-- xor_not_not
theorem xor_not_not : Xor' (¬a) (¬b) ↔ Xor' a b 
Arguments: {a b : Prop}
Goal: Xor' (¬a) ¬b ↔ Xor' a b
-- Xor'.or
protected theorem Xor'.or (h : Xor' a b) : a ∨ b 
Arguments: {a b : Prop} (h : Xor' a b)
Goal: a ∨ b
-- and_symm_right
theorem and_symm_right {α : Sort*} (a b : α) (p : Prop) : p ∧ a = b ↔ p ∧ b = a 
Arguments: {α : Sort u_1} (a b : α) (p : Prop)
Goal: p ∧ a = b ↔ p ∧ b = a
-- and_symm_left
theorem and_symm_left {α : Sort*} (a b : α) (p : Prop) : a = b ∧ p ↔ b = a ∧ p 
Arguments: {α : Sort u_1} (a b : α) (p : Prop)
Goal: a = b ∧ p ↔ b = a ∧ p
-- Or.elim3
theorem Or.elim3 {c d : Prop} (h : a ∨ b ∨ c) (ha : a → d) (hb : b → d) (hc : c → d) : d 
Arguments: {a b c d : Prop} (h : a ∨ b ∨ c) (ha : a → d) (hb : b → d) (hc : c → d)
Goal: d
-- Or.imp3
theorem Or.imp3 {d e c f : Prop} (had : a → d) (hbe : b → e) (hcf : c → f) :
    a ∨ b ∨ c → d ∨ e ∨ f 
Arguments: {a b d e c f : Prop} (had : a → d) (hbe : b → e) (hcf : c → f)
Goal: a ∨ b ∨ c → d ∨ e ∨ f
-- not_or_of_imp
theorem not_or_of_imp : (a → b) → ¬a ∨ b 
Arguments: {a b : Prop}
Goal: (a → b) → ¬a ∨ b
-- Decidable.or_not_of_imp
protected theorem Decidable.or_not_of_imp [Decidable a] (h : a → b) : b ∨ ¬a 
Arguments: {a b : Prop} [Decidable a] (h : a → b)
Goal: b ∨ ¬a
-- or_not_of_imp
theorem or_not_of_imp : (a → b) → b ∨ ¬a 
Arguments: {a b : Prop}
Goal: (a → b) → b ∨ ¬a
-- imp_iff_not_or
theorem imp_iff_not_or : a → b ↔ ¬a ∨ b 
Arguments: {a b : Prop}
Goal: a → b ↔ ¬a ∨ b
-- imp_iff_or_not
theorem imp_iff_or_not {b a : Prop} : b → a ↔ a ∨ ¬b 
Arguments: {b a : Prop}
Goal: b → a ↔ a ∨ ¬b
-- not_imp_not
theorem not_imp_not : ¬a → ¬b ↔ b → a 
Arguments: {a b : Prop}
Goal: ¬a → ¬b ↔ b → a
-- imp_and_neg_imp_iff
theorem imp_and_neg_imp_iff (p q : Prop) : (p → q) ∧ (¬p → q) ↔ q 
Arguments: (p q : Prop)
Goal: (p → q) ∧ (¬p → q) ↔ q
-- Function.mtr
protected theorem Function.mtr : (¬a → ¬b) → b → a 
Arguments: {a b : Prop}
Goal: (¬a → ¬b) → b → a
-- or_congr_left'
theorem or_congr_left' {c a b : Prop} (h : ¬c → (a ↔ b)) : a ∨ c ↔ b ∨ c 
Arguments: {c a b : Prop} (h : ¬c → (a ↔ b))
Goal: a ∨ c ↔ b ∨ c
-- or_congr_right'
theorem or_congr_right' {c : Prop} (h : ¬a → (b ↔ c)) : a ∨ b ↔ a ∨ c 
Arguments: {a b c : Prop} (h : ¬a → (b ↔ c))
Goal: a ∨ b ↔ a ∨ c
-- iff_mpr_iff_true_intro
theorem iff_mpr_iff_true_intro {P : Prop} (h : P) : Iff.mpr (iff_true_intro h) True.intro = h 
Arguments: {P : Prop} (h : P)
Goal: ⋯ = h
-- imp_or
theorem imp_or {a b c : Prop} : a → b ∨ c ↔ (a → b) ∨ (a → c) 
Arguments: {a b c : Prop}
Goal: a → b ∨ c ↔ (a → b) ∨ (a → c)
-- imp_or'
theorem imp_or' {a : Sort*} {b c : Prop} : a → b ∨ c ↔ (a → b) ∨ (a → c) 
Arguments: {a : Sort u_1} {b c : Prop}
Goal: a → b ∨ c ↔ (a → b) ∨ (a → c)
-- not_imp
theorem not_imp : ¬(a → b) ↔ a ∧ ¬b 
Arguments: {a b : Prop}
Goal: ¬(a → b) ↔ a ∧ ¬b
-- peirce
theorem peirce (a b : Prop) : ((a → b) → a) → a 
Arguments: (a b : Prop)
Goal: ((a → b) → a) → a
-- not_iff_not
theorem not_iff_not : (¬a ↔ ¬b) ↔ (a ↔ b) 
Arguments: {a b : Prop}
Goal: (¬a ↔ ¬b) ↔ (a ↔ b)
-- not_iff_comm
theorem not_iff_comm : (¬a ↔ b) ↔ (¬b ↔ a) 
Arguments: {a b : Prop}
Goal: (¬a ↔ b) ↔ (¬b ↔ a)
-- not_iff
theorem not_iff : ¬(a ↔ b) ↔ (¬a ↔ b) 
Arguments: {a b : Prop}
Goal: ¬(a ↔ b) ↔ (¬a ↔ b)
-- iff_not_comm
theorem iff_not_comm : (a ↔ ¬b) ↔ (b ↔ ¬a) 
Arguments: {a b : Prop}
Goal: (a ↔ ¬b) ↔ (b ↔ ¬a)
-- iff_iff_and_or_not_and_not
theorem iff_iff_and_or_not_and_not : (a ↔ b) ↔ a ∧ b ∨ ¬a ∧ ¬b 
Arguments: {a b : Prop}
Goal: (a ↔ b) ↔ a ∧ b ∨ ¬a ∧ ¬b
-- iff_iff_not_or_and_or_not
theorem iff_iff_not_or_and_or_not : (a ↔ b) ↔ (¬a ∨ b) ∧ (a ∨ ¬b) 
Arguments: {a b : Prop}
Goal: (a ↔ b) ↔ (¬a ∨ b) ∧ (a ∨ ¬b)
-- not_and_not_right
theorem not_and_not_right : ¬(a ∧ ¬b) ↔ a → b 
Arguments: {a b : Prop}
Goal: ¬(a ∧ ¬b) ↔ a → b
-- not_and_or
theorem not_and_or : ¬(a ∧ b) ↔ ¬a ∨ ¬b 
Arguments: {a b : Prop}
Goal: ¬(a ∧ b) ↔ ¬a ∨ ¬b
-- or_iff_not_and_not
theorem or_iff_not_and_not : a ∨ b ↔ ¬(¬a ∧ ¬b) 
Arguments: {a b : Prop}
Goal: a ∨ b ↔ ¬(¬a ∧ ¬b)
-- and_iff_not_or_not
theorem and_iff_not_or_not : a ∧ b ↔ ¬(¬a ∨ ¬b) 
Arguments: {a b : Prop}
Goal: a ∧ b ↔ ¬(¬a ∨ ¬b)
-- not_xor
@[simp] theorem not_xor (P Q : Prop) : ¬Xor' P Q ↔ (P ↔ Q) 
Arguments: (P Q : Prop)
Goal: ¬Xor' P Q ↔ (P ↔ Q)
-- xor_iff_not_iff
theorem xor_iff_not_iff (P Q : Prop) : Xor' P Q ↔ ¬ (P ↔ Q) 
Arguments: (P Q : Prop)
Goal: Xor' P Q ↔ ¬(P ↔ Q)
-- xor_iff_iff_not
theorem xor_iff_iff_not : Xor' a b ↔ (a ↔ ¬b) 
Arguments: {a b : Prop}
Goal: Xor' a b ↔ (a ↔ ¬b)
-- xor_iff_not_iff'
theorem xor_iff_not_iff' : Xor' a b ↔ (¬a ↔ b) 
Arguments: {a b : Prop}
Goal: Xor' a b ↔ (¬a ↔ b)
-- forall_cond_comm
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 
Arguments: {α : Sort u_1} {s : α → Prop} {p : α → α → Prop}
Goal: (∀ (a : α), s a → ∀ (b : α), s b → p a b) ↔ ∀ (a b : α), s a → s b → p a b
-- forall_mem_comm
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 
Arguments: {α : Type u_1} {β : Type u_2} [Membership α β] {s : β} {p : α → α → Prop}
Goal: (∀ (a : α), a ∈ s → ∀ (b : α), b ∈ s → p a b) ↔ ∀ (a b : α), a ∈ s → b ∈ s → p a b
-- ne_of_eq_of_ne
lemma ne_of_eq_of_ne {α : Sort*} {a b c : α} (h₁ : a = b) (h₂ : b ≠ c) : a ≠ c 
Arguments: {α : Sort u_1} {a b c : α} (h₁ : a = b) (h₂ : b ≠ c)
Goal: a ≠ c
-- ne_of_ne_of_eq
lemma ne_of_ne_of_eq {α : Sort*} {a b c : α} (h₁ : a ≠ b) (h₂ : b = c) : a ≠ c 
Arguments: {α : Sort u_1} {a b c : α} (h₁ : a ≠ b) (h₂ : b = c)
Goal: a ≠ c
-- eq_equivalence
theorem eq_equivalence {α : Sort*} : Equivalence (@Eq α) 
Arguments: {α : Sort u_1}
Goal: Equivalence Eq
-- congr_refl_left
theorem congr_refl_left {α β : Sort*} (f : α → β) {a b : α} (h : a = b) :
    congr (Eq.refl f) h = congr_arg f h 
Arguments: {α : Sort u_1} {β : Sort u_2} (f : α → β) {a b : α} (h : a = b)
Goal: ⋯ = ⋯
-- congr_refl_right
theorem congr_refl_right {α β : Sort*} {f g : α → β} (h : f = g) (a : α) :
    congr h (Eq.refl a) = congr_fun h a 
Arguments: {α : Sort u_1} {β : Sort u_2} {f g : α → β} (h : f = g) (a : α)
Goal: ⋯ = ⋯
-- congr_arg_refl
theorem congr_arg_refl {α β : Sort*} (f : α → β) (a : α) :
    congr_arg f (Eq.refl a) = Eq.refl (f a) 
Arguments: {α : Sort u_1} {β : Sort u_2} (f : α → β) (a : α)
Goal: ⋯ = ⋯
-- congr_fun_rfl
theorem congr_fun_rfl {α β : Sort*} (f : α → β) (a : α) : congr_fun (Eq.refl f) a = Eq.refl (f a) 
Arguments: {α : Sort u_1} {β : Sort u_2} (f : α → β) (a : α)
Goal: ⋯ = ⋯
-- congr_fun_congr_arg
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 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (f : α → β → γ) {a a' : α} (p : a = a') (b : β)
Goal: ⋯ = ⋯
-- Eq.rec_eq_cast
theorem Eq.rec_eq_cast {α : Sort _} {P : α → Sort _} {x y : α} (h : x = y) (z : P x) :
    h ▸ z = cast (congr_arg P h) z 
Arguments: {α : Sort u_1} {P : α → Sort u_2} {x y : α} (h : x = y) (z : P x)
Goal: h ▸ z = cast ⋯ z
-- eqRec_heq'
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 
Arguments: {α : Sort u_1} {a' : α} {motive : (a : α) → a' = a → Sort u_2} (p : motive a' ⋯) {a : α} (t : a' = a)
Goal: HEq (t ▸ p) p
-- rec_heq_of_heq
theorem rec_heq_of_heq {C : α → Sort*} {x : C a} {y : β} (e : a = b) (h : HEq x y) :
    HEq (e ▸ x) y 
Arguments: {α : Sort u_2} {a : α} {β : Sort u_1} {b : α} {C : α → Sort u_1} {x : C a} {y : β} (e : a = b) (h : HEq x y)
Goal: HEq (e ▸ x) y
-- rec_heq_iff_heq
theorem rec_heq_iff_heq {C : α → Sort*} {x : C a} {y : β} {e : a = b} :
    HEq (e ▸ x) y ↔ HEq x y 
Arguments: {α : Sort u_2} {a : α} {β : Sort u_1} {b : α} {C : α → Sort u_1} {x : C a} {y : β} {e : a = b}
Goal: HEq (e ▸ x) y ↔ HEq x y
-- heq_rec_iff_heq
theorem heq_rec_iff_heq {C : α → Sort*} {x : β} {y : C a} {e : a = b} :
    HEq x (e ▸ y) ↔ HEq x y 
Arguments: {α : Sort u_2} {β : Sort u_1} {a b : α} {C : α → Sort u_1} {x : β} {y : C a} {e : a = b}
Goal: HEq x (e ▸ y) ↔ HEq x y
-- pi_congr
theorem pi_congr {β' : α → Sort _} (h : ∀ a, β a = β' a) : (∀ a, β a) = ∀ a, β' a 
Arguments: {α : Sort u_1} {β β' : α → Sort u_2} (h : ∀ (a : α), β a = β' a)
Goal: ((a : α) → β a) = ((a : α) → β' a)
-- forall₂_imp
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 
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 : β a), p a b) → ∀ (a : α) (b : β a), q a b