ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Order/Interval/Finset/Box.lean

full_name: Finset.box
code: /-- Hollow box centered at `0 : α` going from `-n` to `n`. -/
def box : ℕ → Finset α 
goal: ℕ → Finset α

full_name: _private.Mathlib.Order.Interval.Finset.Box.0.Finset.Icc_neg_mono
code: private lemma Icc_neg_mono : Monotone fun n : ℕ ↦ Icc (-n : α) n 
goal: Monotone fun n => Finset.Icc (-↑n) ↑n

full_name: Finset.box_zero
code: @[simp] lemma box_zero : (box 0 : Finset α) = {0} 
goal: Finset.box 0 = {0}

full_name: Finset.box_succ_eq_sdiff
code: lemma box_succ_eq_sdiff (n : ℕ) :
    box (n + 1) = Icc (-n.succ : α) n.succ \ Icc (-n) n 
goal: Finset.box (n + 1) = Finset.Icc (-↑n.succ) ↑n.succ \ Finset.Icc (-↑n) ↑n

full_name: Finset.disjoint_box_succ_prod
code: lemma disjoint_box_succ_prod (n : ℕ) : Disjoint (box (n + 1)) (Icc (-n : α) n) 
goal: Disjoint (Finset.box (n + 1)) (Finset.Icc (-↑n) ↑n)

full_name: Finset.box_succ_union_prod
code: @[simp] lemma box_succ_union_prod (n : ℕ) :
    box (n + 1) ∪ Icc (-n : α) n = Icc (-n.succ : α) n.succ 
goal: Finset.box (n + 1) ∪ Finset.Icc (-↑n) ↑n = Finset.Icc (-↑n.succ) ↑n.succ

full_name: Finset.box_succ_disjUnion
code: lemma box_succ_disjUnion (n : ℕ) :
    (box (n + 1)).disjUnion (Icc (-n : α) n) (disjoint_box_succ_prod _) =
      Icc (-n.succ : α) n.succ 
goal: (Finset.box (n + 1)).disjUnion (Finset.Icc (-↑n) ↑n) ⋯ = Finset.Icc (-↑n.succ) ↑n.succ

full_name: Finset.zero_mem_box
code: @[simp] lemma zero_mem_box : (0 : α) ∈ box n ↔ n = 0 
goal: 0 ∈ Finset.box n ↔ n = 0

full_name: Finset.eq_zero_iff_eq_zero_of_mem_box
code: lemma eq_zero_iff_eq_zero_of_mem_box  {x : α} (hx : x ∈ box n) : x = 0 ↔ n = 0 
goal: x = 0 ↔ n = 0

full_name: Prod.card_box_succ
code: @[simp] lemma card_box_succ (n : ℕ) :
    (box (n + 1) : Finset (α × β)).card =
      (Icc (-n.succ : α) n.succ).card * (Icc (-n.succ : β) n.succ).card -
        (Icc (-n : α) n).card * (Icc (-n : β) n).card 
goal: (Finset.box (n + 1)).card =
  (Finset.Icc (-↑n.succ) ↑n.succ).card * (Finset.Icc (-↑n.succ) ↑n.succ).card -
    (Finset.Icc (-↑n) ↑n).card * (Finset.Icc (-↑n) ↑n).card

full_name: Int.card_box
code: lemma card_box : ∀ {n}, n ≠ 0 → (box n : Finset (ℤ × ℤ)).card = 8 * n
  
goal: n ≠ 0 → (Finset.box n).card = 8 * n

full_name: Int.mem_box
code: @[simp] lemma mem_box : ∀ {n}, x ∈ box n ↔ max x.1.natAbs x.2.natAbs = n
  
goal: x ∈ Finset.box n ↔ max x.1.natAbs x.2.natAbs = n

full_name: Int.existsUnique_mem_box
code: lemma existsUnique_mem_box (x : ℤ × ℤ) : ∃! n : ℕ, x ∈ box n 
goal: ∃! n, x ∈ Finset.box n
File: Mathlib/Order/Monotone/Odd.lean

full_name: strictMono_of_odd_strictMonoOn_nonneg
code: /-- An odd function on a linear ordered additive commutative group is strictly monotone on the whole
group provided that it is strictly monotone on `Set.Ici 0`. -/
theorem strictMono_of_odd_strictMonoOn_nonneg {f : G → H} (h₁ : ∀ x, f (-x) = -f x)
    (h₂ : StrictMonoOn f (Ici 0)) : StrictMono f 
