ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Lean.Omega.Fin.ofNat_val_add
theorem ofNat_val_add {x y : Fin n} :
    (((x + y : Fin n)) : Int) = ((x : Int) + (y : Int)) % n 
Arguments: {n : Nat} {x y : Fin n}
Goal: ↑↑(x + y) = (↑↑x + ↑↑y) % ↑n
-- Lean.Omega.Fin.ofNat_val_sub
theorem ofNat_val_sub {x y : Fin n} :
    (((x - y : Fin n)) : Int) = (((n - y : Nat) + (x : Int) : Int)) % n 
Arguments: {n : Nat} {x y : Fin n}
Goal: ↑↑(x - y) = (↑(n - ↑y) + ↑↑x) % ↑n
-- Lean.Omega.Fin.ofNat_val_mul
theorem ofNat_val_mul {x y : Fin n} :
    (((x * y : Fin n)) : Int) = ((x : Int) * (y : Int)) % n 
Arguments: {n : Nat} {x y : Fin n}
Goal: ↑↑(x * y) = ↑↑x * ↑↑y % ↑n
-- Lean.Omega.Fin.ofNat_val_natCast
theorem ofNat_val_natCast {n x y : Nat} (h : y = x % (n + 1)):
    @Nat.cast Int instNatCastInt (@Fin.val (n + 1) (OfNat.ofNat x)) = OfNat.ofNat y 
Arguments: {n x y : Nat} (h : y = x % (n + 1))
Goal: ↑↑(OfNat.ofNat x) = OfNat.ofNat y
-- Lean.Omega.Prod.of_lex
theorem of_lex (w : Prod.Lex r s p q) : r p.fst q.fst ∨ p.fst = q.fst ∧ s p.snd q.snd 
Goal: ∀ {α : Type u_1} {r : α → α → Prop} {β : Type u_2} {s : β → β → Prop} {p q : α × β},
  Prod.Lex r s p q → r p.fst q.fst ∨ p.fst = q.fst ∧ s p.snd q.snd
-- Lean.Omega.Prod.of_not_lex
theorem of_not_lex {α} {r : α → α → Prop} [DecidableEq α] {β} {s : β → β → Prop}
    {p q : α × β} (w : ¬ Prod.Lex r s p q) :
    ¬ r p.fst q.fst ∧ (p.fst ≠ q.fst ∨ ¬ s p.snd q.snd) 
Arguments: {α : Type u_1} {r : α → α → Prop} [DecidableEq α] {β : Type u_2} {s : β → β → Prop} {p q : α × β} (w : ¬Prod.Lex r s p q)
Goal: ¬r p.fst q.fst ∧ (p.fst ≠ q.fst ∨ ¬s p.snd q.snd)
-- Lean.Omega.Prod.fst_mk
theorem fst_mk : (Prod.mk x y).fst = x 
Goal: ∀ {α : Type u_1} {x : α} {β : Type u_2} {y : β}, (x, y).fst = x
-- Lean.Omega.Prod.snd_mk
theorem snd_mk : (Prod.mk x y).snd = y 
Goal: ∀ {α : Type u_1} {x : α} {α_1 : Type u_2} {y : α_1}, (x, y).snd = y
-- Classical.choose_spec
theorem choose_spec {α : Sort u} {p : α → Prop} (h : ∃ x, p x) : p (choose h) 
Arguments: {α : Sort u} {p : α → Prop} (h : ∃ x, p x)
Goal: p (Classical.choose h)
-- Classical.em
theorem em (p : Prop) : p ∨ ¬p 
Arguments: (p : Prop)
Goal: p ∨ ¬p
-- Classical.exists_true_of_nonempty
theorem exists_true_of_nonempty {α : Sort u} : Nonempty α → ∃ _ : α, True
  
