ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/Idempotents.lean
lemma CompleteOrthogonalIdempotents.single {I : Type*} [Fintype I] [DecidableEq I]
    (R : I → Type*) [∀ i, Ring (R i)] :
    CompleteOrthogonalIdempotents (Pi.single (f := R) · 1)
-- Mathlib/CategoryTheory/GlueData.lean
@[simp]
theorem diagram_fst (i j : D.J) : D.diagram.fst ⟨i, j⟩ = D.f i j
-- Mathlib/Algebra/Module/Submodule/Basic.lean
theorem not_mem_of_ortho {x : M} {N : Submodule R M}
    (ortho : ∀ (c : R), ∀ y ∈ N, c • x + y = (0 : M) → c = 0) : x ∉ N
-- Mathlib/Algebra/Lie/Weights/RootSystem.lean
lemma chainLength_smul {x} (hx : x ∈ rootSpace H (chainTop α β)) :
    (chainLength α β : K) • x = ⁅coroot α, x⁆
-- Mathlib/GroupTheory/Complement.lean
theorem equiv_fst_eq_one_of_mem_of_one_mem {g : G} (h1 : 1 ∈ S) (hg : g ∈ T) :
    (hST.equiv g).fst = ⟨1, h1⟩
-- Mathlib/Algebra/Algebra/Operations.lean
theorem pow_toAddSubmonoid {n : ℕ} (h : n ≠ 0) : (M ^ n).toAddSubmonoid = M.toAddSubmonoid ^ n
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
/-- The singleton prepartition `{J}`, `J ≤ I`. -/
@[simps]
def single (I J : Box ι) (h : J ≤ I) : Prepartition I
-- Mathlib/Algebra/Associated/Basic.lean
@[simp] protected theorem le_zero (a : Associates α) : a ≤ 0
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
theorem inl_snd' {b : BinaryBicone X Y} (h : b.IsBilimit) :
    IsPullback b.inl (0 : X ⟶ 0) b.snd (0 : 0 ⟶ Y)
-- Mathlib/Algebra/FreeAlgebra.lean
@[simp]
theorem quot_mk_eq_ι (m : X) : Quot.mk (FreeAlgebra.Rel R X) m = ι R m
-- Mathlib/Order/UpperLower/Basic.lean
theorem isLowerSet_Iio : IsLowerSet (Iio a)
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
theorem fderivWithin_neg (hxs : UniqueDiffWithinAt 𝕜 s x) :
    fderivWithin 𝕜 (fun y => -f y) s x = -fderivWithin 𝕜 f s x
-- Mathlib/Algebra/Order/Field/Power.lean
theorem Odd.zpow_nonpos_iff (hn : Odd n) : a ^ n ≤ 0 ↔ a ≤ 0
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atBot_of_add_const_left (C : β) (hf : Tendsto (fun x => C + f x) l atBot) :
    Tendsto f l atBot
-- Mathlib/Data/Rat/Lemmas.lean
theorem inv_natCast_den_of_pos {a : ℕ} (ha0 : 0 < a) : (a : ℚ)⁻¹.den = a
-- Mathlib/Analysis/BoxIntegral/Box/Basic.lean
protected theorem Ioo_subset_Icc (I : Box ι) : Box.Ioo I ⊆ Box.Icc I
-- Mathlib/Topology/Homotopy/Path.lean
theorem hcomp_half (F : Homotopy p₀ q₀) (G : Homotopy p₁ q₁) (t : I) :
    F.hcomp G (t, ⟨1 / 2, by norm_num, by norm_num⟩) = x₁
-- Mathlib/Data/Sigma/Basic.lean
@[simp]
theorem Sigma.uncurry_curry {γ : ∀ a, β a → Type*} (f : ∀ x : Sigma β, γ x.1 x.2) :
    Sigma.uncurry (Sigma.curry f) = f
-- Mathlib/Data/Complex/Abs.lean
lemma re_neg_ne_zero_of_one_lt_re {s : ℂ} (hs : 1 < s.re) : (-s).re ≠ 0
-- Mathlib/Data/Nat/Log.lean
theorem lt_pow_succ_log_self {b : ℕ} (hb : 1 < b) (x : ℕ) : x < b ^ (log b x).succ
-- Mathlib/Data/Seq/Computation.lean
@[simp]
theorem get_bind (s : Computation α) (f : α → Computation β) [Terminates s]
    [Terminates (f (get s))] : get (bind s f) = get (f (get s))