goal: StrictMono f

full_name: strictAnti_of_odd_strictAntiOn_nonneg
code: /-- An odd function on a linear ordered additive commutative group is strictly antitone on the whole
group provided that it is strictly antitone on `Set.Ici 0`. -/
theorem strictAnti_of_odd_strictAntiOn_nonneg {f : G → H} (h₁ : ∀ x, f (-x) = -f x)
    (h₂ : StrictAntiOn f (Ici 0)) : StrictAnti f 
goal: StrictAnti f

full_name: monotone_of_odd_of_monotoneOn_nonneg
code: /-- An odd function on a linear ordered additive commutative group is monotone on the whole group
provided that it is monotone on `Set.Ici 0`. -/
theorem monotone_of_odd_of_monotoneOn_nonneg {f : G → H} (h₁ : ∀ x, f (-x) = -f x)
    (h₂ : MonotoneOn f (Ici 0)) : Monotone f 
goal: Monotone f

full_name: antitone_of_odd_of_monotoneOn_nonneg
code: /-- An odd function on a linear ordered additive commutative group is antitone on the whole group
provided that it is monotone on `Set.Ici 0`. -/
theorem antitone_of_odd_of_monotoneOn_nonneg {f : G → H} (h₁ : ∀ x, f (-x) = -f x)
    (h₂ : AntitoneOn f (Ici 0)) : Antitone f 
goal: Antitone f
File: Mathlib/Order/Monotone/Union.lean

full_name: StrictMonoOn.union
code: /-- If `f` is strictly monotone both on `s` and `t`, with `s` to the left of `t` and the center
point belonging to both `s` and `t`, then `f` is strictly monotone on `s ∪ t` -/
protected theorem StrictMonoOn.union {s t : Set α} {c : α} (h₁ : StrictMonoOn f s)
    (h₂ : StrictMonoOn f t) (hs : IsGreatest s c) (ht : IsLeast t c) : StrictMonoOn f (s ∪ t) 
goal: StrictMonoOn f (s ∪ t)

full_name: StrictMonoOn.Iic_union_Ici
code: /-- If `f` is strictly monotone both on `(-∞, a]` and `[a, ∞)`, then it is strictly monotone on the
whole line. -/
protected theorem StrictMonoOn.Iic_union_Ici (h₁ : StrictMonoOn f (Iic a))
    (h₂ : StrictMonoOn f (Ici a)) : StrictMono f 
goal: StrictMono f

full_name: StrictAntiOn.union
code: /-- If `f` is strictly antitone both on `s` and `t`, with `s` to the left of `t` and the center
point belonging to both `s` and `t`, then `f` is strictly antitone on `s ∪ t` -/
protected theorem StrictAntiOn.union {s t : Set α} {c : α} (h₁ : StrictAntiOn f s)
    (h₂ : StrictAntiOn f t) (hs : IsGreatest s c) (ht : IsLeast t c) : StrictAntiOn f (s ∪ t) 
goal: StrictAntiOn f (s ∪ t)

full_name: StrictAntiOn.Iic_union_Ici
code: /-- If `f` is strictly antitone both on `(-∞, a]` and `[a, ∞)`, then it is strictly antitone on the
whole line. -/
protected theorem StrictAntiOn.Iic_union_Ici (h₁ : StrictAntiOn f (Iic a))
    (h₂ : StrictAntiOn f (Ici a)) : StrictAnti f 
goal: StrictAnti f

full_name: MonotoneOn.union_right
code: /-- If `f` is monotone both on `s` and `t`, with `s` to the left of `t` and the center
point belonging to both `s` and `t`, then `f` is monotone on `s ∪ t` -/
protected theorem MonotoneOn.union_right {s t : Set α} {c : α} (h₁ : MonotoneOn f s)
    (h₂ : MonotoneOn f t) (hs : IsGreatest s c) (ht : IsLeast t c) : MonotoneOn f (s ∪ t) 
goal: MonotoneOn f (s ∪ t)

full_name: MonotoneOn.Iic_union_Ici
code: /-- If `f` is monotone both on `(-∞, a]` and `[a, ∞)`, then it is monotone on the whole line. -/
protected theorem MonotoneOn.Iic_union_Ici (h₁ : MonotoneOn f (Iic a)) (h₂ : MonotoneOn f (Ici a)) :
    Monotone f 