Arguments: {α : Sort u}
Goal: Nonempty α → ∃ x, True
-- Classical.epsilon_spec_aux
theorem epsilon_spec_aux {α : Sort u} (h : Nonempty α) (p : α → Prop) : (∃ y, p y) → p (@epsilon α h p) 
Arguments: {α : Sort u} (h : Nonempty α) (p : α → Prop)
Goal: (∃ y, p y) → p (Classical.epsilon p)
-- Classical.epsilon_spec
theorem epsilon_spec {α : Sort u} {p : α → Prop} (hex : ∃ y, p y) : p (@epsilon α (nonempty_of_exists hex) p) 
Arguments: {α : Sort u} {p : α → Prop} (hex : ∃ y, p y)
Goal: p (Classical.epsilon p)
-- Classical.epsilon_singleton
theorem epsilon_singleton {α : Sort u} (x : α) : @epsilon α ⟨x⟩ (fun y => y = x) = x 
Arguments: {α : Sort u} (x : α)
Goal: (Classical.epsilon fun y => y = x) = x
-- Classical.axiomOfChoice
theorem axiomOfChoice {α : Sort u} {β : α → Sort v} {r : ∀ x, β x → Prop} (h : ∀ x, ∃ y, r x y) : ∃ (f : ∀ x, β x), ∀ x, r x (f x) 
Arguments: {α : Sort u} {β : α → Sort v} {r : (x : α) → β x → Prop} (h : ∀ (x : α), ∃ y, r x y)
Goal: ∃ f, ∀ (x : α), r x (f x)
-- Classical.skolem
theorem skolem {α : Sort u} {b : α → Sort v} {p : ∀ x, b x → Prop} : (∀ x, ∃ y, p x y) ↔ ∃ (f : ∀ x, b x), ∀ x, p x (f x) 
Arguments: {α : Sort u} {b : α → Sort v} {p : (x : α) → b x → Prop}
Goal: (∀ (x : α), ∃ y, p x y) ↔ ∃ f, ∀ (x : α), p x (f x)
-- Classical.propComplete
theorem propComplete (a : Prop) : a = True ∨ a = False 
Arguments: (a : Prop)
Goal: a = True ∨ a = False
-- Classical.byCases
theorem byCases {p q : Prop} (hpq : p → q) (hnpq : ¬p → q) : q 
Arguments: {p q : Prop} (hpq : p → q) (hnpq : ¬p → q)
Goal: q
-- Classical.byContradiction
theorem byContradiction {p : Prop} (h : ¬p → False) : p 
Arguments: {p : Prop} (h : ¬p → False)
Goal: p
-- Classical.not_not
@[simp] theorem not_not : ¬¬a ↔ a 
Arguments: {a : Prop}
Goal: ¬¬a ↔ a
-- Classical.not_forall
@[simp low] theorem not_forall {p : α → Prop} : (¬∀ x, p x) ↔ ∃ x, ¬p x 
Arguments: {α : Sort u_1} {p : α → Prop}
Goal: (¬∀ (x : α), p x) ↔ ∃ x, ¬p x
-- Classical.not_forall_not
theorem not_forall_not {p : α → Prop} : (¬∀ x, ¬p x) ↔ ∃ x, p x 
Arguments: {α : Sort u_1} {p : α → Prop}
Goal: (¬∀ (x : α), ¬p x) ↔ ∃ x, p x
-- Classical.not_exists_not
theorem not_exists_not {p : α → Prop} : (¬∃ x, ¬p x) ↔ ∀ x, p x 
Arguments: {α : Sort u_1} {p : α → Prop}
Goal: (¬∃ x, ¬p x) ↔ ∀ (x : α), p x
-- Classical.forall_or_exists_not
theorem forall_or_exists_not (P : α → Prop) : (∀ a, P a) ∨ ∃ a, ¬ P a 
Arguments: {α : Sort u_1} (P : α → Prop)
Goal: (∀ (a : α), P a) ∨ ∃ a, ¬P a
-- Classical.exists_or_forall_not
theorem exists_or_forall_not (P : α → Prop) : (∃ a, P a) ∨ ∀ a, ¬ P a 
Arguments: {α : Sort u_1} (P : α → Prop)
Goal: (∃ a, P a) ∨ ∀ (a : α), ¬P a
-- Classical.or_iff_not_imp_left
theorem or_iff_not_imp_left  : a ∨ b ↔ (¬a → b) 
Arguments: {a b : Prop}
Goal: a ∨ b ↔ ¬a → b
-- Classical.or_iff_not_imp_right
theorem or_iff_not_imp_right : a ∨ b ↔ (¬b → a) 
Arguments: {a b : Prop}
Goal: a ∨ b ↔ ¬b → a
-- Classical.not_imp_iff_and_not
theorem not_imp_iff_and_not : ¬(a → b) ↔ a ∧ ¬b 
Arguments: {a b : Prop}
Goal: ¬(a → b) ↔ a ∧ ¬b
-- Classical.not_and_iff_or_not_not
theorem not_and_iff_or_not_not : ¬(a ∧ b) ↔ ¬a ∨ ¬b 
Arguments: {a b : Prop}
Goal: ¬(a ∧ b) ↔ ¬a ∨ ¬b
-- Classical.not_iff
theorem not_iff : ¬(a ↔ b) ↔ (¬a ↔ b) 
Arguments: {a b : Prop}
Goal: ¬(a ↔ b) ↔ (¬a ↔ b)
-- Classical.imp_iff_left_iff
@[simp] theorem imp_iff_left_iff  : (b ↔ a → b) ↔ a ∨ b 
Arguments: {b a : Prop}
Goal: (b ↔ a → b) ↔ a ∨ b
-- Classical.imp_iff_right_iff
@[simp] theorem imp_iff_right_iff : (a → b ↔ b) ↔ a ∨ b 
Arguments: {a b : Prop}
Goal: (a → b ↔ b) ↔ a ∨ b
-- Classical.and_or_imp
@[simp] theorem and_or_imp : a ∧ b ∨ (a → c) ↔ a → b ∨ c 
Arguments: {a b c : Prop}
Goal: a ∧ b ∨ (a → c) ↔ a → b ∨ c
-- Classical.not_imp
@[simp] theorem not_imp : ¬(a → b) ↔ a ∧ ¬b 
Arguments: {a b : Prop}
Goal: ¬(a → b) ↔ a ∧ ¬b
-- Classical.imp_and_neg_imp_iff
@[simp] theorem imp_and_neg_imp_iff (p q : Prop) : (p → q) ∧ (¬p → q) ↔ q 
Arguments: (p q : Prop)
Goal: (p → q) ∧ (¬p → q) ↔ q
-- Exists.choose_spec
theorem Exists.choose_spec {p : α → Prop} (P : ∃ a, p a) : p P.choose 
Arguments: {α : Sort u_1} {p : α → Prop} (P : ∃ a, p a)
Goal: p P.choose
-- Prod.ext
@[ext] theorem Prod.ext : {x y : Prod α β} → x.fst = y.fst → x.snd = y.snd → x = y
  
