ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- LawfulSingleton.insert_emptyc_eq
class LawfulSingleton (α : Type u) (β : Type v) [EmptyCollection β] [Insert α β] [Singleton α β] :
    Prop where
    insert_emptyc_eq (x : α) : (insert x ∅ : β) = singleton x
Arguments: {α : Type u} {β : Type v} [EmptyCollection β] [Insert α β] [Singleton α β] [self : LawfulSingleton α β] (x : α)
Goal: insert x ∅ = singleton x
-- Nat.add_zero
@[simp] protected theorem Nat.add_zero (n : Nat) : n + 0 = n 
Arguments: (n : Nat)
Goal: n + 0 = n
-- optParam_eq
theorem optParam_eq (α : Sort u) (default : α) : optParam α default = α 
Arguments: (α : Sort u) (default : α)
Goal: optParam α default = α
-- LawfulBEq.rfl
class LawfulBEq (α : Type u) [BEq α] : Prop where
    eq_of_beq : {a b : α} → a == b → a = b
    protected rfl : {a : α} → a == a
Arguments: {α : Type u} [BEq α] [self : LawfulBEq α] {a : α}
Goal: (a == a) = true
-- LawfulBEq.eq_of_beq
class LawfulBEq (α : Type u) [BEq α] : Prop where
    eq_of_beq : {a b : α} → a == b → a = b
    protected rfl : {a : α} → a == a
Arguments: {α : Type u} [BEq α] [self : LawfulBEq α] {a b : α}
Goal: (a == b) = true → a = b
-- trivial
@[inherit_doc True.intro] theorem trivial : True 
Goal: True
-- mt
theorem mt {a b : Prop} (h₁ : a → b) (h₂ : ¬b) : ¬a 
Arguments: {a b : Prop} (h₁ : a → b) (h₂ : ¬b)
Goal: ¬a
-- not_false
theorem not_false : ¬False 
Goal: ¬False
-- not_not_intro
theorem not_not_intro {p : Prop} (h : p) : ¬ ¬ p 
Arguments: {p : Prop} (h : p)
Goal: ¬¬p
-- proof_irrel
theorem proof_irrel {a : Prop} (h₁ h₂ : a) : h₁ = h₂ 
Arguments: {a : Prop} (h₁ h₂ : a)
Goal: h₁ = h₂
-- Eq.substr
@[elab_as_elim]
theorem Eq.substr {α : Sort u} {p : α → Prop} {a b : α} (h₁ : b = a) (h₂ : p a) : p b 
Arguments: {α : Sort u} {p : α → Prop} {a b : α} (h₁ : b = a) (h₂ : p a)
Goal: p b
-- cast_eq
@[simp] theorem cast_eq {α : Sort u} (h : α = α) (a : α) : cast h a = a 
Arguments: {α : Sort u} (h : α = α) (a : α)
Goal: cast h a = a
-- Ne.intro
theorem Ne.intro (h : a = b → False) : a ≠ b 
Arguments: {α : Sort u} {a b : α} (h : a = b → False)
Goal: a ≠ b
-- Ne.elim
theorem Ne.elim (h : a ≠ b) : a = b → False 
Arguments: {α : Sort u} {a b : α} (h : a ≠ b)
Goal: a = b → False
-- Ne.irrefl
theorem Ne.irrefl (h : a ≠ a) : False 
Arguments: {α : Sort u} {a : α} (h : a ≠ a)
Goal: False
-- Ne.symm
theorem Ne.symm (h : a ≠ b) : b ≠ a 
Arguments: {α : Sort u} {a b : α} (h : a ≠ b)
Goal: b ≠ a
-- ne_comm
theorem ne_comm {α} {a b : α} : a ≠ b ↔ b ≠ a 
Arguments: {α : Sort u_1} {a b : α}
Goal: a ≠ b ↔ b ≠ a
-- false_of_ne
theorem false_of_ne : a ≠ a → False 
Arguments: {α : Sort u} {a : α}
Goal: a ≠ a → False
-- ne_false_of_self
theorem ne_false_of_self : p → p ≠ False 
Arguments: {p : Prop}
Goal: p → p ≠ False
-- ne_true_of_not
theorem ne_true_of_not : ¬p → p ≠ True 
Arguments: {p : Prop}
Goal: ¬p → p ≠ True
-- true_ne_false
theorem true_ne_false : ¬True = False 
Goal: ¬True = False
-- false_ne_true
theorem false_ne_true : False ≠ True 
Goal: False ≠ True
-- Bool.of_not_eq_true
theorem Bool.of_not_eq_true : {b : Bool} → ¬ (b = true) → b = false
  
