ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Ne.ite_eq_right_iff
protected theorem Ne.ite_eq_right_iff (h : a ≠ b) : ite P a b = b ↔ ¬P 
Arguments: {α : Sort u_1} {P : Prop} [Decidable P] {a b : α} (h : a ≠ b)
Goal: (if P then a else b) = b ↔ ¬P
-- Ne.dite_ne_left_iff
protected theorem Ne.dite_ne_left_iff (h : ∀ h, a ≠ B h) : dite P (fun _ ↦ a) B ≠ a ↔ ¬P 
Arguments: {α : Sort u_1} {P : Prop} [Decidable P] {a : α} {B : ¬P → α} (h : ∀ (h : ¬P), a ≠ B h)
Goal: dite P (fun x => a) B ≠ a ↔ ¬P
-- Ne.dite_ne_right_iff
protected theorem Ne.dite_ne_right_iff (h : ∀ h, A h ≠ b) : (dite P A fun _ ↦ b) ≠ b ↔ P 
Arguments: {α : Sort u_1} {P : Prop} [Decidable P] {b : α} {A : P → α} (h : ∀ (h : P), A h ≠ b)
Goal: (dite P A fun x => b) ≠ b ↔ P
-- Ne.ite_ne_left_iff
protected theorem Ne.ite_ne_left_iff (h : a ≠ b) : ite P a b ≠ a ↔ ¬P 
Arguments: {α : Sort u_1} {P : Prop} [Decidable P] {a b : α} (h : a ≠ b)
Goal: (if P then a else b) ≠ a ↔ ¬P
-- Ne.ite_ne_right_iff
protected theorem Ne.ite_ne_right_iff (h : a ≠ b) : ite P a b ≠ b ↔ P 
Arguments: {α : Sort u_1} {P : Prop} [Decidable P] {a b : α} (h : a ≠ b)
Goal: (if P then a else b) ≠ b ↔ P
-- dite_eq_or_eq
theorem dite_eq_or_eq : (∃ h, dite P A B = A h) ∨ ∃ h, dite P A B = B h 
Arguments: {α : Sort u_1} (P : Prop) [Decidable P] {A : P → α} {B : ¬P → α}
Goal: (∃ h, dite P A B = A h) ∨ ∃ h, dite P A B = B h
-- ite_eq_or_eq
theorem ite_eq_or_eq : ite P a b = a ∨ ite P a b = b 
Arguments: {α : Sort u_1} (P : Prop) [Decidable P] (a b : α)
Goal: (if P then a else b) = a ∨ (if P then a else b) = b
-- apply_dite₂
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) 
Arguments: {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} (f : α → β → γ) (P : Prop) [Decidable P] (a : P → α) (b : ¬P → α) (c : P → β) (d : ¬P → β)
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)
-- apply_ite₂
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) 
Arguments: {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} (f : α → β → γ) (P : Prop) [Decidable P] (a b : α) (c 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
-- dite_apply
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 
Arguments: {α : Sort u_1} {σ : α → Sort u_2} (P : Prop) [Decidable P] (f : P → (a : α) → σ a) (g : ¬P → (a : α) → σ a) (a : α)
Goal: dite P f g a = if h : P then f h a else g h a
-- ite_apply
theorem ite_apply (f g : ∀ a, σ a) (a : α) : (ite P f g) a = ite P (f a) (g a) 
Arguments: {α : Sort u_1} {σ : α → Sort u_2} (P : Prop) [Decidable P] (f g : (a : α) → σ a) (a : α)
Goal: (if P then f else g) a = if P then f a else g a
-- ite_and
theorem ite_and : ite (P ∧ Q) a b = ite P (ite Q a b) b 
Arguments: {α : Sort u_1} (P Q : Prop) [Decidable P] [Decidable Q] (a b : α)
Goal: (if P ∧ Q then a else b) = if P then if Q then a else b else b
-- dite_dite_comm
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 
Arguments: {α : Sort u_1} (P Q : Prop) [Decidable P] [Decidable Q] {A : P → α} {B : Q → α} {C : ¬P → ¬Q → α} (h : 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
-- ite_ite_comm
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 
Arguments: {α : Sort u_1} (P Q : Prop) [Decidable P] [Decidable Q] (a b : α) {c : α} (h : P → ¬Q)
Goal: (if P then a else if Q then b else c) = if Q then b else if P then a else c
-- ite_prop_iff_or
theorem ite_prop_iff_or : (if P then Q else R) ↔ (P ∧ Q ∨ ¬ P ∧ R) 
Arguments: {P Q R : Prop} [Decidable P]
Goal: (if P then Q else R) ↔ P ∧ Q ∨ ¬P ∧ R
-- dite_prop_iff_or
theorem dite_prop_iff_or {Q : P → Prop} {R : ¬P → Prop} [Decidable P] :
    dite P Q R ↔ (∃ p, Q p) ∨ (∃ p, R p) 
Arguments: {P : Prop} {Q : P → Prop} {R : ¬P → Prop} [Decidable P]
Goal: dite P Q R ↔ (∃ p, Q p) ∨ ∃ p, R p
-- ite_prop_iff_and
theorem ite_prop_iff_and : (if P then Q else R) ↔ ((P → Q) ∧ (¬ P → R)) 
Arguments: {P Q R : Prop} [Decidable P]
Goal: (if P then Q else R) ↔ (P → Q) ∧ (¬P → R)
-- dite_prop_iff_and
theorem dite_prop_iff_and {Q : P → Prop} {R : ¬P → Prop} [Decidable P] :
    dite P Q R ↔ (∀ h, Q h) ∧ (∀ h, R h) 
Arguments: {P : Prop} {Q : P → Prop} {R : ¬P → Prop} [Decidable P]
Goal: dite P Q R ↔ (∀ (h : P), Q h) ∧ ∀ (h : ¬P), R h
-- not_beq_of_ne
theorem not_beq_of_ne {α : Type*} [BEq α] [LawfulBEq α] {a b : α} (ne : a ≠ b) : ¬(a == b) 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {a b : α} (ne : a ≠ b)
Goal: ¬(a == b) = true
-- beq_eq_decide
theorem beq_eq_decide {α : Type*} [BEq α] [LawfulBEq α] {a b : α} : (a == b) = decide (a = b) 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {a b : α}
Goal: (a == b) = decide (a = b)
-- beq_ext
@[ext]
theorem beq_ext {α : Type*} (inst1 : BEq α) (inst2 : BEq α)
    (h : ∀ x y, @BEq.beq _ inst1 x y = @BEq.beq _ inst2 x y) :
    inst1 = inst2 
Arguments: {α : Type u_1} (inst1 inst2 : BEq α) (h : ∀ (x y : α), (x == y) = (x == y))
Goal: inst1 = inst2
-- lawful_beq_subsingleton
theorem lawful_beq_subsingleton {α : Type*} (inst1 : BEq α) (inst2 : BEq α)
    [@LawfulBEq α inst1] [@LawfulBEq α inst2] :
    inst1 = inst2 
Arguments: {α : Type u_1} (inst1 inst2 : BEq α) [LawfulBEq α] [LawfulBEq α]
Goal: inst1 = inst2
-- Nat.coprime_mul_succ
lemma coprime_mul_succ {n m a} (h : n ≤ m) (ha : m - n ∣ a) : Coprime (n * a + 1) (m * a + 1) 
Arguments: {n m a : ℕ} (h : n ≤ m) (ha : m - n ∣ a)
Goal: (n * a + 1).Coprime (m * a + 1)
-- Nat.coprimes_lt
lemma coprimes_lt (a : Fin m → ℕ) (i) : a i < coprimes a i 
Arguments: {m : ℕ} (a : Fin m → ℕ) (i : Fin m)
Goal: a i < Nat.coprimes a i
-- _private.Mathlib.Logic.Godel.GodelBetaFunction.0.Nat.pairwise_coprime_coprimes
private lemma pairwise_coprime_coprimes (a : Fin m → ℕ) : Pairwise (Coprime on coprimes a) 
Arguments: {m : ℕ} (a : Fin m → ℕ)
Goal: Pairwise (Nat.Coprime on Nat.coprimes a)
-- Nat.beta_unbeta_coe
lemma beta_unbeta_coe (l : List ℕ) (i : Fin l.length) : beta (unbeta l) i = l.get i 
Arguments: (l : List ℕ) (i : Fin l.length)
Goal: (Nat.unbeta l).beta ↑i = l.get i
-- RegularExpression.zero_def
@[simp]
theorem zero_def : (zero : RegularExpression α) = 0 
Arguments: {α : Type u_1}
Goal: RegularExpression.zero = 0
-- RegularExpression.one_def
@[simp]
theorem one_def : (epsilon : RegularExpression α) = 1 
Arguments: {α : Type u_1}
Goal: RegularExpression.epsilon = 1
-- RegularExpression.plus_def
@[simp]
theorem plus_def (P Q : RegularExpression α) : plus P Q = P + Q 
Arguments: {α : Type u_1} (P Q : RegularExpression α)
Goal: P.plus Q = P + Q
-- RegularExpression.comp_def
@[simp]
theorem comp_def (P Q : RegularExpression α) : comp P Q = P * Q 
Arguments: {α : Type u_1} (P Q : RegularExpression α)
Goal: P.comp Q = P * Q
-- RegularExpression.matches'_zero
@[simp]
theorem matches'_zero : (0 : RegularExpression α).matches' = 0 
Arguments: {α : Type u_1}
Goal: RegularExpression.matches' 0 = 0
-- RegularExpression.matches'_epsilon
@[simp]
theorem matches'_epsilon : (1 : RegularExpression α).matches' = 1 
Arguments: {α : Type u_1}
Goal: RegularExpression.matches' 1 = 1
-- RegularExpression.matches'_char
@[simp]
theorem matches'_char (a : α) : (char a).matches' = {[a]} 
Arguments: {α : Type u_1} (a : α)
Goal: (RegularExpression.char a).matches' = {[a]}
-- RegularExpression.matches'_add
@[simp]
theorem matches'_add (P Q : RegularExpression α) : (P + Q).matches' = P.matches' + Q.matches' 
Arguments: {α : Type u_1} (P Q : RegularExpression α)
Goal: (P + Q).matches' = P.matches' + Q.matches'
-- RegularExpression.matches'_mul
@[simp]
theorem matches'_mul (P Q : RegularExpression α) : (P * Q).matches' = P.matches' * Q.matches' 
Arguments: {α : Type u_1} (P Q : RegularExpression α)
Goal: (P * Q).matches' = P.matches' * Q.matches'
-- RegularExpression.matches'_pow
@[simp]
theorem matches'_pow (P : RegularExpression α) : ∀ n : ℕ, (P ^ n).matches' = P.matches' ^ n
  
Arguments: {α : Type u_1} (P : RegularExpression α) (n : ℕ)
Goal: (P ^ n).matches' = P.matches' ^ n
-- RegularExpression.matches'_star
@[simp]
theorem matches'_star (P : RegularExpression α) : P.star.matches' = P.matches'∗ 
Arguments: {α : Type u_1} (P : RegularExpression α)
Goal: P.star.matches' = P.matches'∗
-- RegularExpression.deriv_zero
@[simp]
theorem deriv_zero (a : α) : deriv 0 a = 0 
Arguments: {α : Type u_1} [dec : DecidableEq α] (a : α)
Goal: RegularExpression.deriv 0 a = 0
-- RegularExpression.deriv_one
@[simp]
theorem deriv_one (a : α) : deriv 1 a = 0 
Arguments: {α : Type u_1} [dec : DecidableEq α] (a : α)
Goal: RegularExpression.deriv 1 a = 0
-- RegularExpression.deriv_char_self
@[simp]
theorem deriv_char_self (a : α) : deriv (char a) a = 1 
Arguments: {α : Type u_1} [dec : DecidableEq α] (a : α)
Goal: (RegularExpression.char a).deriv a = 1
-- RegularExpression.deriv_char_of_ne
@[simp]
theorem deriv_char_of_ne (h : a ≠ b) : deriv (char a) b = 0 
Arguments: {α : Type u_1} [dec : DecidableEq α] {a b : α} (h : a ≠ b)
Goal: (RegularExpression.char a).deriv b = 0
-- RegularExpression.deriv_add
@[simp]
theorem deriv_add (P Q : RegularExpression α) (a : α) : deriv (P + Q) a = deriv P a + deriv Q a 
Arguments: {α : Type u_1} [dec : DecidableEq α] (P Q : RegularExpression α) (a : α)
Goal: (P + Q).deriv a = P.deriv a + Q.deriv a
-- RegularExpression.deriv_star
@[simp]
theorem deriv_star (P : RegularExpression α) (a : α) : deriv P.star a = deriv P a * star P 
Arguments: {α : Type u_1} [dec : DecidableEq α] (P : RegularExpression α) (a : α)
Goal: P.star.deriv a = P.deriv a * P.star
-- RegularExpression.zero_rmatch
@[simp]
theorem zero_rmatch (x : List α) : rmatch 0 x = false 
Arguments: {α : Type u_1} [dec : DecidableEq α] (x : List α)
Goal: RegularExpression.rmatch 0 x = false
-- RegularExpression.one_rmatch_iff
theorem one_rmatch_iff (x : List α) : rmatch 1 x ↔ x = [] 
Arguments: {α : Type u_1} [dec : DecidableEq α] (x : List α)
Goal: RegularExpression.rmatch 1 x = true ↔ x = []
-- RegularExpression.char_rmatch_iff
theorem char_rmatch_iff (a : α) (x : List α) : rmatch (char a) x ↔ x = [a] 
Arguments: {α : Type u_1} [dec : DecidableEq α] (a : α) (x : List α)
Goal: (RegularExpression.char a).rmatch x = true ↔ x = [a]
-- RegularExpression.add_rmatch_iff
theorem add_rmatch_iff (P Q : RegularExpression α) (x : List α) :
    (P + Q).rmatch x ↔ P.rmatch x ∨ Q.rmatch x 
Arguments: {α : Type u_1} [dec : DecidableEq α] (P Q : RegularExpression α) (x : List α)
Goal: (P + Q).rmatch x = true ↔ P.rmatch x = true ∨ Q.rmatch x = true
-- RegularExpression.mul_rmatch_iff
theorem mul_rmatch_iff (P Q : RegularExpression α) (x : List α) :
    (P * Q).rmatch x ↔ ∃ t u : List α, x = t ++ u ∧ P.rmatch t ∧ Q.rmatch u 
Arguments: {α : Type u_1} [dec : DecidableEq α] (P Q : RegularExpression α) (x : List α)
Goal: (P * Q).rmatch x = true ↔ ∃ t u, x = t ++ u ∧ P.rmatch t = true ∧ Q.rmatch u = true
-- RegularExpression.star_rmatch_iff
theorem star_rmatch_iff (P : RegularExpression α) :
    ∀ x : List α, (star P).rmatch x ↔ ∃ S : List (List α), x
          = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t 
Arguments: {α : Type u_1} [dec : DecidableEq α] (P : RegularExpression α) (x : List α)
Goal: P.star.rmatch x = true ↔ ∃ S, x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
-- RegularExpression.rmatch_iff_matches'
@[simp]
theorem rmatch_iff_matches' (P : RegularExpression α) (x : List α) :
    P.rmatch x ↔ x ∈ P.matches' 
Arguments: {α : Type u_1} [dec : DecidableEq α] (P : RegularExpression α) (x : List α)
Goal: P.rmatch x = true ↔ x ∈ P.matches'
-- RegularExpression.map_pow
@[simp]
protected theorem map_pow (f : α → β) (P : RegularExpression α) :
    ∀ n : ℕ, map f (P ^ n) = map f P ^ n
  
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (P : RegularExpression α) (n : ℕ)
Goal: RegularExpression.map f (P ^ n) = RegularExpression.map f P ^ n
-- RegularExpression.map_id
@[simp]
theorem map_id : ∀ P : RegularExpression α, P.map id = P
  
Arguments: {α : Type u_1} (P : RegularExpression α)
Goal: RegularExpression.map id P = P
-- RegularExpression.map_map
@[simp]
theorem map_map (g : β → γ) (f : α → β) : ∀ P : RegularExpression α, (P.map f).map g = P.map (g ∘ f)
  
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (g : β → γ) (f : α → β) (P : RegularExpression α)
Goal: RegularExpression.map g (RegularExpression.map f P) = RegularExpression.map (g ∘ f) P
-- RegularExpression.matches'_map
@[simp]
theorem matches'_map (f : α → β) :
    ∀ P : RegularExpression α, (P.map f).matches' = Language.map f P.matches'
  
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (P : RegularExpression α)
Goal: (RegularExpression.map f P).matches' = (Language.map f) P.matches'
-- Relation.cutExpand_le_invImage_lex
theorem cutExpand_le_invImage_lex [DecidableEq α] [IsIrrefl α r] :
    CutExpand r ≤ InvImage (Finsupp.Lex (rᶜ ⊓ (· ≠ ·)) (· < ·)) toFinsupp 
Arguments: {α : Type u_1} {r : α → α → Prop} [DecidableEq α] [IsIrrefl α r]
Goal: Relation.CutExpand r ≤ InvImage (Finsupp.Lex (rᶜ ⊓ fun x x_1 => x ≠ x_1) fun x x_1 => x < x_1) ⇑Multiset.toFinsupp
-- Relation.cutExpand_singleton
theorem cutExpand_singleton {s x} (h : ∀ x' ∈ s, r x' x) : CutExpand r s {x} 
Arguments: {α : Type u_1} {r : α → α → Prop} {s : Multiset α} {x : α} (h : ∀ x' ∈ s, r x' x)
Goal: Relation.CutExpand r s {x}
-- Relation.cutExpand_singleton_singleton
theorem cutExpand_singleton_singleton {x' x} (h : r x' x) : CutExpand r {x'} {x} 
Arguments: {α : Type u_1} {r : α → α → Prop} {x' x : α} (h : r x' x)
Goal: Relation.CutExpand r {x'} {x}
-- Relation.cutExpand_add_left
theorem cutExpand_add_left {t u} (s) : CutExpand r (s + t) (s + u) ↔ CutExpand r t u 
Arguments: {α : Type u_1} {r : α → α → Prop} {t u : Multiset α} (s : Multiset α)
Goal: Relation.CutExpand r (s + t) (s + u) ↔ Relation.CutExpand r t u
-- Relation.cutExpand_add_right
lemma cutExpand_add_right {s' s} (t) : CutExpand r (s' + t) (s + t) ↔ CutExpand r s' s 
Arguments: {α : Type u_1} {r : α → α → Prop} {s' s : Multiset α} (t : Multiset α)
Goal: Relation.CutExpand r (s' + t) (s + t) ↔ Relation.CutExpand r s' s
-- Relation.cutExpand_iff
theorem cutExpand_iff [DecidableEq α] [IsIrrefl α r] {s' s : Multiset α} :
    CutExpand r s' s ↔
      ∃ (t : Multiset α) (a : α), (∀ a' ∈ t, r a' a) ∧ a ∈ s ∧ s' = s.erase a + t 
Arguments: {α : Type u_1} {r : α → α → Prop} [DecidableEq α] [IsIrrefl α r] {s' s : Multiset α}
Goal: Relation.CutExpand r s' s ↔ ∃ t a, (∀ a' ∈ t, r a' a) ∧ a ∈ s ∧ s' = s.erase a + t
-- Relation.not_cutExpand_zero
theorem not_cutExpand_zero [IsIrrefl α r] (s) : ¬CutExpand r s 0 
Arguments: {α : Type u_1} {r : α → α → Prop} [IsIrrefl α r] (s : Multiset α)
Goal: ¬Relation.CutExpand r s 0
-- Relation.cutExpand_zero
lemma cutExpand_zero {x} : CutExpand r 0 {x} 
Arguments: {α : Type u_1} {r : α → α → Prop} {x : α}
Goal: Relation.CutExpand r 0 {x}
-- Relation.cutExpand_fibration
theorem cutExpand_fibration (r : α → α → Prop) :
    Fibration (GameAdd (CutExpand r) (CutExpand r)) (CutExpand r) fun s ↦ s.1 + s.2 
Arguments: {α : Type u_1} (r : α → α → Prop)
Goal: Relation.Fibration (Prod.GameAdd (Relation.CutExpand r) (Relation.CutExpand r)) (Relation.CutExpand r) fun s =>
  s.1 + s.2
-- Relation.cutExpand_closed
lemma cutExpand_closed [IsIrrefl α r] (p : α → Prop)
    (h : ∀ {a' a}, r a' a → p a → p a') :
    ∀ {s' s}, CutExpand r s' s → (∀ a ∈ s, p a) → ∀ a ∈ s', p a 
Arguments: {α : Type u_1} {r : α → α → Prop} [IsIrrefl α r] (p : α → Prop) (h : ∀ {a' a : α}, r a' a → p a → p a') {s' s : Multiset α}
Goal: Relation.CutExpand r s' s → (∀ a ∈ s, p a) → ∀ a ∈ s', p a
-- Relation.cutExpand_double
lemma cutExpand_double {a a₁ a₂} (h₁ : r a₁ a) (h₂ : r a₂ a) : CutExpand r {a₁, a₂} {a} 
Arguments: {α : Type u_1} {r : α → α → Prop} {a a₁ a₂ : α} (h₁ : r a₁ a) (h₂ : r a₂ a)
Goal: Relation.CutExpand r {a₁, a₂} {a}
-- Relation.cutExpand_pair_left
lemma cutExpand_pair_left {a' a b} (hr : r a' a) : CutExpand r {a', b} {a, b} 
Arguments: {α : Type u_1} {r : α → α → Prop} {a' a b : α} (hr : r a' a)
Goal: Relation.CutExpand r {a', b} {a, b}
-- Relation.cutExpand_pair_right
lemma cutExpand_pair_right {a b' b} (hr : r b' b) : CutExpand r {a, b'} {a, b} 
Arguments: {α : Type u_1} {r : α → α → Prop} {a b' b : α} (hr : r b' b)
Goal: Relation.CutExpand r {a, b'} {a, b}
-- Relation.cutExpand_double_left
lemma cutExpand_double_left {a a₁ a₂ b} (h₁ : r a₁ a) (h₂ : r a₂ a) :
    CutExpand r {a₁, a₂, b} {a, b} 
Arguments: {α : Type u_1} {r : α → α → Prop} {a a₁ a₂ b : α} (h₁ : r a₁ a) (h₂ : r a₂ a)
Goal: Relation.CutExpand r {a₁, a₂, b} {a, b}
-- Relation.acc_of_singleton
theorem acc_of_singleton [IsIrrefl α r] {s : Multiset α} (hs : ∀ a ∈ s, Acc (CutExpand r) {a}) :
    Acc (CutExpand r) s 
Arguments: {α : Type u_1} {r : α → α → Prop} [IsIrrefl α r] {s : Multiset α} (hs : ∀ a ∈ s, Acc (Relation.CutExpand r) {a})
Goal: Acc (Relation.CutExpand r) s
-- Acc.cutExpand
theorem _root_.Acc.cutExpand [IsIrrefl α r] {a : α} (hacc : Acc r a) : Acc (CutExpand r) {a} 
Arguments: {α : Type u_1} {r : α → α → Prop} [IsIrrefl α r] {a : α} (hacc : Acc r a)
Goal: Acc (Relation.CutExpand r) {a}
-- WellFounded.cutExpand
theorem _root_.WellFounded.cutExpand (hr : WellFounded r) : WellFounded (CutExpand r) 
Arguments: {α : Type u_1} {r : α → α → Prop} (hr : WellFounded r)
Goal: WellFounded (Relation.CutExpand r)
-- IsEmpty.false
class IsEmpty (α : Sort*) : Prop where
  protected false : α → False
Arguments: {α : Sort u_4} [self : IsEmpty α]
Goal: α → False
-- Function.isEmpty
protected theorem Function.isEmpty [IsEmpty β] (f : α → β) : IsEmpty α 
Arguments: {α : Sort u_1} {β : Sort u_2} [IsEmpty β] (f : α → β)
Goal: IsEmpty α
-- Function.Surjective.isEmpty
theorem Function.Surjective.isEmpty [IsEmpty α] {f : α → β} (hf : f.Surjective) : IsEmpty β 
Arguments: {α : Sort u_1} {β : Sort u_2} [IsEmpty α] {f : α → β} (hf : Function.Surjective f)
Goal: IsEmpty β
-- Subtype.isEmpty_of_false
theorem Subtype.isEmpty_of_false {p : α → Prop} (hp : ∀ a, ¬p a) : IsEmpty (Subtype p) 
Arguments: {α : Sort u_1} {p : α → Prop} (hp : ∀ (a : α), ¬p a)
Goal: IsEmpty (Subtype p)
-- isEmpty_iff
theorem isEmpty_iff : IsEmpty α ↔ α → False 
Arguments: {α : Sort u_1}
Goal: IsEmpty α ↔ α → False
-- IsEmpty.prop_iff
protected theorem prop_iff {p : Prop} : IsEmpty p ↔ ¬p 
Arguments: {p : Prop}
Goal: IsEmpty p ↔ ¬p
-- IsEmpty.forall_iff
@[simp]
theorem forall_iff {p : α → Prop} : (∀ a, p a) ↔ True 
Arguments: {α : Sort u_1} [IsEmpty α] {p : α → Prop}
Goal: (∀ (a : α), p a) ↔ True
-- IsEmpty.exists_iff
@[simp]
theorem exists_iff {p : α → Prop} : (∃ a, p a) ↔ False 
Arguments: {α : Sort u_1} [IsEmpty α] {p : α → Prop}
Goal: (∃ a, p a) ↔ False
-- not_nonempty_iff
@[simp]
theorem not_nonempty_iff : ¬Nonempty α ↔ IsEmpty α 
Arguments: {α : Sort u_1}
Goal: ¬Nonempty α ↔ IsEmpty α
-- not_isEmpty_iff
@[simp]
theorem not_isEmpty_iff : ¬IsEmpty α ↔ Nonempty α 
Arguments: {α : Sort u_1}
Goal: ¬IsEmpty α ↔ Nonempty α
-- isEmpty_Prop
@[simp]
theorem isEmpty_Prop {p : Prop} : IsEmpty p ↔ ¬p 
Arguments: {p : Prop}
Goal: IsEmpty p ↔ ¬p
-- isEmpty_pi
@[simp]
theorem isEmpty_pi {π : α → Sort*} : IsEmpty (∀ a, π a) ↔ ∃ a, IsEmpty (π a) 
Arguments: {α : Sort u_1} {π : α → Sort u_4}
Goal: IsEmpty ((a : α) → π a) ↔ ∃ a, IsEmpty (π a)
-- isEmpty_fun
theorem isEmpty_fun : IsEmpty (α → β) ↔ Nonempty α ∧ IsEmpty β 
Arguments: {α : Sort u_1} {β : Sort u_2}
Goal: IsEmpty (α → β) ↔ Nonempty α ∧ IsEmpty β
-- nonempty_fun
@[simp]
theorem nonempty_fun : Nonempty (α → β) ↔ IsEmpty α ∨ Nonempty β 
Arguments: {α : Sort u_1} {β : Sort u_2}
Goal: Nonempty (α → β) ↔ IsEmpty α ∨ Nonempty β
-- isEmpty_sigma
@[simp]
theorem isEmpty_sigma {α} {E : α → Type*} : IsEmpty (Sigma E) ↔ ∀ a, IsEmpty (E a) 
Arguments: {α : Type u_5} {E : α → Type u_4}
Goal: IsEmpty (Sigma E) ↔ ∀ (a : α), IsEmpty (E a)
-- isEmpty_psigma
@[simp]
theorem isEmpty_psigma {α} {E : α → Sort*} : IsEmpty (PSigma E) ↔ ∀ a, IsEmpty (E a) 
Arguments: {α : Sort u_5} {E : α → Sort u_4}
Goal: IsEmpty (PSigma E) ↔ ∀ (a : α), IsEmpty (E a)
-- isEmpty_subtype
@[simp]
theorem isEmpty_subtype (p : α → Prop) : IsEmpty (Subtype p) ↔ ∀ x, ¬p x 
Arguments: {α : Sort u_1} (p : α → Prop)
Goal: IsEmpty (Subtype p) ↔ ∀ (x : α), ¬p x
-- isEmpty_prod
@[simp]
theorem isEmpty_prod {α β : Type*} : IsEmpty (α × β) ↔ IsEmpty α ∨ IsEmpty β 
Arguments: {α : Type u_4} {β : Type u_5}
Goal: IsEmpty (α × β) ↔ IsEmpty α ∨ IsEmpty β
-- isEmpty_pprod
@[simp]
theorem isEmpty_pprod : IsEmpty (PProd α β) ↔ IsEmpty α ∨ IsEmpty β 
Arguments: {α : Sort u_1} {β : Sort u_2}
Goal: IsEmpty (PProd α β) ↔ IsEmpty α ∨ IsEmpty β
-- isEmpty_sum
@[simp]
theorem isEmpty_sum {α β} : IsEmpty (α ⊕ β) ↔ IsEmpty α ∧ IsEmpty β 
Arguments: {α : Type u_4} {β : Type u_5}
Goal: IsEmpty (α ⊕ β) ↔ IsEmpty α ∧ IsEmpty β
-- isEmpty_psum
@[simp]
theorem isEmpty_psum {α β} : IsEmpty (α ⊕' β) ↔ IsEmpty α ∧ IsEmpty β 
Arguments: {α : Sort u_4} {β : Sort u_5}
Goal: IsEmpty (α ⊕' β) ↔ IsEmpty α ∧ IsEmpty β
-- isEmpty_ulift
@[simp]
theorem isEmpty_ulift {α} : IsEmpty (ULift α) ↔ IsEmpty α 
Arguments: {α : Type u_4}
Goal: IsEmpty (ULift.{u_5, u_4} α) ↔ IsEmpty α
-- isEmpty_plift
@[simp]
theorem isEmpty_plift {α} : IsEmpty (PLift α) ↔ IsEmpty α 
Arguments: {α : Sort u_4}
Goal: IsEmpty (PLift α) ↔ IsEmpty α
-- wellFounded_of_isEmpty
theorem wellFounded_of_isEmpty {α} [IsEmpty α] (r : α → α → Prop) : WellFounded r 
Arguments: {α : Sort u_4} [IsEmpty α] (r : α → α → Prop)
Goal: WellFounded r
-- isEmpty_or_nonempty
theorem isEmpty_or_nonempty : IsEmpty α ∨ Nonempty α 
Arguments: (α : Sort u_1)
Goal: IsEmpty α ∨ Nonempty α
-- not_isEmpty_of_nonempty
@[simp]
theorem not_isEmpty_of_nonempty [h : Nonempty α] : ¬IsEmpty α 
Arguments: (α : Sort u_1) [h : Nonempty α]
Goal: ¬IsEmpty α
-- Function.extend_of_isEmpty
theorem Function.extend_of_isEmpty [IsEmpty α] (f : α → β) (g : α → γ) (h : β → γ) :
    Function.extend f g h = h 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} [IsEmpty α] (f : α → β) (g : α → γ) (h : β → γ)
Goal: Function.extend f g h = h
-- EuclideanGeometry.continuousAt_oangle
theorem continuousAt_oangle {x : P × P × P} (hx12 : x.1 ≠ x.2.1) (hx32 : x.2.2 ≠ x.2.1) :
    ContinuousAt (fun y : P × P × P => ∡ y.1 y.2.1 y.2.2) x 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] [hd2 : Fact (FiniteDimensional.finrank ℝ V = 2)] [Module.Oriented ℝ V (Fin 2)] {x : P × P × P} (hx12 : x.1 ≠ x.2.1) (hx32 : x.2.2 ≠ x.2.1)
Goal: ContinuousAt (fun y => ∡ y.1 y.2.1 y.2.2) x
-- EuclideanGeometry.oangle_self_left
@[simp]
theorem oangle_self_left (p₁ p₂ : P) : ∡ p₁ p₁ p₂ = 0 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] [hd2 : Fact (FiniteDimensional.finrank ℝ V = 2)] [Module.Oriented ℝ V (Fin 2)] (p₁ p₂ : P)
Goal: ∡ p₁ p₁ p₂ = 0
-- EuclideanGeometry.oangle_self_right
@[simp]
theorem oangle_self_right (p₁ p₂ : P) : ∡ p₁ p₂ p₂ = 0 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] [hd2 : Fact (FiniteDimensional.finrank ℝ V = 2)] [Module.Oriented ℝ V (Fin 2)] (p₁ p₂ : P)
Goal: ∡ p₁ p₂ p₂ = 0
-- EuclideanGeometry.oangle_self_left_right
@[simp]
theorem oangle_self_left_right (p₁ p₂ : P) : ∡ p₁ p₂ p₁ = 0 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] [hd2 : Fact (FiniteDimensional.finrank ℝ V = 2)] [Module.Oriented ℝ V (Fin 2)] (p₁ p₂ : P)
Goal: ∡ p₁ p₂ p₁ = 0
-- EuclideanGeometry.left_ne_of_oangle_ne_zero
theorem left_ne_of_oangle_ne_zero {p₁ p₂ p₃ : P} (h : ∡ p₁ p₂ p₃ ≠ 0) : p₁ ≠ p₂ 
Arguments: {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] [hd2 : Fact (FiniteDimensional.finrank ℝ V = 2)] [Module.Oriented ℝ V (Fin 2)] {p₁ p₂ p₃ : P} (h : ∡ p₁ p₂ p₃ ≠ 0)
Goal: p₁ ≠ p₂