Arguments: {α : Type u_1} {β : Type u_2} {x y : α × β}
Goal: x.fst = y.fst → x.snd = y.snd → x = y
-- PProd.ext
@[ext] theorem PProd.ext : {x y : PProd α β} → x.fst = y.fst → x.snd = y.snd → x = y
  
Arguments: {α : Sort u_1} {β : Sort u_2} {x y : PProd α β}
Goal: x.fst = y.fst → x.snd = y.snd → x = y
-- Sigma.ext
@[ext] theorem Sigma.ext : {x y : Sigma β} → x.fst = y.fst → HEq x.snd y.snd → x = y
  
Goal: ∀ {α : Type u_1} {β : α → Type u_2} {x y : Sigma β}, x.fst = y.fst → HEq x.snd y.snd → x = y
-- PSigma.ext
@[ext] theorem PSigma.ext : {x y : PSigma β} → x.fst = y.fst → HEq x.snd y.snd → x = y
  
Goal: ∀ {α : Sort u_1} {β : α → Sort u_2} {x y : PSigma β}, x.fst = y.fst → HEq x.snd y.snd → x = y
-- PUnit.ext
@[ext] protected theorem PUnit.ext (x y : PUnit) : x = y 
Arguments: (x y : PUnit)
Goal: x = y
-- Unit.ext
protected theorem Unit.ext (x y : Unit) : x = y 
Arguments: (x y : Unit)
Goal: x = y
-- Lean.Omega.LinearCombo.ext
theorem ext {a b : LinearCombo} (w₁ : a.const = b.const) (w₂ : a.coeffs = b.coeffs) :
    a = b 
Arguments: {a b : Lean.Omega.LinearCombo} (w₁ : a.const = b.const) (w₂ : a.coeffs = b.coeffs)
Goal: a = b
-- Lean.Omega.LinearCombo.eval_nil
@[simp] theorem eval_nil : (lc : LinearCombo).eval .nil = lc.const 
Arguments: {lc : Lean.Omega.LinearCombo}
Goal: lc.eval [] = lc.const
-- Lean.Omega.LinearCombo.coordinate_eval
@[simp] theorem coordinate_eval (i : Nat) (v : Coeffs) :
    (coordinate i).eval v = v.get i 
Arguments: (i : Nat) (v : Lean.Omega.Coeffs)
Goal: (Lean.Omega.LinearCombo.coordinate i).eval v = v.get i
-- Lean.Omega.LinearCombo.coordinate_eval_0
theorem coordinate_eval_0 : (coordinate 0).eval (.ofList (a0 :: t)) = a0 
Arguments: {a0 : Int} {t : List Int}
Goal: (Lean.Omega.LinearCombo.coordinate 0).eval (Lean.Omega.Coeffs.ofList (a0 :: t)) = a0
-- Lean.Omega.LinearCombo.coordinate_eval_1
theorem coordinate_eval_1 : (coordinate 1).eval (.ofList (a0 :: a1 :: t)) = a1 
Arguments: {a0 a1 : Int} {t : List Int}
Goal: (Lean.Omega.LinearCombo.coordinate 1).eval (Lean.Omega.Coeffs.ofList (a0 :: a1 :: t)) = a1
-- Lean.Omega.LinearCombo.coordinate_eval_2
theorem coordinate_eval_2 : (coordinate 2).eval (.ofList (a0 :: a1 :: a2 :: t)) = a2 
Arguments: {a0 a1 a2 : Int} {t : List Int}
Goal: (Lean.Omega.LinearCombo.coordinate 2).eval (Lean.Omega.Coeffs.ofList (a0 :: a1 :: a2 :: t)) = a2
-- Lean.Omega.LinearCombo.coordinate_eval_3
theorem coordinate_eval_3 :
    (coordinate 3).eval (.ofList (a0 :: a1 :: a2 :: a3 :: t)) = a3 