goal: Monotone f

full_name: AntitoneOn.union_right
code: /-- If `f` is antitone both on `s` and `t`, with `s` to the left of `t` and the center
point belonging to both `s` and `t`, then `f` is antitone on `s ∪ t` -/
protected theorem AntitoneOn.union_right {s t : Set α} {c : α} (h₁ : AntitoneOn f s)
    (h₂ : AntitoneOn f t) (hs : IsGreatest s c) (ht : IsLeast t c) : AntitoneOn f (s ∪ t) 
goal: AntitoneOn f (s ∪ t)

full_name: AntitoneOn.Iic_union_Ici
code: /-- If `f` is antitone both on `(-∞, a]` and `[a, ∞)`, then it is antitone on the whole line. -/
protected theorem AntitoneOn.Iic_union_Ici (h₁ : AntitoneOn f (Iic a)) (h₂ : AntitoneOn f (Ici a)) :
    Antitone f 
goal: Antitone f
File: Mathlib/Order/Atoms/Finite.lean

full_name: IsSimpleOrder.instFintypeOfDecidableEq
code: instance (priority := 200) {α} [DecidableEq α] [LE α] [BoundedOrder α] [IsSimpleOrder α] :
    Fintype α 
goal: Fintype α

full_name: Fintype.IsSimpleOrder.univ
code: theorem univ : (Finset.univ : Finset α) = {⊤, ⊥} 
goal: Finset.univ = {⊤, ⊥}

full_name: Fintype.IsSimpleOrder.card
code: theorem card : Fintype.card α = 2 
goal: Fintype.card α = 2

full_name: Bool.instIsSimpleOrder
code: instance : IsSimpleOrder Bool 
goal: IsSimpleOrder Bool

full_name: Finite.to_isCoatomic
code: instance (priority := 100) Finite.to_isCoatomic [PartialOrder α] [OrderTop α] [Finite α] :
    IsCoatomic α 
goal: IsCoatomic α

full_name: Finite.to_isAtomic
code: instance (priority := 100) Finite.to_isAtomic [PartialOrder α] [OrderBot α] [Finite α] :
    IsAtomic α 
goal: IsAtomic α

full_name: instIsStronglyAtomic
code: instance : IsStronglyAtomic α 
goal: IsStronglyAtomic α

full_name: instIsStronglyCoatomic
code: instance : IsStronglyCoatomic α 
goal: IsStronglyCoatomic α

full_name: exists_covby_infinite_Ici_of_infinite_Ici
code: theorem exists_covby_infinite_Ici_of_infinite_Ici [IsStronglyAtomic α]
    (ha : (Set.Ici a).Infinite) (hfin : {x | a ⋖ x}.Finite) :
    ∃ b, a ⋖ b ∧ (Set.Ici b).Infinite 
goal: ∃ b, a ⋖ b ∧ (Set.Ici b).Infinite

full_name: exists_covby_infinite_Iic_of_infinite_Iic
code: theorem exists_covby_infinite_Iic_of_infinite_Iic [IsStronglyCoatomic α]
    (ha : (Set.Iic a).Infinite) (hfin : {x | x ⋖ a}.Finite) :
    ∃ b, b ⋖ a ∧ (Set.Iic b).Infinite 
goal: ∃ b, b ⋖ a ∧ (Set.Iic b).Infinite
File: Mathlib/Mathport/Attributes.lean

full_name: Lean.Attr.initFn._@.Mathlib.Mathport.Attributes._hyg.5
code: initialize substAttr : TagAttribute ← registerTagAttribute `subst "substitution"
goal: IO Lean.TagAttribute

full_name: Lean.Attr.substAttr
code: initialize substAttr : TagAttribute ← registerTagAttribute `subst "substitution"
goal: Lean.TagAttribute
File: Mathlib/Order/Monotone/Extension.lean

full_name: MonotoneOn.exists_monotone_extension
code: /-- If a function is monotone and is bounded on a set `s`, then it admits a monotone extension to
the whole space. -/
theorem MonotoneOn.exists_monotone_extension (h : MonotoneOn f s) (hl : BddBelow (f '' s))
    (hu : BddAbove (f '' s)) : ∃ g : α → β, Monotone g ∧ EqOn f g s 