-- Mathlib/GroupTheory/Perm/DomMulAct.lean
lemma mem_stabilizer_iff {g : (Perm α)ᵈᵐᵃ} :
    g ∈ stabilizer (Perm α)ᵈᵐᵃ f ↔ f ∘ (mk.symm g :) = f
-- .lake/packages/lean4/src/lean/Init/Classical.lean
/-- Show that an element extracted from `P : ∃ a, p a` using `P.choose` satisfies `p`. -/
theorem Exists.choose_spec {p : α → Prop} (P : ∃ a, p a) : p P.choose
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem one_out_eq (x : (1 : Ordinal).out.α) : x = enum (· < ·) 0 (by simp)
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem eq_of_eqOn_set_top {f g : R →ₙ+* S} (h : Set.EqOn f g (⊤ : NonUnitalSubring R)) : f = g
-- Mathlib/Probability/Kernel/Composition.lean
@[simp]
theorem prodMkRight_apply (κ : Kernel α β) (ca : α × γ) : prodMkRight γ κ ca = κ ca.fst
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean
/-- If a continuous linear map is constructed from a linear map via the constructor `mkContinuous`,
then its norm is bounded by the bound given to the constructor if it is nonnegative. -/
theorem mkContinuous_norm_le (f : E →ₛₗ[σ₁₂] F) {C : ℝ} (hC : 0 ≤ C) (h : ∀ x, ‖f x‖ ≤ C * ‖x‖) :
    ‖f.mkContinuous C h‖ ≤ C
-- Mathlib/Data/Prod/Basic.lean
theorem fst_surjective [h : Nonempty β] : Function.Surjective (@fst α β)
-- .lake/packages/lean4/src/lean/lake/Lake/Util/Name.lean
theorem quickCmp_rfl {n : Name} : n.quickCmp n = .eq
-- Mathlib/CategoryTheory/Limits/Opposites.lean
theorem hasColimitsOfShape_of_hasLimitsOfShape_op [HasLimitsOfShape Jᵒᵖ Cᵒᵖ] :
    HasColimitsOfShape J C
-- Mathlib/Order/Filter/Basic.lean
theorem eventually_imp_distrib_right {f : Filter α} {p : α → Prop} {q : Prop} :
    (∀ᶠ x in f, p x → q) ↔ (∃ᶠ x in f, p x) → q
-- Mathlib/Analysis/SpecificLimits/Normed.lean
/-- Partial sums of an alternating monotone series with an even number of terms provide
upper bounds on the limit. -/
theorem Monotone.tendsto_le_alternating_series
    (hfl : Tendsto (fun n ↦ ∑ i ∈ range n, (-1) ^ i * f i) atTop (𝓝 l))
    (hfm : Monotone f) (k : ℕ) : l ≤ ∑ i ∈ range (2 * k), (-1) ^ i * f i
-- Mathlib/Order/Filter/ZeroAndBoundedAtFilter.lean
nonrec theorem BoundedAtFilter.mul [SeminormedRing β] {l : Filter α} {f g : α → β}
    (hf : BoundedAtFilter l f) (hg : BoundedAtFilter l g) : BoundedAtFilter l (f * g)