Arguments: {a0 a1 a2 a3 : Int} {t : List Int}
Goal: (Lean.Omega.LinearCombo.coordinate 3).eval (Lean.Omega.Coeffs.ofList (a0 :: a1 :: a2 :: a3 :: t)) = a3
-- Lean.Omega.LinearCombo.coordinate_eval_4
theorem coordinate_eval_4 :
    (coordinate 4).eval (.ofList (a0 :: a1 :: a2 :: a3 :: a4 :: t)) = a4 
Arguments: {a0 a1 a2 a3 a4 : Int} {t : List Int}
Goal: (Lean.Omega.LinearCombo.coordinate 4).eval (Lean.Omega.Coeffs.ofList (a0 :: a1 :: a2 :: a3 :: a4 :: t)) = a4
-- Lean.Omega.LinearCombo.coordinate_eval_5
theorem coordinate_eval_5 :
    (coordinate 5).eval (.ofList (a0 :: a1 :: a2 :: a3 :: a4 :: a5 :: t)) = a5 
Arguments: {a0 a1 a2 a3 a4 a5 : Int} {t : List Int}
Goal: (Lean.Omega.LinearCombo.coordinate 5).eval (Lean.Omega.Coeffs.ofList (a0 :: a1 :: a2 :: a3 :: a4 :: a5 :: t)) = a5
-- Lean.Omega.LinearCombo.coordinate_eval_6
theorem coordinate_eval_6 :
    (coordinate 6).eval (.ofList (a0 :: a1 :: a2 :: a3 :: a4 :: a5 :: a6 :: t)) = a6 
Arguments: {a0 a1 a2 a3 a4 a5 a6 : Int} {t : List Int}
Goal: (Lean.Omega.LinearCombo.coordinate 6).eval (Lean.Omega.Coeffs.ofList (a0 :: a1 :: a2 :: a3 :: a4 :: a5 :: a6 :: t)) = a6
-- Lean.Omega.LinearCombo.coordinate_eval_7
theorem coordinate_eval_7 :
    (coordinate 7).eval
      (.ofList (a0 :: a1 :: a2 :: a3 :: a4 :: a5 :: a6 :: a7 :: t)) = a7 
Arguments: {a0 a1 a2 a3 a4 a5 a6 a7 : Int} {t : List Int}
Goal: (Lean.Omega.LinearCombo.coordinate 7).eval
    (Lean.Omega.Coeffs.ofList (a0 :: a1 :: a2 :: a3 :: a4 :: a5 :: a6 :: a7 :: t)) =
  a7
-- Lean.Omega.LinearCombo.coordinate_eval_8
theorem coordinate_eval_8 :
    (coordinate 8).eval
      (.ofList (a0 :: a1 :: a2 :: a3 :: a4 :: a5 :: a6 :: a7 :: a8 :: t)) = a8 
Arguments: {a0 a1 a2 a3 a4 a5 a6 a7 a8 : Int} {t : List Int}
Goal: (Lean.Omega.LinearCombo.coordinate 8).eval
    (Lean.Omega.Coeffs.ofList (a0 :: a1 :: a2 :: a3 :: a4 :: a5 :: a6 :: a7 :: a8 :: t)) =
  a8
-- Lean.Omega.LinearCombo.coordinate_eval_9
theorem coordinate_eval_9 :
    (coordinate 9).eval
      (.ofList (a0 :: a1 :: a2 :: a3 :: a4 :: a5 :: a6 :: a7 :: a8 :: a9 :: t)) = a9 
Arguments: {a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 : Int} {t : List Int}
Goal: (Lean.Omega.LinearCombo.coordinate 9).eval
    (Lean.Omega.Coeffs.ofList (a0 :: a1 :: a2 :: a3 :: a4 :: a5 :: a6 :: a7 :: a8 :: a9 :: t)) =
  a9