goal: ∃ g, Monotone g ∧ Set.EqOn f g s

full_name: AntitoneOn.exists_antitone_extension
code: /-- If a function is antitone and is bounded on a set `s`, then it admits an antitone extension to
the whole space. -/
theorem AntitoneOn.exists_antitone_extension (h : AntitoneOn f s) (hl : BddBelow (f '' s))
    (hu : BddAbove (f '' s)) : ∃ g : α → β, Antitone g ∧ EqOn f g s 
goal: ∃ g, Antitone g ∧ Set.EqOn f g s
File: Mathlib/Init/Quot.lean

full_name: Quot.recOn'
code: @[inherit_doc Quot.rec, elab_as_elim] -- Porting note: adding `elab_as_elim`
protected abbrev Quot.recOn'
    (q : Quot r)
    (f : (a : α) → motive (Quot.mk r a))
    (h : (a b : α) → (p : r a b) → Eq.ndrec (f a) (Quot.sound p) = f b) :
    motive q 
goal: motive q

full_name: Quot.recOnSubsingleton'
code: /-- Version of `Quot.recOnSubsingleton` tagged with `elab_as_elim` -/
@[elab_as_elim] -- Porting note: this attribute is missing in core
protected abbrev Quot.recOnSubsingleton'
    [h : (a : α) → Subsingleton (motive (Quot.mk r a))]
    (q : Quot r)
    (f : (a : α) → motive (Quot.mk r a)) :
    motive q 
goal: motive q

full_name: Quotient.mk'_eq_mk
code: theorem Quotient.mk'_eq_mk [s : Setoid α] : Quotient.mk' = Quotient.mk s 
goal: Quotient.mk' = Quotient.mk s
File: Mathlib/Order/Radical.lean

full_name: Order.radical
code: /--
The infimum of all coatoms.

This notion specializes, e.g. in the subgroup lattice of a group to the Frattini subgroup,
or in the lattices of ideals in a ring `R` to the Jacobson ideal.
-/
def Order.radical (α : Type*) [Preorder α] [OrderTop α] [InfSet α] : α 
goal: α

full_name: Order.radical_le_coatom
code: lemma Order.radical_le_coatom {a : α} (h : IsCoatom a) : radical α ≤ a 
goal: Order.radical α ≤ a

full_name: OrderIso.map_radical
code: theorem OrderIso.map_radical (f : α ≃o β) : f (Order.radical α) = Order.radical β 
goal: f (Order.radical α) = Order.radical β

full_name: Order.radical_nongenerating
code: theorem Order.radical_nongenerating [IsCoatomic α] {a : α} (h : a ⊔ radical α = ⊤) : a = ⊤ 
goal: a = ⊤
File: Mathlib/Order/PrimeSeparator.lean

full_name: DistribLattice.mem_ideal_sup_principal
code: lemma mem_ideal_sup_principal (a b : α) (J : Ideal α) : b ∈ J ⊔ principal a ↔ ∃ j ∈ J, b ≤ j ⊔ a 
goal: b ∈ J ⊔ Order.Ideal.principal a ↔ ∃ j ∈ J, b ≤ j ⊔ a

full_name: DistribLattice.prime_ideal_of_disjoint_filter_ideal
code: theorem prime_ideal_of_disjoint_filter_ideal (hFI : Disjoint (F : Set α) (I : Set α)) :
    ∃ J : Ideal α, (IsPrime J) ∧ I ≤ J ∧ Disjoint (F : Set α) J 
goal: ∃ J, J.IsPrime ∧ I ≤ J ∧ Disjoint ↑F ↑J
File: Mathlib/Init/Core.lean

full_name: Prod.mk.injArrow
code: def Prod.mk.injArrow {α : Type u} {β : Type v} {x₁ : α} {y₁ : β} {x₂ : α} {y₂ : β} :
    (x₁, y₁) = (x₂, y₂) → ∀ ⦃P : Sort w⦄, (x₁ = x₂ → y₁ = y₂ → P) → P 
goal: (x₁, y₁) = (x₂, y₂) → ⦃P : Sort w⦄ → (x₁ = x₂ → y₁ = y₂ → P) → P