Arguments: {b : Bool}
Goal: ¬b = true → b = false
-- Bool.of_not_eq_false
theorem Bool.of_not_eq_false : {b : Bool} → ¬ (b = false) → b = true
  
Arguments: {b : Bool}
Goal: ¬b = false → b = true
-- ne_of_beq_false
theorem ne_of_beq_false [BEq α] [LawfulBEq α] {a b : α} (h : (a == b) = false) : a ≠ b 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {a b : α} (h : (a == b) = false)
Goal: a ≠ b
-- beq_false_of_ne
theorem beq_false_of_ne [BEq α] [LawfulBEq α] {a b : α} (h : a ≠ b) : (a == b) = false 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {a b : α} (h : a ≠ b)
Goal: (a == b) = false
-- HEq.subst
theorem HEq.subst {p : (T : Sort u) → T → Prop} (h₁ : HEq a b) (h₂ : p α a) : p β b 
Arguments: {α β : Sort u} {a : α} {b : β} {p : (T : Sort u) → T → Prop} (h₁ : HEq a b) (h₂ : p α a)
Goal: p β b
-- HEq.symm
theorem HEq.symm (h : HEq a b) : HEq b a 
Arguments: {α β : Sort u} {a : α} {b : β} (h : HEq a b)
Goal: HEq b a
-- heq_of_eq
theorem heq_of_eq (h : a = a') : HEq a a' 
Arguments: {α : Sort u} {a a' : α} (h : a = a')
Goal: HEq a a'
-- HEq.trans
theorem HEq.trans (h₁ : HEq a b) (h₂ : HEq b c) : HEq a c 
Arguments: {α β φ : Sort u} {a : α} {b : β} {c : φ} (h₁ : HEq a b) (h₂ : HEq b c)
Goal: HEq a c
-- heq_of_heq_of_eq
theorem heq_of_heq_of_eq (h₁ : HEq a b) (h₂ : b = b') : HEq a b' 
Arguments: {α β : Sort u} {a : α} {b b' : β} (h₁ : HEq a b) (h₂ : b = b')
Goal: HEq a b'
-- heq_of_eq_of_heq
theorem heq_of_eq_of_heq (h₁ : a = a') (h₂ : HEq a' b) : HEq a b 
Arguments: {α β : Sort u} {a a' : α} {b : β} (h₁ : a = a') (h₂ : HEq a' b)
Goal: HEq a b
-- type_eq_of_heq
theorem type_eq_of_heq (h : HEq a b) : α = β 
Arguments: {α β : Sort u} {a : α} {b : β} (h : HEq a b)
Goal: α = β
-- eqRec_heq
theorem eqRec_heq {α : Sort u} {φ : α → Sort v} {a a' : α} : (h : a = a') → (p : φ a) → HEq (Eq.recOn (motive := fun x _ => φ x) h p) p
  
Arguments: {α : Sort u} {φ : α → Sort v} {a a' : α} (h : a = a') (p : φ a)
Goal: HEq (Eq.recOn h p) p
-- heq_of_eqRec_eq
theorem heq_of_eqRec_eq {α β : Sort u} {a : α} {b : β} (h₁ : α = β) (h₂ : Eq.rec (motive := fun α _ => α) a h₁ = b) : HEq a b 
Arguments: {α β : Sort u} {a : α} {b : β} (h₁ : α = β) (h₂ : Eq.rec a h₁ = b)
Goal: HEq a b
-- cast_heq
theorem cast_heq {α β : Sort u} : (h : α = β) → (a : α) → HEq (cast h a) a
  
Arguments: {α β : Sort u} (h : α = β) (a : α)
Goal: HEq (cast h a) a
-- iff_iff_implies_and_implies
theorem iff_iff_implies_and_implies (a b : Prop) : (a ↔ b) ↔ (a → b) ∧ (b → a) 
Arguments: (a b : Prop)
Goal: (a ↔ b) ↔ (a → b) ∧ (b → a)
-- Iff.refl
theorem Iff.refl (a : Prop) : a ↔ a 
Arguments: (a : Prop)
Goal: a ↔ a
-- Iff.rfl
protected theorem Iff.rfl {a : Prop} : a ↔ a 
Arguments: {a : Prop}
Goal: a ↔ a
-- Iff.of_eq
theorem Iff.of_eq (h : a = b) : a ↔ b 
Arguments: {a b : Prop} (h : a = b)
Goal: a ↔ b
-- Iff.trans
theorem Iff.trans (h₁ : a ↔ b) (h₂ : b ↔ c) : a ↔ c 
Arguments: {a b c : Prop} (h₁ : a ↔ b) (h₂ : b ↔ c)
Goal: a ↔ c
-- Eq.comm
theorem Eq.comm {a b : α} : a = b ↔ b = a 
Arguments: {α : Sort u_1} {a b : α}
Goal: a = b ↔ b = a
-- eq_comm
theorem eq_comm {a b : α} : a = b ↔ b = a 
Arguments: {α : Sort u_1} {a b : α}
Goal: a = b ↔ b = a
-- Iff.symm
theorem Iff.symm (h : a ↔ b) : b ↔ a 
Arguments: {a b : Prop} (h : a ↔ b)
Goal: b ↔ a
-- Iff.comm
theorem Iff.comm: (a ↔ b) ↔ (b ↔ a) 
Arguments: {a b : Prop}
Goal: (a ↔ b) ↔ (b ↔ a)
-- iff_comm
theorem iff_comm : (a ↔ b) ↔ (b ↔ a) 
Arguments: {a b : Prop}
Goal: (a ↔ b) ↔ (b ↔ a)
-- And.symm
theorem And.symm : a ∧ b → b ∧ a 
Arguments: {a b : Prop}
Goal: a ∧ b → b ∧ a
-- And.comm
theorem And.comm : a ∧ b ↔ b ∧ a 
Arguments: {a b : Prop}
Goal: a ∧ b ↔ b ∧ a
-- and_comm
theorem and_comm : a ∧ b ↔ b ∧ a 
Arguments: {a b : Prop}
Goal: a ∧ b ↔ b ∧ a
-- Or.symm
theorem Or.symm : a ∨ b → b ∨ a 
Arguments: {a b : Prop}
Goal: a ∨ b → b ∨ a
-- Or.comm
theorem Or.comm : a ∨ b ↔ b ∨ a 
Arguments: {a b : Prop}
Goal: a ∨ b ↔ b ∨ a
-- or_comm
theorem or_comm : a ∨ b ↔ b ∨ a 
Arguments: {a b : Prop}
Goal: a ∨ b ↔ b ∨ a
-- Exists.elim
theorem Exists.elim {α : Sort u} {p : α → Prop} {b : Prop}
   (h₁ : Exists (fun x => p x)) (h₂ : ∀ (a : α), p a → b) : b 
Arguments: {α : Sort u} {p : α → Prop} {b : Prop} (h₁ : Exists fun x => p x) (h₂ : ∀ (a : α), p a → b)
Goal: b
-- decide_true_eq_true
theorem decide_true_eq_true (h : Decidable True) : @decide True h = true 
Arguments: (h : Decidable True)
Goal: decide True = true
-- decide_false_eq_false
theorem decide_false_eq_false (h : Decidable False) : @decide False h = false 
Arguments: (h : Decidable False)
Goal: decide False = false
-- toBoolUsing_eq_true
theorem toBoolUsing_eq_true {p : Prop} (d : Decidable p) (h : p) : toBoolUsing d = true 
Arguments: {p : Prop} (d : Decidable p) (h : p)
Goal: toBoolUsing d = true
-- ofBoolUsing_eq_true
theorem ofBoolUsing_eq_true {p : Prop} {d : Decidable p} (h : toBoolUsing d = true) : p 
Arguments: {p : Prop} {d : Decidable p} (h : toBoolUsing d = true)
Goal: p
-- ofBoolUsing_eq_false
theorem ofBoolUsing_eq_false {p : Prop} {d : Decidable p} (h : toBoolUsing d = false) : ¬ p 
Arguments: {p : Prop} {d : Decidable p} (h : toBoolUsing d = false)
Goal: ¬p
-- Decidable.em
theorem em (p : Prop) [Decidable p] : p ∨ ¬p 
Arguments: (p : Prop) [Decidable p]
Goal: p ∨ ¬p
-- Decidable.byContradiction
theorem byContradiction [dec : Decidable p] (h : ¬p → False) : p 
Arguments: {p : Prop} [dec : Decidable p] (h : ¬p → False)
Goal: p
-- Decidable.of_not_not
theorem of_not_not [Decidable p] : ¬ ¬ p → p 
Arguments: {p : Prop} [Decidable p]
Goal: ¬¬p → p
-- Decidable.not_and_iff_or_not
theorem not_and_iff_or_not (p q : Prop) [d₁ : Decidable p] [d₂ : Decidable q] : ¬ (p ∧ q) ↔ ¬ p ∨ ¬ q 
Arguments: (p q : Prop) [d₁ : Decidable p] [d₂ : Decidable q]
Goal: ¬(p ∧ q) ↔ ¬p ∨ ¬q
-- if_pos
theorem if_pos {c : Prop} {h : Decidable c} (hc : c) {α : Sort u} {t e : α} : (ite c t e) = t 
Arguments: {c : Prop} {h : Decidable c} (hc : c) {α : Sort u} {t e : α}
Goal: ite c t e = t
-- if_neg
theorem if_neg {c : Prop} {h : Decidable c} (hnc : ¬c) {α : Sort u} {t e : α} : (ite c t e) = e 
Arguments: {c : Prop} {h : Decidable c} (hnc : ¬c) {α : Sort u} {t e : α}
Goal: ite c t e = e
-- dif_pos
theorem dif_pos {c : Prop} {h : Decidable c} (hc : c) {α : Sort u} {t : c → α} {e : ¬ c → α} : (dite c t e) = t hc 
Arguments: {c : Prop} {h : Decidable c} (hc : c) {α : Sort u} {t : c → α} {e : ¬c → α}
Goal: dite c t e = t hc
-- dif_neg
theorem dif_neg {c : Prop} {h : Decidable c} (hnc : ¬c) {α : Sort u} {t : c → α} {e : ¬ c → α} : (dite c t e) = e hnc 
Arguments: {c : Prop} {h : Decidable c} (hnc : ¬c) {α : Sort u} {t : c → α} {e : ¬c → α}
Goal: dite c t e = e hnc
-- dif_eq_if
theorem dif_eq_if (c : Prop) {h : Decidable c} {α : Sort u} (t : α) (e : α) : dite c (fun _ => t) (fun _ => e) = ite c t e 
Arguments: (c : Prop) {h : Decidable c} {α : Sort u} (t e : α)
Goal: (if x : c then t else e) = ite c t e
-- nonempty_of_exists
theorem nonempty_of_exists {α : Sort u} {p : α → Prop} : Exists (fun x => p x) → Nonempty α
  
Arguments: {α : Sort u} {p : α → Prop}
Goal: (Exists fun x => p x) → Nonempty α
-- Subsingleton.allEq
class Subsingleton (α : Sort u) : Prop where
    intro ::
    allEq : (a b : α) → a = b
Arguments: {α : Sort u} [self : Subsingleton α] (a b : α)
Goal: a = b
-- Subsingleton.elim
protected theorem Subsingleton.elim {α : Sort u} [h : Subsingleton α] : (a b : α) → a = b 
Arguments: {α : Sort u} [h : Subsingleton α] (a b : α)
Goal: a = b
-- Subsingleton.helim
protected theorem Subsingleton.helim {α β : Sort u} [h₁ : Subsingleton α] (h₂ : α = β) (a : α) (b : β) : HEq a b 
Arguments: {α β : Sort u} [h₁ : Subsingleton α] (h₂ : α = β) (a : α) (b : β)
Goal: HEq a b
-- recSubsingleton
theorem recSubsingleton
     {p : Prop} [h : Decidable p]
     {h₁ : p → Sort u}
     {h₂ : ¬p → Sort u}
     [h₃ : ∀ (h : p), Subsingleton (h₁ h)]
     [h₄ : ∀ (h : ¬p), Subsingleton (h₂ h)]
     : Subsingleton (h.casesOn h₂ h₁) 
Arguments: {p : Prop} [h : Decidable p] {h₁ : p → Sort u} {h₂ : ¬p → Sort u} [h₃ : ∀ (h : p), Subsingleton (h₁ h)] [h₄ : ∀ (h : ¬p), Subsingleton (h₂ h)]
Goal: Subsingleton (Decidable.casesOn h h₂ h₁)
-- Equivalence.trans
structure Equivalence {α : Sort u} (r : α → α → Prop) : Prop where
    refl  : ∀ x, r x x
    symm  : ∀ {x y}, r x y → r y x
    trans : ∀ {x y z}, r x y → r y z → r x z
Arguments: {α : Sort u} {r : α → α → Prop} (self : Equivalence r) {x y z : α}
Goal: r x y → r y z → r x z
-- Equivalence.refl
structure Equivalence {α : Sort u} (r : α → α → Prop) : Prop where
    refl  : ∀ x, r x x
    symm  : ∀ {x y}, r x y → r y x
    trans : ∀ {x y z}, r x y → r y z → r x z
Arguments: {α : Sort u} {r : α → α → Prop} (self : Equivalence r) (x : α)
Goal: r x x
-- Equivalence.symm
structure Equivalence {α : Sort u} (r : α → α → Prop) : Prop where
    refl  : ∀ x, r x x
    symm  : ∀ {x y}, r x y → r y x
    trans : ∀ {x y z}, r x y → r y z → r x z
Arguments: {α : Sort u} {r : α → α → Prop} (self : Equivalence r) {x y : α}
Goal: r x y → r y x
-- Subtype.existsOfSubtype
theorem existsOfSubtype {α : Type u} {p : α → Prop} : { x // p x } → Exists (fun x => p x)
  
Arguments: {α : Type u} {p : α → Prop}
Goal: (Subtype fun x => p x) → Exists fun x => p x
-- Subtype.eq
protected theorem eq : ∀ {a1 a2 : {x // p x}}, val a1 = val a2 → a1 = a2
  
Arguments: {α : Type u} {p : α → Prop} {a1 a2 : Subtype fun x => p x}
Goal: a1.val = a2.val → a1 = a2
-- Subtype.eta
theorem eta (a : {x // p x}) (h : p (val a)) : mk (val a) h = a 
Arguments: {α : Type u} {p : α → Prop} (a : Subtype fun x => p x) (h : p a.val)
Goal: ⟨a.val, h⟩ = a
-- Prod.lexLt_def
theorem Prod.lexLt_def [LT α] [LT β] (s t : α × β) : (Prod.lexLt s t) = (s.1 < t.1 ∨ (s.1 = t.1 ∧ s.2 < t.2)) 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] (s t : α × β)
Goal: s.lexLt t = (s.fst < t.fst ∨ s.fst = t.fst ∧ s.snd < t.snd)
-- Prod.eta
theorem Prod.eta (p : α × β) : (p.1, p.2) = p 
Arguments: {α : Type u_1} {β : Type u_2} (p : α × β)
Goal: { fst := p.fst, snd := p.snd } = p
-- Prod.map_apply
@[simp] theorem Prod.map_apply (f : α → β) (g : γ → δ) (x) (y) :
    Prod.map f g (x, y) = (f x, g y) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β) (g : γ → δ) (x : α) (y : γ)
Goal: Prod.map f g { fst := x, snd := y } = { fst := f x, snd := g y }
-- Prod.map_fst
@[simp] theorem Prod.map_fst (f : α → β) (g : γ → δ) (x) : (Prod.map f g x).1 = f x.1 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β) (g : γ → δ) (x : α × γ)
Goal: (Prod.map f g x).fst = f x.fst
-- Prod.map_snd
@[simp] theorem Prod.map_snd (f : α → β) (g : γ → δ) (x) : (Prod.map f g x).2 = g x.2 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β) (g : γ → δ) (x : α × γ)
Goal: (Prod.map f g x).snd = g x.snd
-- ex_of_PSigma
theorem ex_of_PSigma {α : Type u} {p : α → Prop} : (PSigma (fun x => p x)) → Exists (fun x => p x)
-- PSigma.eta
protected theorem PSigma.eta {α : Sort u} {β : α → Sort v} {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂}
    (h₁ : a₁ = a₂) (h₂ : Eq.ndrec b₁ h₁ = b₂) : PSigma.mk a₁ b₁ = PSigma.mk a₂ b₂ 
Arguments: {α : Sort u} {β : α → Sort v} {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂} (h₁ : a₁ = a₂) (h₂ : Eq.ndrec b₁ h₁ = b₂)
Goal: ⟨a₁, b₁⟩ = ⟨a₂, b₂⟩
-- PUnit.subsingleton
theorem PUnit.subsingleton (a b : PUnit) : a = b 
Arguments: (a b : PUnit)
Goal: a = b
-- PUnit.eq_punit
theorem PUnit.eq_punit (a : PUnit) : a = ⟨⟩ 
Arguments: (a : PUnit)
Goal: a = PUnit.unit
-- Setoid.iseqv
class Setoid (α : Sort u) where
    r : α → α → Prop
    iseqv : Equivalence r
Arguments: {α : Sort u} [self : Setoid α]
Goal: Equivalence Setoid.r
-- Setoid.refl
theorem refl (a : α) : a ≈ a 
Arguments: {α : Sort u} [Setoid α] (a : α)
Goal: a ≈ a
-- Setoid.symm
theorem symm {a b : α} (hab : a ≈ b) : b ≈ a 
Arguments: {α : Sort u} [Setoid α] {a b : α} (hab : a ≈ b)
Goal: b ≈ a
-- Setoid.trans
theorem trans {a b c : α} (hab : a ≈ b) (hbc : b ≈ c) : a ≈ c 
Arguments: {α : Sort u} [Setoid α] {a b c : α} (hab : a ≈ b) (hbc : b ≈ c)
Goal: a ≈ c
-- Eq.propIntro
theorem Eq.propIntro {a b : Prop} (h₁ : a → b) (h₂ : b → a) : a = b 
Arguments: {a b : Prop} (h₁ : a → b) (h₂ : b → a)
Goal: a = b
-- Nat.succ.inj
theorem Nat.succ.inj {m n : Nat} : m.succ = n.succ → m = n 
Arguments: {m n : Nat}
Goal: m.succ = n.succ → m = n
-- Nat.succ.injEq
theorem Nat.succ.injEq (u v : Nat) : (u.succ = v.succ) = (u = v) 
Arguments: (u v : Nat)
Goal: (u.succ = v.succ) = (u = v)
-- beq_iff_eq
@[simp] theorem beq_iff_eq [BEq α] [LawfulBEq α] (a b : α) : a == b ↔ a = b 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] (a b : α)
Goal: (a == b) = true ↔ a = b
-- Iff.subst
theorem Iff.subst {a b : Prop} {p : Prop → Prop} (h₁ : a ↔ b) (h₂ : p a) : p b 
Arguments: {a b : Prop} {p : Prop → Prop} (h₁ : a ↔ b) (h₂ : p a)
Goal: p b
-- Not.intro
theorem Not.intro {a : Prop} (h : a → False) : ¬a 
Arguments: {a : Prop} (h : a → False)
Goal: ¬a
-- Not.imp
theorem Not.imp {a b : Prop} (H2 : ¬b) (H1 : a → b) : ¬a 
Arguments: {a b : Prop} (H2 : ¬b) (H1 : a → b)
Goal: ¬a
-- not_congr
theorem not_congr (h : a ↔ b) : ¬a ↔ ¬b 
Arguments: {a b : Prop} (h : a ↔ b)
Goal: ¬a ↔ ¬b
-- not_not_not
theorem not_not_not : ¬¬¬a ↔ ¬a 
Arguments: {a : Prop}
Goal: ¬¬¬a ↔ ¬a
-- iff_of_true
theorem iff_of_true (ha : a) (hb : b) : a ↔ b 
Arguments: {a b : Prop} (ha : a) (hb : b)
Goal: a ↔ b
-- iff_of_false
theorem iff_of_false (ha : ¬a) (hb : ¬b) : a ↔ b 
Arguments: {a b : Prop} (ha : ¬a) (hb : ¬b)
Goal: a ↔ b
-- iff_true_left
theorem iff_true_left  (ha : a) : (a ↔ b) ↔ b 
Arguments: {a b : Prop} (ha : a)
Goal: (a ↔ b) ↔ b
-- iff_true_right
theorem iff_true_right (ha : a) : (b ↔ a) ↔ b 
Arguments: {a b : Prop} (ha : a)
Goal: (b ↔ a) ↔ b
-- iff_false_left
theorem iff_false_left  (ha : ¬a) : (a ↔ b) ↔ ¬b 
Arguments: {a b : Prop} (ha : ¬a)
Goal: (a ↔ b) ↔ ¬b
-- iff_false_right
theorem iff_false_right (ha : ¬a) : (b ↔ a) ↔ ¬b 
Arguments: {a b : Prop} (ha : ¬a)
Goal: (b ↔ a) ↔ ¬b
-- of_iff_true
theorem of_iff_true    (h : a ↔ True) : a 
Arguments: {a : Prop} (h : a ↔ True)
Goal: a
-- iff_true_intro
theorem iff_true_intro (h : a) : a ↔ True 
Arguments: {a : Prop} (h : a)
Goal: a ↔ True
-- not_of_iff_false
theorem not_of_iff_false : (p ↔ False) → ¬p 
Arguments: {p : Prop}
Goal: (p ↔ False) → ¬p
-- iff_false_intro
theorem iff_false_intro (h : ¬a) : a ↔ False 
Arguments: {a : Prop} (h : ¬a)
Goal: a ↔ False
-- not_iff_false_intro
theorem not_iff_false_intro (h : a) : ¬a ↔ False 
Arguments: {a : Prop} (h : a)
Goal: ¬a ↔ False
-- not_true
theorem not_true : (¬True) ↔ False 
Goal: ¬True ↔ False
-- not_false_iff
theorem not_false_iff : (¬False) ↔ True 
Goal: ¬False ↔ True
-- Eq.to_iff
theorem Eq.to_iff : a = b → (a ↔ b) 
Arguments: {a b : Prop}
Goal: a = b → (a ↔ b)
-- iff_of_eq
theorem iff_of_eq : a = b → (a ↔ b) 
Arguments: {a b : Prop}
Goal: a = b → (a ↔ b)
-- neq_of_not_iff
theorem neq_of_not_iff : ¬(a ↔ b) → a ≠ b 
Arguments: {a b : Prop}
Goal: ¬(a ↔ b) → a ≠ b
-- iff_iff_eq
theorem iff_iff_eq : (a ↔ b) ↔ a = b 
Arguments: {a b : Prop}
Goal: (a ↔ b) ↔ a = b
-- eq_iff_iff
@[simp] theorem eq_iff_iff : (a = b) ↔ (a ↔ b) 
Arguments: {a b : Prop}
Goal: a = b ↔ (a ↔ b)
-- eq_self_iff_true
theorem eq_self_iff_true (a : α)  : a = a ↔ True  
Arguments: {α : Sort u_1} (a : α)
Goal: a = a ↔ True
-- ne_self_iff_false
theorem ne_self_iff_false (a : α) : a ≠ a ↔ False 
Arguments: {α : Sort u_1} (a : α)
Goal: a ≠ a ↔ False
-- false_of_true_iff_false
theorem false_of_true_iff_false (h : True ↔ False) : False 
Arguments: (h : True ↔ False)
Goal: False
-- false_of_true_eq_false
theorem false_of_true_eq_false  (h : True = False) : False 
Arguments: (h : True = False)
Goal: False
-- true_eq_false_of_false
theorem true_eq_false_of_false : False → (True = False) 
Goal: False → True = False
-- iff_def
theorem iff_def  : (a ↔ b) ↔ (a → b) ∧ (b → a) 
Arguments: {a b : Prop}
Goal: (a ↔ b) ↔ (a → b) ∧ (b → a)
-- iff_def'
theorem iff_def' : (a ↔ b) ↔ (b → a) ∧ (a → b) 
Arguments: {a b : Prop}
Goal: (a ↔ b) ↔ (b → a) ∧ (a → b)
-- true_iff_false
theorem true_iff_false : (True ↔ False) ↔ False 
Goal: (True ↔ False) ↔ False
-- false_iff_true
theorem false_iff_true : (False ↔ True) ↔ False 
Goal: (False ↔ True) ↔ False
-- iff_not_self
theorem iff_not_self : ¬(a ↔ ¬a) 
Arguments: {a : Prop}
Goal: ¬(a ↔ ¬a)
-- heq_self_iff_true
theorem heq_self_iff_true (a : α) : HEq a a ↔ True 
Arguments: {α : Sort u_1} (a : α)
Goal: HEq a a ↔ True
-- not_not_of_not_imp
theorem not_not_of_not_imp : ¬(a → b) → ¬¬a 
Arguments: {a b : Prop}
Goal: ¬(a → b) → ¬¬a
-- not_of_not_imp
theorem not_of_not_imp {a : Prop} : ¬(a → b) → ¬b 
Arguments: {b a : Prop}
Goal: ¬(a → b) → ¬b
-- imp_not_self
@[simp] theorem imp_not_self : (a → ¬a) ↔ ¬a 
Arguments: {a : Prop}
Goal: a → ¬a ↔ ¬a
-- imp_intro
theorem imp_intro {α β : Prop} (h : α) : β → α 
Arguments: {α β : Prop} (h : α)
Goal: β → α
-- imp_imp_imp
theorem imp_imp_imp {a b c d : Prop} (h₀ : c → a) (h₁ : b → d) : (a → b) → (c → d) 
Arguments: {a b c d : Prop} (h₀ : c → a) (h₁ : b → d)
Goal: (a → b) → c → d
-- imp_iff_right
theorem imp_iff_right {a : Prop} (ha : a) : (a → b) ↔ b 
Arguments: {b a : Prop} (ha : a)
Goal: a → b ↔ b
-- imp_true_iff
theorem imp_true_iff (α : Sort u) : (α → True) ↔ True 
Arguments: (α : Sort u)
Goal: α → True ↔ True
-- false_imp_iff
theorem false_imp_iff (a : Prop) : (False → a) ↔ True 
Arguments: (a : Prop)
Goal: False → a ↔ True
-- true_imp_iff
theorem true_imp_iff (α : Prop) : (True → α) ↔ α 
Arguments: (α : Prop)
Goal: True → α ↔ α
-- imp_self
@[simp high] theorem imp_self : (a → a) ↔ True 
Arguments: {a : Prop}
Goal: a → a ↔ True
-- imp_false
@[simp] theorem imp_false : (a → False) ↔ ¬a 
Arguments: {a : Prop}
Goal: a → False ↔ ¬a
-- imp.swap
theorem imp.swap : (a → b → c) ↔ (b → a → c) 
Arguments: {a b c : Prop}
Goal: a → b → c ↔ b → a → c
-- imp_not_comm
theorem imp_not_comm : (a → ¬b) ↔ (b → ¬a) 
Arguments: {a b : Prop}
Goal: a → ¬b ↔ b → ¬a
-- imp_congr_left
theorem imp_congr_left (h : a ↔ b) : (a → c) ↔ (b → c) 
Arguments: {a b c : Prop} (h : a ↔ b)
Goal: a → c ↔ b → c
-- imp_congr_right
theorem imp_congr_right (h : a → (b ↔ c)) : (a → b) ↔ (a → c) 
Arguments: {a b c : Prop} (h : a → (b ↔ c))
Goal: a → b ↔ a → c
-- imp_congr_ctx
theorem imp_congr_ctx (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
-- imp_congr
theorem imp_congr (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_iff_not
theorem imp_iff_not (hb : ¬b) : a → b ↔ ¬a 
Arguments: {a b : Prop} (hb : ¬b)
Goal: a → b ↔ ¬a
-- Quot.liftBeta
protected theorem liftBeta {α : Sort u} {r : α → α → Prop} {β : Sort v}
    (f : α → β)
    (c : (a b : α) → r a b → f a = f b)
    (a : α)
    : lift f c (Quot.mk r a) = f a 
Arguments: {α : Sort u} {r : α → α → Prop} {β : Sort v} (f : α → β) (c : ∀ (a b : α), r a b → f a = f b) (a : α)
Goal: Quot.lift f c (Quot.mk r a) = f a
-- Quot.indBeta
protected theorem indBeta {α : Sort u} {r : α → α → Prop} {motive : Quot r → Prop}
    (p : (a : α) → motive (Quot.mk r a))
    (a : α)
    : (ind p (Quot.mk r a) : motive (Quot.mk r a)) = p a 
Arguments: {α : Sort u} {r : α → α → Prop} {motive : Quot r → Prop} (p : ∀ (a : α), motive (Quot.mk r a)) (a : α)
Goal: ⋯ = ⋯
-- Quot.inductionOn
@[elab_as_elim]
protected theorem inductionOn {α : Sort u} {r : α → α → Prop} {motive : Quot r → Prop}
    (q : Quot r)
    (h : (a : α) → motive (Quot.mk r a))
    : motive q 
Arguments: {α : Sort u} {r : α → α → Prop} {motive : Quot r → Prop} (q : Quot r) (h : ∀ (a : α), motive (Quot.mk r a))
Goal: motive q
-- Quot.exists_rep
theorem exists_rep {α : Sort u} {r : α → α → Prop} (q : Quot r) : Exists (fun a => (Quot.mk r a) = q) 
Arguments: {α : Sort u} {r : α → α → Prop} (q : Quot r)
Goal: Exists fun a => Quot.mk r a = q
-- Quot.indepCoherent
protected theorem indepCoherent
    (f : (a : α) → motive (Quot.mk r a))
    (h : (a b : α) → (p : r a b) → Eq.ndrec (f a) (sound p) = f b)
    : (a b : α) → r a b → Quot.indep f a = Quot.indep f b  
Arguments: {α : Sort u} {r : α → α → Prop} {motive : Quot r → Sort v} (f : (a : α) → motive (Quot.mk r a)) (h : ∀ (a b : α) (p : r a b), Eq.ndrec (f a) ⋯ = f b) (a b : α)
Goal: r a b → Quot.indep f a = Quot.indep f b
-- Quot.liftIndepPr1
protected theorem liftIndepPr1
    (f : (a : α) → motive (Quot.mk r a))
    (h : ∀ (a b : α) (p : r a b), Eq.ndrec (f a) (sound p) = f b)
    (q : Quot r)
    : (lift (Quot.indep f) (Quot.indepCoherent f h) q).1 = q 
Arguments: {α : Sort u} {r : α → α → Prop} {motive : Quot r → Sort v} (f : (a : α) → motive (Quot.mk r a)) (h : ∀ (a b : α) (p : r a b), Eq.ndrec (f a) ⋯ = f b) (q : Quot r)
Goal: (Quot.lift (Quot.indep f) ⋯ q).fst = q
-- Quotient.sound
theorem sound {α : Sort u} {s : Setoid α} {a b : α} : a ≈ b → Quotient.mk s a = Quotient.mk s b 
Arguments: {α : Sort u} {s : Setoid α} {a b : α}
Goal: a ≈ b → Quotient.mk s a = Quotient.mk s b
-- Quotient.ind
protected theorem ind {α : Sort u} {s : Setoid α} {motive : Quotient s → Prop} : ((a : α) → motive (Quotient.mk s a)) → (q : Quotient s) → motive q 
Arguments: {α : Sort u} {s : Setoid α} {motive : Quotient s → Prop}
Goal: (∀ (a : α), motive (Quotient.mk s a)) → ∀ (q : Quotient s), motive q