-- Lean.Omega.LinearCombo.add_const
@[simp] theorem add_const {l₁ l₂ : LinearCombo} : (l₁ + l₂).const = l₁.const + l₂.const 
Arguments: {l₁ l₂ : Lean.Omega.LinearCombo}
Goal: (l₁ + l₂).const = l₁.const + l₂.const
-- Lean.Omega.LinearCombo.add_coeffs
@[simp] theorem add_coeffs {l₁ l₂ : LinearCombo} : (l₁ + l₂).coeffs = l₁.coeffs + l₂.coeffs 
Arguments: {l₁ l₂ : Lean.Omega.LinearCombo}
Goal: (l₁ + l₂).coeffs = l₁.coeffs + l₂.coeffs
-- Lean.Omega.LinearCombo.sub_const
@[simp] theorem sub_const {l₁ l₂ : LinearCombo} : (l₁ - l₂).const = l₁.const - l₂.const 
Arguments: {l₁ l₂ : Lean.Omega.LinearCombo}
Goal: (l₁ - l₂).const = l₁.const - l₂.const
-- Lean.Omega.LinearCombo.sub_coeffs
@[simp] theorem sub_coeffs {l₁ l₂ : LinearCombo} : (l₁ - l₂).coeffs = l₁.coeffs - l₂.coeffs 
Arguments: {l₁ l₂ : Lean.Omega.LinearCombo}
Goal: (l₁ - l₂).coeffs = l₁.coeffs - l₂.coeffs
-- Lean.Omega.LinearCombo.neg_const
@[simp] theorem neg_const {l : LinearCombo} : (-l).const = -l.const 
Arguments: {l : Lean.Omega.LinearCombo}
Goal: (-l).const = -l.const
-- Lean.Omega.LinearCombo.neg_coeffs
@[simp] theorem neg_coeffs {l : LinearCombo} : (-l).coeffs = -l.coeffs  
Arguments: {l : Lean.Omega.LinearCombo}
Goal: (-l).coeffs = -l.coeffs
-- Lean.Omega.LinearCombo.sub_eq_add_neg
theorem sub_eq_add_neg (l₁ l₂ : LinearCombo) : l₁ - l₂ = l₁ + -l₂ 
Arguments: (l₁ l₂ : Lean.Omega.LinearCombo)
Goal: l₁ - l₂ = l₁ + -l₂
-- Lean.Omega.LinearCombo.smul_const
@[simp] theorem smul_const {lc : LinearCombo} {i : Int} : (i * lc).const = i * lc.const 
Arguments: {lc : Lean.Omega.LinearCombo} {i : Int}
Goal: (i * lc).const = i * lc.const
-- Lean.Omega.LinearCombo.smul_coeffs
@[simp] theorem smul_coeffs {lc : LinearCombo} {i : Int} : (i * lc).coeffs = i * lc.coeffs 
Arguments: {lc : Lean.Omega.LinearCombo} {i : Int}
Goal: (i * lc).coeffs = i * lc.coeffs
-- Lean.Omega.LinearCombo.add_eval
@[simp] theorem add_eval (l₁ l₂ : LinearCombo) (v : Coeffs) :
    (l₁ + l₂).eval v = l₁.eval v + l₂.eval v 
Arguments: (l₁ l₂ : Lean.Omega.LinearCombo) (v : Lean.Omega.Coeffs)
Goal: (l₁ + l₂).eval v = l₁.eval v + l₂.eval v
-- Lean.Omega.LinearCombo.neg_eval
@[simp] theorem neg_eval (lc : LinearCombo) (v : Coeffs) : (-lc).eval v = - lc.eval v 
Arguments: (lc : Lean.Omega.LinearCombo) (v : Lean.Omega.Coeffs)
Goal: (-lc).eval v = -lc.eval v
-- Lean.Omega.LinearCombo.sub_eval
@[simp] theorem sub_eval (l₁ l₂ : LinearCombo) (v : Coeffs) :
    (l₁ - l₂).eval v = l₁.eval v - l₂.eval v 
Arguments: (l₁ l₂ : Lean.Omega.LinearCombo) (v : Lean.Omega.Coeffs)
Goal: (l₁ - l₂).eval v = l₁.eval v - l₂.eval v
-- Lean.Omega.LinearCombo.smul_eval
@[simp] theorem smul_eval (lc : LinearCombo) (i : Int) (v : Coeffs) :
    (i * lc).eval v = i * lc.eval v 
Arguments: (lc : Lean.Omega.LinearCombo) (i : Int) (v : Lean.Omega.Coeffs)
Goal: (i * lc).eval v = i * lc.eval v
-- Lean.Omega.LinearCombo.smul_eval_comm
theorem smul_eval_comm (lc : LinearCombo) (i : Int) (v : Coeffs) :
    (i * lc).eval v = lc.eval v * i 
Arguments: (lc : Lean.Omega.LinearCombo) (i : Int) (v : Lean.Omega.Coeffs)
Goal: (i * lc).eval v = lc.eval v * i
-- Lean.Omega.LinearCombo.mul_eval_of_const_left
theorem mul_eval_of_const_left (l₁ l₂ : LinearCombo) (v : Coeffs) (w : l₁.coeffs.isZero) :
    (mul l₁ l₂).eval v = l₁.eval v * l₂.eval v 
Arguments: (l₁ l₂ : Lean.Omega.LinearCombo) (v : Lean.Omega.Coeffs) (w : l₁.coeffs.isZero)
Goal: (l₁.mul l₂).eval v = l₁.eval v * l₂.eval v
-- Lean.Omega.LinearCombo.mul_eval_of_const_right
theorem mul_eval_of_const_right (l₁ l₂ : LinearCombo) (v : Coeffs) (w : l₂.coeffs.isZero) :
    (mul l₁ l₂).eval v = l₁.eval v * l₂.eval v 
Arguments: (l₁ l₂ : Lean.Omega.LinearCombo) (v : Lean.Omega.Coeffs) (w : l₂.coeffs.isZero)
Goal: (l₁.mul l₂).eval v = l₁.eval v * l₂.eval v
-- Lean.Omega.LinearCombo.mul_eval
theorem mul_eval (l₁ l₂ : LinearCombo) (v : Coeffs) (w : l₁.coeffs.isZero ∨ l₂.coeffs.isZero) :
    (mul l₁ l₂).eval v = l₁.eval v * l₂.eval v 