full_name: PProd.mk.injArrow
code: def PProd.mk.injArrow {α : Type u} {β : Type v} {x₁ : α} {y₁ : β} {x₂ : α} {y₂ : β} :
    (x₁, y₁) = (x₂, y₂) → ∀ ⦃P : Sort w⦄, (x₁ = x₂ → y₁ = y₂ → P) → P 
goal: (x₁, y₁) = (x₂, y₂) → ⦃P : Sort w⦄ → (x₁ = x₂ → y₁ = y₂ → P) → P

full_name: Combinator.I
code: def I (a : α) 
goal: α

full_name: Combinator.K
code: def K (a : α) (_b : β) 
goal: α

full_name: Combinator.S
code: def S (x : α → β → γ) (y : α → β) (z : α) 
goal: γ
File: Mathlib/Init/Data/Quot.lean

full_name: EqvGen.rel
code: /-- `EqvGen r` is the equivalence relation generated by `r`. -/
inductive EqvGen : α → α → Prop
  | rel : ∀ x y, r x y → EqvGen x y
  | refl : ∀ x, EqvGen x x
  | symm : ∀ x y, EqvGen x y → EqvGen y x
  | trans : ∀ x y z, EqvGen x y → EqvGen y z → EqvGen x z
goal: r x y → EqvGen r x y

full_name: EqvGen.trans
code: /-- `EqvGen r` is the equivalence relation generated by `r`. -/
inductive EqvGen : α → α → Prop
  | rel : ∀ x y, r x y → EqvGen x y
  | refl : ∀ x, EqvGen x x
  | symm : ∀ x y, EqvGen x y → EqvGen y x
  | trans : ∀ x y z, EqvGen x y → EqvGen y z → EqvGen x z
goal: EqvGen r x y → EqvGen r y z → EqvGen r x z

full_name: EqvGen
code: /-- `EqvGen r` is the equivalence relation generated by `r`. -/
inductive EqvGen : α → α → Prop
  | rel : ∀ x y, r x y → EqvGen x y
  | refl : ∀ x, EqvGen x x
  | symm : ∀ x y, EqvGen x y → EqvGen y x
  | trans : ∀ x y z, EqvGen x y → EqvGen y z → EqvGen x z
goal: α → α → Prop

full_name: EqvGen.symm
code: /-- `EqvGen r` is the equivalence relation generated by `r`. -/
inductive EqvGen : α → α → Prop
  | rel : ∀ x y, r x y → EqvGen x y
  | refl : ∀ x, EqvGen x x
  | symm : ∀ x y, EqvGen x y → EqvGen y x
  | trans : ∀ x y z, EqvGen x y → EqvGen y z → EqvGen x z
goal: EqvGen r x y → EqvGen r y x

full_name: EqvGen.refl
code: /-- `EqvGen r` is the equivalence relation generated by `r`. -/
inductive EqvGen : α → α → Prop
  | rel : ∀ x y, r x y → EqvGen x y
  | refl : ∀ x, EqvGen x x
  | symm : ∀ x y, EqvGen x y → EqvGen y x
  | trans : ∀ x y z, EqvGen x y → EqvGen y z → EqvGen x z
goal: EqvGen r x x

full_name: EqvGen.is_equivalence
code: theorem EqvGen.is_equivalence : Equivalence (@EqvGen α r) 
goal: Equivalence (EqvGen r)

full_name: EqvGen.Setoid
code: /-- `EqvGen.Setoid r` is the setoid generated by a relation `r`.

The motivation for this definition is that `Quot r` behaves like `Quotient (EqvGen.Setoid r)`,
see for example `Quot.exact` and `Quot.EqvGen_sound`.
-/
def EqvGen.Setoid : Setoid α 
goal: Setoid α

full_name: Quot.exact
code: theorem Quot.exact {a b : α} (H : Quot.mk r a = Quot.mk r b) : EqvGen r a b 
goal: EqvGen r a b

full_name: Quot.EqvGen_sound
code: theorem Quot.EqvGen_sound {r : α → α → Prop} {a b : α} (H : EqvGen r a b) :
    Quot.mk r a = Quot.mk r b 
goal: Quot.mk r a = Quot.mk r b

full_name: Quotient.decidableEq
code: instance Quotient.decidableEq {α : Sort u} {s : Setoid α} [d : ∀ a b : α, Decidable (a ≈ b)] :
    DecidableEq (Quotient s) 