-- Mathlib/Algebra/BigOperators/Group/List.lean
lemma sum_nat_mod (l : List ℕ) (n : ℕ) : l.sum % n = (l.map (· % n)).sum % n
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
theorem IsAdjointPair.smul (c : R) (h : IsAdjointPair B B₂' f₂ g₂) :
    IsAdjointPair B B₂' (c • f₂) (c • g₂)
-- Mathlib/Tactic/ReduceModChar.lean
lemma CharP.neg_mul_eq_sub_one_mul {α : Type _} [Ring α] (n : ℕ) (inst : CharP α n) (a b : α)
    (na : ℕ) (na' : α) (p : IsNat ((n - 1) * a : α) na) (pa : na = na') :
    -(a * b) = na' * b
-- Mathlib/Order/FixedPoints.lean
theorem isLeast_lfp : IsLeast (fixedPoints f) (lfp f)
-- Mathlib/Probability/Kernel/Condexp.lean
theorem _root_.MeasureTheory.AEStronglyMeasurable.comp_snd_map_prod_id [TopologicalSpace F]
    (hm : m ≤ mΩ) (hf : AEStronglyMeasurable f μ) : AEStronglyMeasurable (fun x : Ω × Ω => f x.2)
      (@Measure.map Ω (Ω × Ω) (m.prod mΩ) mΩ (fun ω => (id ω, id ω)) μ)
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
lemma ker_Pi_Quotient_mk {ι : Type*} (I : ι → Ideal R) :
    ker (Pi.ringHom fun i : ι ↦ Quotient.mk (I i)) = ⨅ i, I i
-- Mathlib/Topology/Compactness/Compact.lean
/-- A filter `l` is disjoint with the neighborhood filter of a compact set if and only if it is
disjoint with the neighborhood filter of each point of this set. -/
theorem IsCompact.disjoint_nhdsSet_right {l : Filter X} (hs : IsCompact s) :
    Disjoint l (𝓝ˢ s) ↔ ∀ x ∈ s, Disjoint l (𝓝 x)
-- Mathlib/CategoryTheory/Monoidal/NaturalTransformation.lean
/-- Vertical composition of monoidal natural transformations. -/
@[simps!]
def vcomp {F G H : LaxMonoidalFunctor C D} (α : MonoidalNatTrans F G) (β : MonoidalNatTrans G H) :
    MonoidalNatTrans F H
-- Mathlib/Data/Analysis/Topology.lean
theorem locallyFinite_iff_exists_realizer [TopologicalSpace α] (F : Ctop.Realizer α)
    {f : β → Set α} : LocallyFinite f ↔ Nonempty (LocallyFinite.Realizer F f)
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[simp]
theorem coe_copy (S : Subring R) (s : Set R) (hs : s = ↑S) : (S.copy s hs : Set R) = s
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
lemma map_preΨ' (n : ℕ) : (W.map f).preΨ' n = (W.preΨ' n).map f
-- Mathlib/Data/Finset/PImage.lean
@[simp]
theorem pimage_empty : pimage f ∅ = ∅
-- Mathlib/Topology/Separation.lean
theorem isPreirreducible_iff_subsingleton [T2Space X] {S : Set X} :
    IsPreirreducible S ↔ S.Subsingleton
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem setIntegral_withDensity_eq_setIntegral_smul {f : X → ℝ≥0} (f_meas : Measurable f)
    (g : X → E) {s : Set X} (hs : MeasurableSet s) :
    ∫ x in s, g x ∂μ.withDensity (fun x => f x) = ∫ x in s, f x • g x ∂μ
-- Mathlib/Analysis/Seminorm.lean
protected theorem sSup_apply {s : Set (Seminorm 𝕜 E)} (hp : BddAbove s) {x : E} :
    (sSup s) x = ⨆ p : s, (p : E → ℝ) x
-- Mathlib/Data/Finset/Lattice.lean
@[simp]
theorem sup_bot (s : Finset β) : (s.sup fun _ => ⊥) = (⊥ : α)
-- Mathlib/MeasureTheory/Integral/TorusIntegral.lean
theorem torusIntegral_radius_zero (hn : n ≠ 0) (f : ℂⁿ → E) (c : ℂⁿ) :
    (∯ x in T(c, 0), f x) = 0
-- Mathlib/RingTheory/Polynomial/Hermite/Basic.lean
theorem hermite_one : hermite 1 = X
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
/-- The difference with `NonUnitalAlgebra.adjoin_induction` is that this acts on the subtype. -/
@[elab_as_elim]
lemma adjoin_induction_subtype {s : Set A} {p : adjoin R s → Prop} (a : adjoin R s)
    (mem : ∀ x (h : x ∈ s), p ⟨x, subset_adjoin R h⟩)
    (add : ∀ x y, p x → p y → p (x + y)) (zero : p 0)
    (mul : ∀ x y, p x → p y → p (x * y)) (smul : ∀ (r : R) x, p x → p (r • x)) : p a
-- Mathlib/Order/LiminfLimsup.lean
theorem isBoundedUnder_ge_finset_inf' [LinearOrder β] [Nonempty β] {f : Filter α} {F : ι → α → β}
    {s : Finset ι} (hs : s.Nonempty) (h : ∀ i ∈ s, f.IsBoundedUnder (· ≥ ·) (F i)) :
    f.IsBoundedUnder (· ≥ ·) (fun a ↦ inf' s hs (fun i ↦ F i a))
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem symm_toHomeomorph (e : M₁ ≃SL[σ₁₂] M₂) : e.toHomeomorph.symm = e.symm.toHomeomorph
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem dvd_lcm_right [GCDMonoid α] (a b : α) : b ∣ lcm a b
-- Mathlib/Data/Rel.lean
theorem Relation.is_graph_iff (r : Rel α β) : (∃! f, Function.graph f = r) ↔ ∀ x, ∃! y, r x y
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem monic_of_isUnit_leadingCoeff_inv_smul (h : IsUnit p.leadingCoeff) :
    Monic (h.unit⁻¹ • p)
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem normalize_eq_normalize_iff {x y : α} : normalize x = normalize y ↔ x ∣ y ∧ y ∣ x
-- .lake/packages/lean4/src/lean/Init/Omega/Coeffs.lean
theorem dot_nil_right {xs : Coeffs} : dot xs .nil = 0
-- Mathlib/Analysis/SpecialFunctions/Gamma/Beta.lean
/-- Euler's reflection formula for the complex Gamma function. -/
theorem Gamma_mul_Gamma_one_sub (z : ℂ) : Gamma z * Gamma (1 - z) = π / sin (π * z)
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
@[fun_prop]
theorem Set.Subsingleton.differentiableOn (hs : s.Subsingleton) : DifferentiableOn 𝕜 f s
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_star_id : cfc (star · : R → R) a = star a
-- Mathlib/Data/Rat/Defs.lean
protected lemma zero_add : 0 + a = a
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
@[simp]
theorem coe_le_coe {I J : FractionalIdeal S P} :
    (I : Submodule R P) ≤ (J : Submodule R P) ↔ I ≤ J
-- Mathlib/Computability/Reduce.lean
@[simp]
theorem manyOneEquiv_toNat (p : Set α) (q : Set β) :
    ManyOneEquiv (toNat p) (toNat q) ↔ ManyOneEquiv p q
-- Mathlib/Algebra/Order/Floor.lean
theorem ceil_add_one (ha : 0 ≤ a) : ⌈a + 1⌉₊ = ⌈a⌉₊ + 1
-- Mathlib/Algebra/Module/Submodule/EqLocus.lean
theorem le_eqLocus {f g : F} {S : Submodule R M} : S ≤ eqLocus f g ↔ Set.EqOn f g S
-- Mathlib/Data/Nat/Factorization/Basic.lean
theorem Ico_filter_pow_dvd_eq {n p b : ℕ} (pp : p.Prime) (hn : n ≠ 0) (hb : n ≤ p ^ b) :
    ((Ico 1 n).filter fun i => p ^ i ∣ n) = (Icc 1 b).filter fun i => p ^ i ∣ n
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
@[simp]
theorem mem_basicOpen (f : A) (x : ProjectiveSpectrum 𝒜) :
    x ∈ basicOpen 𝒜 f ↔ f ∉ x.asHomogeneousIdeal
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma add_of_Y_eq {P Q : Fin 3 → F} (hPz : P z ≠ 0) (hQz : Q z ≠ 0)
    (hx : P x * Q z ^ 2 = Q x * P z ^ 2) (hy : P y * Q z ^ 3 = Q y * P z ^ 3)
    (hy' : P y * Q z ^ 3 = W.negY Q * P z ^ 3) : W.add P Q = W.dblU P • ![1, 1, 0]
-- Mathlib/Data/Set/Basic.lean
theorem union_eq_union_iff_right : s ∪ u = t ∪ u ↔ s ⊆ t ∪ u ∧ t ⊆ s ∪ u
-- Mathlib/Logic/Function/Basic.lean
@[simp]
theorem update_same (a : α) (v : β a) (f : ∀ a, β a) : update f a v a = v
-- Mathlib/SetTheory/Cardinal/ToNat.lean
/-- `toNat` has a right-inverse: coercion. -/
theorem toNat_rightInverse : Function.RightInverse ((↑) : ℕ → Cardinal) toNat
-- Mathlib/Data/List/Basic.lean
theorem cons_getElem_drop_succ {l : List α} {n : Nat} {h : n < l.length} :
    l[n] :: l.drop (n + 1) = l.drop n
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
theorem contMDiffOn_id : ContMDiffOn I I n (id : M → M) s
-- Mathlib/Algebra/Homology/Embedding/Boundary.lean
lemma boundaryLE {k' : ι'} {j : ι} (hj : c'.Rel (e.f j) k') (hk' : ∀ i, e.f i ≠ k') :
    e.BoundaryLE j
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem iUnion_iUnion_eq_or_left {b : β} {p : β → Prop} {s : ∀ x : β, x = b ∨ p x → Set α} :
    ⋃ (x) (h), s x h = s b (Or.inl rfl) ∪ ⋃ (x) (h : p x), s x (Or.inr h)
-- Mathlib/Data/Seq/Seq.lean
@[simp]
theorem map_id : ∀ s : Seq α, map id s = s
-- Mathlib/RingTheory/Adjoin/Basic.lean
theorem pow_smul_mem_adjoin_smul (r : R) (s : Set A) {x : A} (hx : x ∈ adjoin R s) :
    ∃ n₀ : ℕ, ∀ n ≥ n₀, r ^ n • x ∈ adjoin R (r • s)
-- Mathlib/LinearAlgebra/QuadraticForm/Prod.lean
theorem nonneg_prod_iff [Preorder P] [CovariantClass P P (· + ·) (· ≤ ·)]
    {Q₁ : QuadraticMap R M₁ P} {Q₂ : QuadraticMap R M₂ P} :
    (∀ x, 0 ≤ (Q₁.prod Q₂) x) ↔ (∀ x, 0 ≤ Q₁ x) ∧ ∀ x, 0 ≤ Q₂ x
-- Mathlib/Algebra/Homology/Embedding/Extend.lean
lemma isZero_X {i : Option ι} (hi : i = none) :
    IsZero (X K i)
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem ae_neBot : (ae μ).NeBot ↔ μ ≠ 0
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[ext]
theorem colimit.hom_ext {F : J ⥤ C} [HasColimit F] {X : C} {f f' : colimit F ⟶ X}
    (w : ∀ j, colimit.ι F j ≫ f = colimit.ι F j ≫ f') : f = f'
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ico_subset_Ici_self : Ico a b ⊆ Ici a
-- Mathlib/Computability/Primrec.lean
theorem nat_findGreatest {f : α → ℕ} {p : α → ℕ → Prop} [∀ x n, Decidable (p x n)]
    (hf : Primrec f) (hp : PrimrecRel p) : Primrec fun x => (f x).findGreatest (p x)
-- Mathlib/Data/Nat/Nth.lean
theorem exists_lt_card_nth_eq {x} (h : p x) :
    ∃ n, (∀ hf : (setOf p).Finite, n < hf.toFinset.card) ∧ nth p n = x
-- Mathlib/CategoryTheory/Category/Basic.lean
theorem ite_comp {P : Prop} [Decidable P] {X Y Z : C} (f f' : X ⟶ Y) (g : Y ⟶ Z) :
    (if P then f else f') ≫ g = if P then f ≫ g else f' ≫ g
-- Mathlib/Algebra/CubicDiscriminant.lean
@[simp]
theorem coeff_eq_b : P.toPoly.coeff 2 = P.b
-- Mathlib/Topology/Order/Basic.lean
theorem tendsto_nhds_bot_mono' [TopologicalSpace β] [Preorder β] [OrderBot β] [OrderTopology β]
    {l : Filter α} {f g : α → β} (hf : Tendsto f l (𝓝 ⊥)) (hg : g ≤ f) : Tendsto g l (𝓝 ⊥)
-- Mathlib/Geometry/Euclidean/Circumcenter.lean
/-- All n-simplices among cospherical points in n-space have the same
circumcenter. -/
theorem exists_circumcenter_eq_of_cospherical {ps : Set P} {n : ℕ} [FiniteDimensional ℝ V]
    (hd : finrank ℝ V = n) (hc : Cospherical ps) :
    ∃ c : P, ∀ sx : Simplex ℝ P n, Set.range sx.points ⊆ ps → sx.circumcenter = c
-- Mathlib/Order/Bounds/Basic.lean
theorem bddBelow_def : BddBelow s ↔ ∃ x, ∀ y ∈ s, x ≤ y
-- Mathlib/Logic/Encodable/Basic.lean
@[simp 1100]
theorem decode_nat (n : ℕ) : decode n = some n
-- Mathlib/Topology/Sheaves/Presheaf.lean
@[simp]
theorem comp_inv_app {X Y Z : TopCat.{w}} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : X.Presheaf C) (U) :
    (comp f g ℱ).inv.app U = 𝟙 _
-- Mathlib/RingTheory/Noetherian.lean
theorem fg_of_injective [IsNoetherian R P] {N : Submodule R M} (f : M →ₗ[R] P)
    (hf : Function.Injective f) : N.FG
-- Mathlib/CategoryTheory/EqToHom.lean
/-- A variant on `eqToHom_naturality` that helps Lean identify the families `f` and `g`. -/
-- The simpNF linter incorrectly claims that this will never apply.
-- https://github.com/leanprover-community/mathlib4/issues/5049
@[reassoc (attr := simp, nolint simpNF)]
theorem eqToHom_iso_inv_naturality {f g : β → C} (z : ∀ b, f b ≅ g b) {j j' : β} (w : j = j') :
    (z j).inv ≫ eqToHom (by simp [w]) = eqToHom (by simp [w]) ≫ (z j').inv
-- Mathlib/Data/Finset/Lattice.lean
theorem mem_maximals_iff_forall_insert (hP : ∀ ⦃s t⦄, P t → s ⊆ t → P s) :
    s ∈ maximals (· ⊆ ·) {t | P t} ↔ P s ∧ ∀ x ∉ s, ¬ P (insert x s)
-- Mathlib/Topology/Order.lean
theorem nhds_mkOfNhds_single [DecidableEq α] {a₀ : α} {l : Filter α} (h : pure a₀ ≤ l) (b : α) :
    @nhds α (TopologicalSpace.mkOfNhds (update pure a₀ l)) b =
      (update pure a₀ l : α → Filter α) b
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
theorem center_le_centralizer {R} [NonUnitalSemiring R] (s) : center R ≤ centralizer s
-- Mathlib/Algebra/Homology/ExactSequence.lean
lemma isComplex_of_iso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂) (h₁ : S₁.IsComplex) :
    S₂.IsComplex
-- Mathlib/Data/Nat/Choose/Basic.lean
theorem choose_le_add (a b c : ℕ) : choose a c ≤ choose (a + b) c
-- Mathlib/Analysis/Convolution.lean
theorem convolution_mono_right {f g g' : G → ℝ} (hfg : ConvolutionExistsAt f g x (lsmul ℝ ℝ) μ)
    (hfg' : ConvolutionExistsAt f g' x (lsmul ℝ ℝ) μ) (hf : ∀ x, 0 ≤ f x) (hg : ∀ x, g x ≤ g' x) :
    (f ⋆[lsmul ℝ ℝ, μ] g) x ≤ (f ⋆[lsmul ℝ ℝ, μ] g') x
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem realize_antisymmetric :
    M ⊨ r.antisymmetric ↔ AntiSymmetric fun x y : M => RelMap r ![x, y]
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
/-- The bijection between the set of prime factors of the ideal `⟨r⟩` and the set of prime factors
  of `r` preserves `count` of the corresponding multisets. See
  `multiplicity_normalizedFactorsEquivSpanNormalizedFactors_eq_multiplicity` for the version
  stated in terms of multiplicity. -/
theorem count_span_normalizedFactors_eq {r X : R} (hr : r ≠ 0) (hX : Prime X) :
    Multiset.count (Ideal.span {X} : Ideal R) (normalizedFactors (Ideal.span {r}))  =
        Multiset.count (normalize X) (normalizedFactors r)
-- Mathlib/RingTheory/OreLocalization/Ring.lean
protected theorem inv_def {r : R} {s : R⁰} :
    (r /ₒ s)⁻¹ =
      if hr : r = (0 : R) then (0 : R[R⁰⁻¹])
      else s /ₒ ⟨r, fun _ => eq_zero_of_ne_zero_of_mul_right_eq_zero hr⟩
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
lemma isOpen_extend_target [I.Boundaryless] : IsOpen (f.extend I).target
-- Mathlib/Order/RelSeries.lean
lemma toList_chain' (x : RelSeries r) : x.toList.Chain' r
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem hasStrictFDerivAt_cpow {p : ℂ × ℂ} (hp : p.1 ∈ slitPlane) :
    HasStrictFDerivAt (fun x : ℂ × ℂ => x.1 ^ x.2)
      ((p.2 * p.1 ^ (p.2 - 1)) • ContinuousLinearMap.fst ℂ ℂ ℂ +
        (p.1 ^ p.2 * log p.1) • ContinuousLinearMap.snd ℂ ℂ ℂ) p
-- Mathlib/Analysis/Calculus/LHopital.lean
/-- **L'Hôpital's rule** for approaching a real, `HasDerivAt` version -/
theorem lhopital_zero_nhds (hff' : ∀ᶠ x in 𝓝 a, HasDerivAt f (f' x) x)
    (hgg' : ∀ᶠ x in 𝓝 a, HasDerivAt g (g' x) x) (hg' : ∀ᶠ x in 𝓝 a, g' x ≠ 0)
    (hfa : Tendsto f (𝓝 a) (𝓝 0)) (hga : Tendsto g (𝓝 a) (𝓝 0))
    (hdiv : Tendsto (fun x => f' x / g' x) (𝓝 a) l) : Tendsto (fun x => f x / g x) (𝓝[≠] a) l
-- Mathlib/LinearAlgebra/Dual.lean
@[simp]
theorem dualDistribInvOfBasis_apply (b : Basis ι R M) (c : Basis κ R N) (f : Dual R (M ⊗[R] N)) :
    dualDistribInvOfBasis b c f = ∑ i, ∑ j, f (b i ⊗ₜ c j) • b.dualBasis i ⊗ₜ c.dualBasis j
-- Mathlib/FieldTheory/IsAlgClosed/Classification.lean
private theorem ringEquivOfCardinalEqOfCharP (p : ℕ) [Fact p.Prime] [CharP K p] [CharP L p]
    (hK : ℵ₀ < #K) (hKL : #K = #L) : Nonempty (K ≃+* L)
-- Mathlib/Data/Set/NAry.lean
@[simp]
theorem image2_insert_left : image2 f (insert a s) t = (fun b => f a b) '' t ∪ image2 f s t
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem map_injective_iff {f : α → β} : Injective (map f) ↔ Injective f
-- Mathlib/CategoryTheory/Limits/Shapes/Reflexive.lean
/--
The pair `f g : A ⟶ B` is coreflexive if there is a morphism `B ⟶ A` which is a retraction for both.
-/
class IsCoreflexivePair (f g : A ⟶ B) : Prop where
  common_retraction' : ∃ s : B ⟶ A, f ≫ s = 𝟙 A ∧ g ≫ s = 𝟙 A
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem succ_le_of_lt {n m : Nat} (h : n < m) : succ n ≤ m
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- Adding a multiple of the first vector passed to `oangle` to the second vector does not change
the sign of the angle. -/
@[simp]
theorem oangle_sign_smul_add_right (x y : V) (r : ℝ) :
    (o.oangle x (r • x + y)).sign = (o.oangle x y).sign
-- Mathlib/Order/BooleanAlgebra.lean
@[simp] theorem compl_le_self : xᶜ ≤ x ↔ x = ⊤
-- Mathlib/Data/Set/Countable.lean
@[simp]
theorem countable_insert {s : Set α} {a : α} : (insert a s).Countable ↔ s.Countable
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem associated_normalize (x : α) : Associated x (normalize x)
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem aleph0_le_add_iff {a b : Cardinal} : ℵ₀ ≤ a + b ↔ ℵ₀ ≤ a ∨ ℵ₀ ≤ b
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem exists_dvd_of_not_prime {n : ℕ} (n2 : 2 ≤ n) (np : ¬Prime n) : ∃ m, m ∣ n ∧ m ≠ 1 ∧ m ≠ n
-- Mathlib/Geometry/Manifold/BumpFunction.lean
theorem eventuallyEq_of_mem_source (hx : x ∈ (chartAt H c).source) :
    f =ᶠ[𝓝 x] f.toContDiffBump ∘ extChartAt I c
-- Mathlib/RingTheory/Localization/Away/Basic.lean
lemma mapₐ_surjective_of_surjective {f : A →ₐ[R] B} (a : A) [Away a Aₚ] [Away (f a) Bₚ]
    (hf : Function.Surjective f) : Function.Surjective (mapₐ Aₚ Bₚ f a)
-- Mathlib/Topology/Instances/TrivSqZeroExt.lean
theorem uniformity_def :
    𝓤 (tsze R M) =
      ((𝓤 R).comap fun p => (p.1.fst, p.2.fst)) ⊓ ((𝓤 M).comap fun p => (p.1.snd, p.2.snd))
-- Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
/-- A subset of a collinear set is collinear. -/
theorem Collinear.subset {s₁ s₂ : Set P} (hs : s₁ ⊆ s₂) (h : Collinear k s₂) : Collinear k s₁
-- Mathlib/Data/Int/Cast/Basic.lean
@[simp]
theorem cast_negOfNat (n : ℕ) : ((negOfNat n : ℤ) : R) = -n
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
@[simp]
theorem natTrailingDegree_neg (p : R[X]) : natTrailingDegree (-p) = natTrailingDegree p
-- Mathlib/Data/Finset/Sups.lean
theorem infs_inter_subset_right : s ⊼ (t₁ ∩ t₂) ⊆ s ⊼ t₁ ∩ s ⊼ t₂
-- Mathlib/Combinatorics/Additive/ErdosGinzburgZiv.lean
/-- The **Erdős–Ginzburg–Ziv theorem** for `ℤ`.

Any sequence of at least `2 * n - 1` elements of `ℤ` contains a subsequence of `n` elements whose
sum is divisible by `n`. -/
theorem Int.erdos_ginzburg_ziv (a : ι → ℤ) (hs : 2 * n - 1 ≤ s.card) :
    ∃ t ⊆ s, t.card = n ∧ ↑n ∣ ∑ i ∈ t, a i
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_const_mul_Ioo_of_neg (a b : α) {c : α} (h : c < 0) :
    (c * ·) ⁻¹' Ioo a b = Ioo (b / c) (a / c)
-- Mathlib/Control/Lawful.lean
@[simp]
theorem run_mk (x : m (Option α)) : OptionT.run (OptionT.mk x) = x
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
protected theorem MeasurableSet.of_compl (h : MeasurableSet sᶜ) : MeasurableSet s
-- Mathlib/Data/Finset/Basic.lean
theorem insert_union_comm (s t : Finset α) (a : α) : insert a s ∪ t = s ∪ insert a t
-- Mathlib/Data/Vector3.lean
@[simp]
theorem cons_fz (a : α) (v : Vector3 α n) : (a :: v) fz = a
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem centralizer_eq_top_iff_subset {s : Set A} : centralizer R s = ⊤ ↔ s ⊆ center R A
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
@[simp] protected theorem sub_self (a : Int) : a - a = 0
-- Mathlib/Data/PEquiv.lean
@[simp]
theorem symm_bot : (⊥ : α ≃. β).symm = ⊥
-- Mathlib/Topology/ContinuousFunction/CompactlySupported.lean
theorem uniformContinuous (f : F) : UniformContinuous (f : β → γ)
-- Mathlib/Order/WithBot.lean
@[simp, norm_cast]
theorem coe_lt_coe : (a : WithBot α) < b ↔ a < b
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem mdifferentiableWithinAt_fst {s : Set (M × M')} {x : M × M'} :
    MDifferentiableWithinAt (I.prod I') I Prod.fst s x
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
@[simp]
theorem image.isoStrongEpiMono_inv_comp_mono {I' : C} (e : X ⟶ I') (m : I' ⟶ Y) (comm : e ≫ m = f)
    [StrongEpi e] [Mono m] : (image.isoStrongEpiMono e m comm).inv ≫ m = image.ι f
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive (attr := simp)]
theorem prod_singleton (f : α → β) (a : α) : ∏ x ∈ singleton a, f x = f a
-- Mathlib/Data/Num/Lemmas.lean
theorem divMod_to_nat (d n : PosNum) :
    (n / d : ℕ) = (divMod d n).1 ∧ (n % d : ℕ) = (divMod d n).2
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem bne_iff_ne [BEq α] [LawfulBEq α] (a b : α) : a != b ↔ a ≠ b
-- Mathlib/Order/Filter/Basic.lean
theorem eq_iInf_of_mem_iff_exists_mem {f : ι → Filter α} {l : Filter α}
    (h : ∀ {s}, s ∈ l ↔ ∃ i, s ∈ f i) : l = iInf f