Arguments: (l₁ l₂ : Lean.Omega.LinearCombo) (v : Lean.Omega.Coeffs) (w : l₁.coeffs.isZero ∨ l₂.coeffs.isZero)
Goal: (l₁.mul l₂).eval v = l₁.eval v * l₂.eval v
-- of_eq_true
theorem of_eq_true (h : p = True) : p 
Arguments: {p : Prop} (h : p = True)
Goal: p
-- of_eq_false
theorem of_eq_false (h : p = False) : ¬ p 
Arguments: {p : Prop} (h : p = False)
Goal: ¬p
-- eq_true
theorem eq_true (h : p) : p = True 
Arguments: {p : Prop} (h : p)
Goal: p = True
-- eq_false
theorem eq_false (h : ¬ p) : p = False 
Arguments: {p : Prop} (h : ¬p)
Goal: p = False
-- eq_false'
theorem eq_false' (h : p → False) : p = False 
Arguments: {p : Prop} (h : p → False)
Goal: p = False
-- eq_true_of_decide
theorem eq_true_of_decide {p : Prop} [Decidable p] (h : decide p = true) : p = True 
Arguments: {p : Prop} [Decidable p] (h : decide p = true)
Goal: p = True
-- eq_false_of_decide
theorem eq_false_of_decide {p : Prop} {_ : Decidable p} (h : decide p = false) : p = False 
Arguments: {p : Prop}
Goal: ∀ {x : Decidable p}, decide p = false → p = False
-- eq_self
@[simp] theorem eq_self (a : α) : (a = a) = True 
Arguments: {α : Sort u_1} (a : α)
Goal: (a = a) = True
-- implies_congr
theorem implies_congr {p₁ p₂ : Sort u} {q₁ q₂ : Sort v} (h₁ : p₁ = p₂) (h₂ : q₁ = q₂) : (p₁ → q₁) = (p₂ → q₂) 
Arguments: {p₁ p₂ : Sort u} {q₁ q₂ : Sort v} (h₁ : p₁ = p₂) (h₂ : q₁ = q₂)
Goal: (p₁ → q₁) = (p₂ → q₂)
-- iff_congr
theorem iff_congr {p₁ p₂ q₁ q₂ : Prop} (h₁ : p₁ ↔ p₂) (h₂ : q₁ ↔ q₂) : (p₁ ↔ q₁) ↔ (p₂ ↔ q₂) 
Arguments: {p₁ p₂ q₁ q₂ : Prop} (h₁ : p₁ ↔ p₂) (h₂ : q₁ ↔ q₂)
Goal: (p₁ ↔ q₁) ↔ (p₂ ↔ q₂)
-- implies_dep_congr_ctx
theorem implies_dep_congr_ctx {p₁ p₂ q₁ : Prop} (h₁ : p₁ = p₂) {q₂ : p₂ → Prop} (h₂ : (h : p₂) → q₁ = q₂ h) : (p₁ → q₁) = ((h : p₂) → q₂ h) 
Arguments: {p₁ p₂ q₁ : Prop} (h₁ : p₁ = p₂) {q₂ : p₂ → Prop} (h₂ : ∀ (h : p₂), q₁ = q₂ h)
Goal: (p₁ → q₁) = ∀ (h : p₂), q₂ h
-- implies_congr_ctx
theorem implies_congr_ctx {p₁ p₂ q₁ q₂ : Prop} (h₁ : p₁ = p₂) (h₂ : p₂ → q₁ = q₂) : (p₁ → q₁) = (p₂ → q₂) 
Arguments: {p₁ p₂ q₁ q₂ : Prop} (h₁ : p₁ = p₂) (h₂ : p₂ → q₁ = q₂)
Goal: (p₁ → q₁) = (p₂ → q₂)
-- forall_congr
theorem forall_congr {α : Sort u} {p q : α → Prop} (h : ∀ a, p a = q a) : (∀ a, p a) = (∀ a, q a) 
Arguments: {α : Sort u} {p q : α → Prop} (h : ∀ (a : α), p a = q a)
Goal: (∀ (a : α), p a) = ∀ (a : α), q a
-- forall_prop_domain_congr
theorem forall_prop_domain_congr {p₁ p₂ : Prop} {q₁ : p₁ → Prop} {q₂ : p₂ → Prop}
    (h₁ : p₁ = p₂)
    (h₂ : ∀ a : p₂, q₁ (h₁.substr a) = q₂ a)
    : (∀ a : p₁, q₁ a) = (∀ a : p₂, q₂ a) 
Arguments: {p₁ p₂ : Prop} {q₁ : p₁ → Prop} {q₂ : p₂ → Prop} (h₁ : p₁ = p₂) (h₂ : ∀ (a : p₂), q₁ ⋯ = q₂ a)
Goal: (∀ (a : p₁), q₁ a) = ∀ (a : p₂), q₂ a
-- let_congr
theorem let_congr {α : Sort u} {β : Sort v} {a a' : α} {b b' : α → β}
    (h₁ : a = a') (h₂ : ∀ x, b x = b' x) : (let x := a; b x) = (let x := a'; b' x) 