goal: DecidableEq (Quotient s)
File: Mathlib/Init/Classical.lean

full_name: Classical.cases_true_false
code: @[elab_as_elim] theorem cases_true_false (p : Prop → Prop)
    (h1 : p True) (h2 : p False) (a : Prop) : p a 
goal: p a

full_name: Classical.cases_on
code: theorem cases_on (a : Prop) {p : Prop → Prop} (h1 : p True) (h2 : p False) : p a 
goal: p a

full_name: Classical.cases
code: theorem cases {p : Prop → Prop} (h1 : p True) (h2 : p False) (a) : p a 
goal: p a

full_name: Classical.eq_false_or_eq_true
code: theorem eq_false_or_eq_true (a : Prop) : a = False ∨ a = True 
goal: a = False ∨ a = True
File: Mathlib/Init/Data/List/Instances.lean

full_name: List.instMonad
code: instance instMonad : Monad List.{u} 
goal: Monad List

full_name: List.pure_def
code: @[simp] theorem pure_def (a : α) : pure a = [a] 
goal: pure a = [a]

full_name: List.instLawfulMonad
code: instance instLawfulMonad : LawfulMonad List.{u} 
goal: LawfulMonad List

full_name: List.instAlternative
code: instance instAlternative : Alternative List.{u} 
goal: Alternative List
File: Mathlib/Init/Data/List/Basic.lean

full_name: List.headI
code: /-- The head of a list, or the default element of the type is the list is `nil`. -/
def headI [Inhabited α] : List α → α
  
goal: List α → α

full_name: List.headI_nil
code: @[simp] theorem headI_nil [Inhabited α] : ([] : List α).headI = default 
goal: [].headI = default

full_name: List.headI_cons
code: @[simp] theorem headI_cons [Inhabited α] {h : α} {t : List α} : (h :: t).headI = h 
goal: (h :: t).headI = h

full_name: List.getLastI
code: /-- The last element of a list, with the default if list empty -/
def getLastI [Inhabited α] : List α → α
  
goal: List α → α

full_name: List.ret
code: /-- List with a single given element. -/
@[inline, deprecated List.pure (since := "2024-03-24")]
protected def ret {α : Type u} (a : α) : List α 
goal: List α

full_name: List.le_eq_not_gt
code: /-- `≤` implies not `>` for lists. -/
theorem le_eq_not_gt [LT α] : ∀ l₁ l₂ : List α, (l₁ ≤ l₂) = ¬l₂ < l₁ 
goal: (l₁ ≤ l₂) = ¬l₂ < l₁
File: Mathlib/Init/Data/Sigma/Lex.lean

full_name: PSigma.lex_wf
code: /-- The lexicographical order of well-founded relations is well-founded. -/
theorem lex_wf (ha : WellFounded r) (hb : ∀ x, WellFounded (s x)) : WellFounded (Lex r s) 
goal: WellFounded (PSigma.Lex r s)

full_name: PSigma.revLex_wf
code: theorem revLex_wf (ha : WellFounded r) (hb : WellFounded s) : WellFounded (RevLex r s) 
goal: WellFounded (PSigma.RevLex r s)

full_name: PSigma.skipLeft_wf
code: theorem skipLeft_wf (α : Type u) {β : Type v} {s : β → β → Prop} (hb : WellFounded s) :
    WellFounded (SkipLeft α s) 
goal: WellFounded (PSigma.SkipLeft α s)

full_name: PSigma.hasWellFounded
code: instance hasWellFounded {α : Type u} {β : α → Type v} [s₁ : WellFoundedRelation α]
    [s₂ : ∀ a, WellFoundedRelation (β a)] : WellFoundedRelation (PSigma β) 
goal: WellFoundedRelation (PSigma β)
File: Mathlib/Init/Data/Sigma/Basic.lean