Arguments: {α : Sort u} {β : Sort v} {a a' : α} {b b' : α → β} (h₁ : a = a') (h₂ : ∀ (x : α), b x = b' x)
Goal: (let x := a;
  b x) =
  let x := a';
  b' x
-- let_val_congr
theorem let_val_congr {α : Sort u} {β : Sort v} {a a' : α}
    (b : α → β) (h : a = a') : (let x := a; b x) = (let x := a'; b x) 
Arguments: {α : Sort u} {β : Sort v} {a a' : α} (b : α → β) (h : a = a')
Goal: (let x := a;
  b x) =
  let x := a';
  b x
-- let_body_congr
theorem let_body_congr {α : Sort u} {β : α → Sort v} {b b' : (a : α) → β a}
    (a : α) (h : ∀ x, b x = b' x) : (let x := a; b x) = (let x := a; b' x) 
Arguments: {α : Sort u} {β : α → Sort v} {b b' : (a : α) → β a} (a : α) (h : ∀ (x : α), b x = b' x)
Goal: (let x := a;
  b x) =
  let x := a;
  b' x
-- ite_congr
@[congr]
theorem ite_congr {x y u v : α} {s : Decidable b} [Decidable c]
    (h₁ : b = c) (h₂ : c → x = u) (h₃ : ¬ c → y = v) : ite b x y = ite c u v 
Arguments: {α : Sort u_1} {b c : Prop} {x y u v : α} {s : Decidable b} [Decidable c] (h₁ : b = c) (h₂ : c → x = u) (h₃ : ¬c → y = v)
Goal: ite b x y = ite c u v
-- Eq.mpr_prop
theorem Eq.mpr_prop {p q : Prop} (h₁ : p = q) (h₂ : q)  : p  
Arguments: {p q : Prop} (h₁ : p = q) (h₂ : q)
Goal: p
-- Eq.mpr_not
theorem Eq.mpr_not  {p q : Prop} (h₁ : p = q) (h₂ : ¬q) : ¬p 
Arguments: {p q : Prop} (h₁ : p = q) (h₂ : ¬q)
Goal: ¬p
-- dite_congr
@[congr]
theorem dite_congr {_ : Decidable b} [Decidable c]
    {x : b → α} {u : c → α} {y : ¬b → α} {v : ¬c → α}
    (h₁ : b = c)
    (h₂ : (h : c)  → x (h₁.mpr_prop h) = u h)
    (h₃ : (h : ¬c) → y (h₁.mpr_not h)  = v h) :
    dite b x y = dite c u v 
Arguments: {b c : Prop} {α : Sort u_1}
Goal: ∀ {x : Decidable b} [inst : Decidable c] {x_1 : b → α} {u : c → α} {y : ¬b → α} {v : ¬c → α} (h₁ : b = c),
  (∀ (h : c), x_1 ⋯ = u h) → (∀ (h : ¬c), y ⋯ = v h) → dite b x_1 y = dite c u v
-- ne_eq
@[simp] theorem ne_eq (a b : α) : (a ≠ b) = ¬(a = b) 
Arguments: {α : Sort u_1} (a b : α)
Goal: (a ≠ b) = ¬a = b
-- ite_true
@[simp] theorem ite_true (a b : α) : (if True then a else b) = a 
Arguments: {α : Sort u_1} (a b : α)
Goal: ite True a b = a
-- ite_false
@[simp] theorem ite_false (a b : α) : (if False then a else b) = b 
Arguments: {α : Sort u_1} (a b : α)
Goal: ite False a b = b
-- dite_true
@[simp] theorem dite_true {α : Sort u} {t : True → α} {e : ¬ True → α} : (dite True t e) = t True.intro 
Arguments: {α : Sort u} {t : True → α} {e : ¬True → α}
Goal: dite True t e = t True.intro
-- dite_false
@[simp] theorem dite_false {α : Sort u} {t : False → α} {e : ¬ False → α} : (dite False t e) = e not_false 
Arguments: {α : Sort u} {t : False → α} {e : ¬False → α}
Goal: dite False t e = e not_false
-- ite_cond_eq_true
theorem ite_cond_eq_true {α : Sort u} {c : Prop} {_ : Decidable c} (a b : α) (h : c = True) : (if c then a else b) = a 
Arguments: {α : Sort u} {c : Prop}
Goal: ∀ {x : Decidable c} (a b : α), c = True → ite c a b = a
-- ite_cond_eq_false
theorem ite_cond_eq_false {α : Sort u} {c : Prop} {_ : Decidable c} (a b : α) (h : c = False) : (if c then a else b) = b 
Arguments: {α : Sort u} {c : Prop}
Goal: ∀ {x : Decidable c} (a b : α), c = False → ite c a b = b
-- dite_cond_eq_true
theorem dite_cond_eq_true {α : Sort u} {c : Prop} {_ : Decidable c} {t : c → α} {e : ¬ c → α} (h : c = True) : (dite c t e) = t (of_eq_true h) 
Arguments: {α : Sort u} {c : Prop}
Goal: ∀ {x : Decidable c} {t : c → α} {e : ¬c → α} (h : c = True), dite c t e = t ⋯
-- dite_cond_eq_false
theorem dite_cond_eq_false {α : Sort u} {c : Prop} {_ : Decidable c} {t : c → α} {e : ¬ c → α} (h : c = False) : (dite c t e) = e (of_eq_false h) 
Arguments: {α : Sort u} {c : Prop}
Goal: ∀ {x : Decidable c} {t : c → α} {e : ¬c → α} (h : c = False), dite c t e = e ⋯
-- ite_self
@[simp] theorem ite_self {α : Sort u} {c : Prop} {d : Decidable c} (a : α) : ite c a a = a 
Arguments: {α : Sort u} {c : Prop} {d : Decidable c} (a : α)
Goal: ite c a a = a
-- and_true
@[simp] theorem and_true (p : Prop) : (p ∧ True) = p 
Arguments: (p : Prop)
Goal: (p ∧ True) = p
-- true_and
@[simp] theorem true_and (p : Prop) : (True ∧ p) = p 
Arguments: (p : Prop)
Goal: (True ∧ p) = p
-- and_false
@[simp] theorem and_false (p : Prop) : (p ∧ False) = False 
Arguments: (p : Prop)
Goal: (p ∧ False) = False
-- false_and
@[simp] theorem false_and (p : Prop) : (False ∧ p) = False 
Arguments: (p : Prop)
Goal: (False ∧ p) = False
-- and_self
@[simp] theorem and_self (p : Prop) : (p ∧ p) = p 
Arguments: (p : Prop)
Goal: (p ∧ p) = p
-- and_not_self
@[simp] theorem and_not_self : ¬(a ∧ ¬a) 
Arguments: {a : Prop}
Goal: ¬(a ∧ ¬a)
-- not_and_self
@[simp] theorem not_and_self : ¬(¬a ∧ a) 
Arguments: {a : Prop}
Goal: ¬(¬a ∧ a)
-- and_imp
@[simp] theorem and_imp : (a ∧ b → c) ↔ (a → b → c) 
Arguments: {a b c : Prop}
Goal: a ∧ b → c ↔ a → b → c
-- not_and
@[simp] theorem not_and : ¬(a ∧ b) ↔ (a → ¬b) 
Arguments: {a b : Prop}
Goal: ¬(a ∧ b) ↔ a → ¬b
-- or_self
@[simp] theorem or_self (p : Prop) : (p ∨ p) = p 
Arguments: (p : Prop)
Goal: (p ∨ p) = p
-- or_true
@[simp] theorem or_true (p : Prop) : (p ∨ True) = True 
Arguments: (p : Prop)
Goal: (p ∨ True) = True
-- true_or
@[simp] theorem true_or (p : Prop) : (True ∨ p) = True 
Arguments: (p : Prop)
Goal: (True ∨ p) = True
-- or_false
@[simp] theorem or_false (p : Prop) : (p ∨ False) = p 
Arguments: (p : Prop)
Goal: (p ∨ False) = p
-- false_or
@[simp] theorem false_or (p : Prop) : (False ∨ p) = p 
Arguments: (p : Prop)
Goal: (False ∨ p) = p
-- iff_self
@[simp] theorem iff_self (p : Prop) : (p ↔ p) = True 
Arguments: (p : Prop)
Goal: (p ↔ p) = True
-- iff_true
@[simp] theorem iff_true (p : Prop) : (p ↔ True) = p 
Arguments: (p : Prop)
Goal: (p ↔ True) = p
-- true_iff
@[simp] theorem true_iff (p : Prop) : (True ↔ p) = p 
Arguments: (p : Prop)
Goal: (True ↔ p) = p
-- iff_false
@[simp] theorem iff_false (p : Prop) : (p ↔ False) = ¬p 
Arguments: (p : Prop)
Goal: (p ↔ False) = ¬p
-- false_iff
@[simp] theorem false_iff (p : Prop) : (False ↔ p) = ¬p 
Arguments: (p : Prop)
Goal: (False ↔ p) = ¬p
-- false_implies
@[simp] theorem false_implies (p : Prop) : (False → p) = True 
Arguments: (p : Prop)
Goal: (False → p) = True
-- implies_true
@[simp] theorem implies_true (α : Sort u) : (α → True) = True 
Arguments: (α : Sort u)
Goal: (α → True) = True
-- true_implies
@[simp] theorem true_implies (p : Prop) : (True → p) = p 
Arguments: (p : Prop)
Goal: (True → p) = p
-- not_false_eq_true
@[simp] theorem not_false_eq_true : (¬ False) = True 
Goal: (¬False) = True