full_name: ex_of_psig
code: theorem ex_of_psig {α : Sort u} {p : α → Prop} : (Σ' x, p x) → ∃ x, p x
  
goal: (x : α) ×' p x → ∃ x, p x

full_name: Sigma.eq
code: protected theorem Sigma.eq {α : Type u} {β : α → Type v} : ∀ {p₁ p₂ : Σ a, β a} (h₁ : p₁.1 = p₂.1),
    (Eq.recOn h₁ p₁.2 : β p₂.1) = p₂.2 → p₁ = p₂
  
goal: Eq.recOn h₁ p₁.snd = p₂.snd → p₁ = p₂

full_name: PSigma.eq
code: protected theorem PSigma.eq {α : Sort u} {β : α → Sort v} : ∀ {p₁ p₂ : Σ' a, β a} (h₁ : p₁.1 = p₂.1),
    (Eq.recOn h₁ p₁.2 : β p₂.1) = p₂.2 → p₁ = p₂
  
goal: Eq.recOn h₁ p₁.snd = p₂.snd → p₁ = p₂
File: Mathlib/Init/Data/List/Lemmas.lean

full_name: List.mem_cons_eq
code: theorem mem_cons_eq (a y : α) (l : List α) : (a ∈ y :: l) = (a = y ∨ a ∈ l) 
goal: (a ∈ y :: l) = (a = y ∨ a ∈ l)

full_name: List.not_exists_mem_nil
code: theorem not_exists_mem_nil (p : α → Prop) : ¬∃ x ∈ @nil α, p x 
goal: ¬∃ x, x ∈ [] ∧ p x

full_name: List.mapAccumr
code: /-- Runs a function over a list returning the intermediate results and a final result. -/
def mapAccumr (f : α → σ → σ × β) : List α → σ → σ × List β
  
goal: List α → σ → σ × List β

full_name: List.length_mapAccumr
code: /-- Length of the list obtained by `mapAccumr`. -/
@[simp]
theorem length_mapAccumr :
    ∀ (f : α → σ → σ × β) (x : List α) (s : σ), length (mapAccumr f x s).2 = length x
  
goal: (List.mapAccumr f x s).snd.length = x.length

full_name: List.mapAccumr₂
code: /-- Runs a function over two lists returning the intermediate results and a final result. -/
def mapAccumr₂ (f : α → β → σ → σ × φ) : List α → List β → σ → σ × List φ
  
goal: List α → List β → σ → σ × List φ

full_name: List.length_mapAccumr₂
code: /-- Length of a list obtained using `mapAccumr₂`. -/
@[simp]
theorem length_mapAccumr₂ :
    ∀ (f : α → β → σ → σ × φ) (x y c), length (mapAccumr₂ f x y c).2 = min (length x) (length y)
  
goal: (List.mapAccumr₂ f x y c).snd.length = min x.length y.length
File: Mathlib/Init/Data/Fin/Basic.lean

full_name: Fin.eq_of_veq
code: @[deprecated eq_of_val_eq (since := "2024-02-15")]
theorem eq_of_veq : i.val = j.val → i = j 
goal: ↑i = ↑j → i = j

full_name: Fin.veq_of_eq
code: @[deprecated val_eq_of_eq (since := "2024-02-15")]
theorem veq_of_eq : i = j → i.val = j.val 
goal: i = j → ↑i = ↑j

full_name: Fin.ne_of_vne
code: theorem ne_of_vne (h : i.val ≠ j.val) : i ≠ j 
goal: i ≠ j

full_name: Fin.vne_of_ne
code: theorem vne_of_ne (h : i ≠ j) : i.val ≠ j.val 
goal: ↑i ≠ ↑j
File: Mathlib/Init/Data/Nat/GCD.lean

full_name: Nat.gcd_def
code: theorem gcd_def (x y : ℕ) : gcd x y = if x = 0 then y else gcd (y % x) x 
goal: x.gcd y = if x = 0 then y else (y % x).gcd x
File: Mathlib/Init/Data/Int/Order.lean

full_name: Int.le.elim
code: theorem le.elim {a b : ℤ} (h : a ≤ b) {P : Prop} (h' : ∀ n : ℕ, a + ↑n = b → P) : P 
goal: P

full_name: Int.lt.elim
code: theorem lt.elim {a b : ℤ} (h : a < b) {P : Prop} (h' : ∀ n : ℕ, a + ↑(Nat.succ n) = b → P) : P 
goal: P

full_name: Int.instLinearOrder
code: instance instLinearOrder : LinearOrder ℤ 
goal: LinearOrder ℤ

full_name: Int.neg_mul_eq_neg_mul_symm
code: theorem neg_mul_eq_neg_mul_symm (a b : ℤ) : -a * b = -(a * b) 
goal: -a * b = -(a * b)

full_name: Int.mul_neg_eq_neg_mul_symm
code: theorem mul_neg_eq_neg_mul_symm (a b : ℤ) : a * -b = -(a * b) 
goal: a * -b = -(a * b)

full_name: Int.eq_zero_or_eq_zero_of_mul_eq_zero
code: protected theorem eq_zero_or_eq_zero_of_mul_eq_zero {a b : ℤ} (h : a * b = 0) : a = 0 ∨ b = 0 
goal: a = 0 ∨ b = 0
File: Mathlib/Init/Data/Nat/Lemmas.lean

full_name: Nat.eq_zero_of_mul_eq_zero
code: theorem eq_zero_of_mul_eq_zero : ∀ {n m : ℕ}, n * m = 0 → n = 0 ∨ m = 0
  
goal: n * m = 0 → n = 0 ∨ m = 0

full_name: Nat.ltGeByCases
code: protected def ltGeByCases {a b : ℕ} {C : Sort u} (h₁ : a < b → C) (h₂ : b ≤ a → C) : C 
goal: C

full_name: Nat.ltByCases
code: protected def ltByCases {a b : ℕ} {C : Sort u} (h₁ : a < b → C) (h₂ : a = b → C) (h₃ : b < a → C) :
    C 
goal: C

full_name: Nat.discriminate
code: def discriminate {B : Sort u} {n : ℕ} (H1 : n = 0 → B) (H2 : ∀ m, n = succ m → B) : B 
goal: B

full_name: Nat.one_eq_succ_zero
code: theorem one_eq_succ_zero : 1 = succ 0 
goal: 1 = Nat.succ 0

full_name: Nat.twoStepInduction
code: def twoStepInduction {P : ℕ → Sort u} (H1 : P 0) (H2 : P 1)
    (H3 : ∀ (n : ℕ) (_IH1 : P n) (_IH2 : P (succ n)), P (succ (succ n))) : ∀ a : ℕ, P a
  
goal: P a

full_name: Nat.subInduction
code: def subInduction {P : ℕ → ℕ → Sort u} (H1 : ∀ m, P 0 m) (H2 : ∀ n, P (succ n) 0)
    (H3 : ∀ n m, P n m → P (succ n) (succ m)) : ∀ n m : ℕ, P n m
  
goal: P n m

full_name: Nat.strong_induction_on
code: @[elab_as_elim]
protected theorem strong_induction_on {p : Nat → Prop} (n : Nat)
    (h : ∀ n, (∀ m, m < n → p m) → p n) : p n 
goal: p n

full_name: Nat.case_strong_induction_on
code: protected theorem case_strong_induction_on {p : Nat → Prop} (a : Nat) (hz : p 0)
    (hi : ∀ n, (∀ m, m ≤ n → p m) → p (succ n)) : p a 
goal: p a

full_name: Nat.cond_decide_mod_two
code: theorem cond_decide_mod_two (x : ℕ) [d : Decidable (x % 2 = 1)] :
    cond (@decide (x % 2 = 1) d) 1 0 = x % 2 
goal: (bif decide (x % 2 = 1) then 1 else 0) = x % 2
File: Mathlib/NumberTheory/Basic.lean

full_name: dvd_sub_pow_of_dvd_sub
code: theorem dvd_sub_pow_of_dvd_sub {R : Type*} [CommRing R] {p : ℕ} {a b : R} (h : (p : R) ∣ a - b)
    (k : ℕ) : (p ^ (k + 1) : R) ∣ a ^ p ^ k - b ^ p ^ k 
goal: ↑p ^ (k + 1) ∣ a ^ p ^ k - b ^ p ^ k
File: Mathlib/NumberTheory/DirichletCharacter/Bounds.lean

full_name: DirichletCharacter.unit_norm_eq_one
code: /-- The value at a unit of a Dirichlet character with target a normed field has norm `1`. -/
@[simp] lemma unit_norm_eq_one (a : (ZMod n)ˣ) : ‖χ a‖ = 1 
goal: ‖χ ↑a‖ = 1

full_name: DirichletCharacter.norm_le_one
code: /-- The values of a Dirichlet character with target a normed field have norm bounded by `1`. -/
lemma norm_le_one (a : ZMod n) : ‖χ a‖ ≤ 1 
goal: ‖χ a‖ ≤ 1