ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
@[reassoc (attr := simp, nolint simpNF)]
theorem Sigma.eqToHom_comp_ι {J : Type*} (f : J → C) [HasCoproduct f] {j j' : J} (w : j = j') :
    eqToHom (by simp [w]) ≫ Sigma.ι f j' = Sigma.ι f j
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem edist_indicatorConstLp_eq_nnnorm {t : Set α} {ht : MeasurableSet t} {hμt : μ t ≠ ∞} :
    edist (indicatorConstLp p hs hμs c) (indicatorConstLp p ht hμt c) =
      ‖indicatorConstLp p (hs.symmDiff ht) (measure_symmDiff_ne_top hμs hμt) c‖₊
-- Mathlib/Data/Finset/Card.lean
theorem Multiset.card_toFinset : m.toFinset.card = Multiset.card m.dedup
-- Mathlib/Logic/Small/Defs.lean
theorem small_congr {α : Type*} {β : Type*} (e : α ≃ β) : Small.{w} α ↔ Small.{w} β
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem setIntegral_nonneg_of_ae_restrict (hf : 0 ≤ᵐ[μ.restrict s] f) : 0 ≤ ∫ x in s, f x ∂μ
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
@[simp, fun_prop]
theorem differentiableAt_id : DifferentiableAt 𝕜 id x
-- Mathlib/Data/Finsupp/Defs.lean
/-- `Finsupp α M`, denoted `α →₀ M`, is the type of functions `f : α → M` such that
  `f x = 0` for all but finitely many `x`. -/
structure Finsupp (α : Type*) (M : Type*) [Zero M] where
  /-- The support of a finitely supported function (aka `Finsupp`). -/
  support : Finset α
  /-- The underlying function of a bundled finitely supported function (aka `Finsupp`). -/
  toFun : α → M
  /-- The witness that the support of a `Finsupp` is indeed the exact locus where its
  underlying function is nonzero. -/
  mem_support_toFun : ∀ a, a ∈ support ↔ toFun a ≠ 0
-- Mathlib/NumberTheory/VonMangoldt.lean
@[simp]
theorem moebius_mul_log_eq_vonMangoldt : (μ : ArithmeticFunction ℝ) * log = Λ
-- Mathlib/LinearAlgebra/BilinearForm/DualLattice.lean
/-- The natural paring of `B.dualSubmodule N` and `N`. -/
-- TODO: Show that this is perfect when `N` is a lattice and `B` is nondegenerate.
@[simps]
noncomputable
def dualSubmoduleToDual [NoZeroSMulDivisors R S] (N : Submodule R M) :
    B.dualSubmodule N →ₗ[R] Module.Dual R N
-- Mathlib/Data/Nat/Cast/Defs.lean
theorem one_add_one_eq_two [AddMonoidWithOne R] : 1 + 1 = (2 : R)
-- Mathlib/Algebra/Order/Ring/Basic.lean
lemma add_sq_le : (a + b) ^ 2 ≤ 2 * (a ^ 2 + b ^ 2)
-- Mathlib/Algebra/Group/Commute/Basic.lean
@[to_additive]
protected lemma inv_mul_cancel (h : Commute a b) : a⁻¹ * b * a = b
-- Mathlib/Algebra/Homology/SingleHomology.lean
lemma exactAt_single_obj (A : C) (i : ι) (hi : i ≠ j) :
    ExactAt ((single C c j).obj A) i
-- Mathlib/Data/Finsupp/Lex.lean
theorem lex_def {r : α → α → Prop} {s : N → N → Prop} {a b : α →₀ N} :
    Finsupp.Lex r s a b ↔ ∃ j, (∀ d, r d j → a d = b d) ∧ s (a j) (b j)
-- Mathlib/LinearAlgebra/Matrix/Nondegenerate.lean
theorem eq_zero_of_vecMul_eq_zero [DecidableEq m] {M : Matrix m m A} (hM : M.det ≠ 0) {v : m → A}
    (hv : v ᵥ* M = 0) : v = 0
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem mem_mk {S : Subring K} {x : K} (h) : x ∈ (⟨S, h⟩ : Subfield K) ↔ x ∈ S
-- Mathlib/Algebra/Module/Submodule/Basic.lean
@[mono]
theorem toSubMulAction_strictMono :
    StrictMono (toSubMulAction : Submodule R M → SubMulAction R M)
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
protected theorem le_of_add_le_add_left [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊥)
    (h : a + b ≤ a + c) : b ≤ c
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
theorem measurableSet_sSup {ms : Set (MeasurableSpace α)} {s : Set α} :
    MeasurableSet[sSup ms] s ↔
      GenerateMeasurable { s : Set α | ∃ m ∈ ms, MeasurableSet[m] s } s
-- Mathlib/LinearAlgebra/Lagrange.lean
/-- This is the first barycentric form of the Lagrange interpolant. -/
theorem eval_interpolate_not_at_node (hx : ∀ i ∈ s, x ≠ v i) :
    eval x (interpolate s v r) =
      eval x (nodal s v) * ∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹ * r i
-- Mathlib/Deprecated/Submonoid.lean
theorem Additive.isAddSubmonoid_iff {s : Set M} :
    @IsAddSubmonoid (Additive M) _ s ↔ IsSubmonoid s
-- Mathlib/Data/PFunctor/Multivariate/Basic.lean
theorem id_map {α : TypeVec n} : ∀ x : P α, TypeVec.id <$$> x = x
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem countP_False {s : Multiset α} : countP (fun _ => False) s = 0
-- Mathlib/CategoryTheory/Generator.lean
theorem IsSeparator.isDetector [Balanced C] {G : C} : IsSeparator G → IsDetector G
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Cospan.lean
@[simp]
theorem spanCompIso_app_right : (spanCompIso F f g).app WalkingSpan.right = Iso.refl _
-- Mathlib/Data/Sum/Order.lean
theorem toLex_strictMono : StrictMono (@toLex (α ⊕ β))
-- Mathlib/Analysis/Normed/Group/HomCompletion.lean
@[simp]
theorem NormedAddGroupHom.norm_completion (f : NormedAddGroupHom G H) : ‖f.completion‖ = ‖f‖
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem type_le_iff' {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r]
    [IsWellOrder β s] : type r ≤ type s ↔ Nonempty (r ↪r s)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem sign_eq_one_iff_pos (a : Int) : sign a = 1 ↔ 0 < a
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[continuity]
protected theorem continuous (h : M ≃ₘ^n⟮I, I'⟯ M') : Continuous h
-- Mathlib/Geometry/RingedSpace/LocallyRingedSpace/HasColimits.lean
theorem colimit_exists_rep (x : colimit (C := SheafedSpace C) F) :
    ∃ (i : J) (y : F.obj i), (colimit.ι F i).base y = x
-- Mathlib/LinearAlgebra/Basis/Flag.lean
theorem self_mem_flag (b : Basis (Fin n) R M) {i : Fin n} {k : Fin (n + 1)} (h : i.castSucc < k) :
    b i ∈ b.flag k
-- Mathlib/CategoryTheory/Limits/Elements.lean
@[simp]
lemma map_π_liftedConeElement (i : I) :
    A.map (limit.π (F ⋙ π A) i) (liftedConeElement F) = (F.obj i).snd
-- Mathlib/Data/Finset/SMulAntidiagonal.lean
@[to_additive]
theorem IsWF.min_smul [LinearOrder G] [LinearOrder P] [SMul G P] [IsOrderedCancelSMul G P]
    {s : Set G} {t : Set P} (hs : s.IsWF) (ht : t.IsWF) (hsn : s.Nonempty) (htn : t.Nonempty) :
    (hs.smul ht).min (hsn.smul htn) = hs.min hsn • ht.min htn
-- Mathlib/Data/Finset/Lattice.lean
theorem max'_erase_ne_self {s : Finset α} (s0 : (s.erase x).Nonempty) : (s.erase x).max' s0 ≠ x
-- Mathlib/Data/Nat/Defs.lean
lemma exists_mul_self' (x : ℕ) : (∃ n, n ^ 2 = x) ↔ sqrt x ^ 2 = x
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
theorem isClosed_iff_zeroLocus (Z : Set (PrimeSpectrum R)) : IsClosed Z ↔ ∃ s, Z = zeroLocus s
-- Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean
/-- A functor to an `R`-linear category lifts to a functor from its `R`-linear completion.
-/
@[simps]
def lift (F : C ⥤ D) : Free R C ⥤ D
-- Mathlib/Data/Nat/Hyperoperation.lean
theorem hyperoperation_two_two_eq_four (n : ℕ) : hyperoperation (n + 1) 2 2 = 4
-- Mathlib/Order/Monotone/Basic.lean
/-- If `f` is a monotone function from `ℤ` to a preorder and `x` lies between `f n` and
  `f (n + 1)`, then `x` doesn't lie in the range of `f`. -/
theorem Monotone.ne_of_lt_of_lt_int {f : ℤ → α} (hf : Monotone f) (n : ℤ) {x : α} (h1 : f n < x)
    (h2 : x < f (n + 1)) (a : ℤ) : f a ≠ x
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma Y_eq_of_Y_ne' {P Q : Fin 3 → F} (hP : W.Equation P) (hQ : W.Equation Q)
    (hx : P x * Q z ^ 2 = Q x * P z ^ 2) (hy : P y * Q z ^ 3 ≠ W.negY Q * P z ^ 3) :
    P y * Q z ^ 3 = Q y * P z ^ 3
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem rTensor_tmul (m : M) (n : N) : f.rTensor M (n ⊗ₜ m) = f n ⊗ₜ m
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
theorem coe_quotQuotToQuotSupₐ : ⇑(quotQuotToQuotSupₐ R I J) = quotQuotToQuotSup I J
-- Mathlib/Algebra/Group/Nat.lean
lemma even_iff : Even n ↔ n % 2 = 0
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem lTensor_mul (f g : N ≃ₗ[R] N) : (f * g).lTensor M = f.lTensor M * g.lTensor M
-- Mathlib/Order/Filter/Bases.lean
/-- `IsCountablyGenerated f` means `f = generate s` for some countable `s`. -/
class IsCountablyGenerated (f : Filter α) : Prop where
  /-- There exists a countable set that generates the filter. -/
  out : ∃ s : Set (Set α), s.Countable ∧ f = generate s
-- Mathlib/Algebra/GroupWithZero/WithZero.lean
lemma lift'_zero (f : α →* β) : lift' f (0 : WithZero α) = 0
-- Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean
/-- The function `ContinuousLinearMap.smulRight`, associating to a continuous linear map
`f : E → 𝕜` and a scalar `c : F` the tensor product `f ⊗ c` as a continuous linear map from `E` to
`F`, is a bounded bilinear map. -/
theorem isBoundedBilinearMap_smulRight :
    IsBoundedBilinearMap 𝕜 fun p =>
      (ContinuousLinearMap.smulRight : (E →L[𝕜] 𝕜) → F → E →L[𝕜] F) p.1 p.2
-- Mathlib/Data/QPF/Univariate/Basic.lean
theorem has_good_supp_iff {α : Type u} (x : F α) :
    (∀ p, Liftp p x ↔ ∀ u ∈ supp x, p u) ↔
      ∃ a f, abs ⟨a, f⟩ = x ∧ ∀ a' f', abs ⟨a', f'⟩ = x → f '' univ ⊆ f' '' univ
-- Mathlib/Data/Rat/Cast/Defs.lean
@[simp, norm_cast] lemma cast_ofNat (n : ℕ) [n.AtLeastTwo] :
    no_index (OfNat.ofNat n : ℚ≥0) = (OfNat.ofNat n : α)
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem map_preimage (f : α →ₛ β) (g : β → γ) (s : Set γ) :
    f.map g ⁻¹' s = f ⁻¹' ↑(f.range.filter fun b => g b ∈ s)
-- Mathlib/RingTheory/PrincipalIdealDomain.lean
/-- If a `RingHom` maps all units and all factors of an element `a` into a submonoid `s`, then it
also maps `a` into that submonoid. -/
theorem ringHom_mem_submonoid_of_factors_subset_of_units_subset {R S : Type*} [CommRing R]
    [IsDomain R] [IsPrincipalIdealRing R] [Semiring S] (f : R →+* S) (s : Submonoid S) (a : R)
    (ha : a ≠ 0) (h : ∀ b ∈ factors a, f b ∈ s) (hf : ∀ c : Rˣ, f c ∈ s) : f a ∈ s
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
lemma orderOf_eq [Group G] (a : G) {x y : G} (h : SemiconjBy a x y) : orderOf x = orderOf y
-- Mathlib/CategoryTheory/Sites/Coherent/RegularSheaves.lean
/-- An alternative phrasing of the explicit equalizer condition, using more categorical language. -/
theorem equalizerCondition_iff_isIso_lift (P : Cᵒᵖ ⥤ Type*) : EqualizerCondition P ↔
    ∀ (X B : C) (π : X ⟶ B) [EffectiveEpi π] [HasPullback π π],
      IsIso (equalizer.lift (P.map π.op) (equalizerCondition_w' P π))
-- Mathlib/Data/Set/Card.lean
theorem ncard_singleton_inter (a : α) (s : Set α) : ({a} ∩ s).ncard ≤ 1
-- Mathlib/Topology/MetricSpace/Basic.lean
theorem MetricSpace.replaceBornology_eq {α} [m : MetricSpace α] [B : Bornology α]
    (H : ∀ s, @IsBounded _ B s ↔ @IsBounded _ PseudoMetricSpace.toBornology s) :
    MetricSpace.replaceBornology _ H = m
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
/-- If a function is interval integrable with respect to a given measure `μ` on `a..b` then
  it is integrable on `uIoc a b` with respect to `μ`. -/
theorem IntervalIntegrable.def' (h : IntervalIntegrable f μ a b) : IntegrableOn f (Ι a b) μ
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
@[simp]
theorem Units.inv_neg
    [ZeroLEOneClass α] [NeZero (R := α) 1] [MulPosMono α] [PosMulMono α]
    {u : αˣ} : ↑u⁻¹ < (0 : α) ↔ ↑u < (0 : α)
-- Mathlib/Topology/FiberBundle/Basic.lean
/-- The composition of two local trivializations is the trivialization change Z.triv_change i j. -/
theorem localTrivAsPartialEquiv_trans (i j : ι) :
    (Z.localTrivAsPartialEquiv i).symm.trans (Z.localTrivAsPartialEquiv j) ≈
      (Z.trivChange i j).toPartialEquiv
-- Mathlib/Order/Antichain.lean
theorem isAntichain_and_greatest_iff : IsAntichain (· ≤ ·) s ∧ IsGreatest s a ↔ s = {a}
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem num_mul_dvd (x y : RatFunc K) : num (x * y) ∣ num x * num y
-- Mathlib/RingTheory/WittVector/Identities.lean
theorem verschiebung_frobenius_comm [CharP R p] :
    Function.Commute (verschiebung : 𝕎 R → 𝕎 R) frobenius
-- Mathlib/Probability/Distributions/Gaussian.lean
/-- The gaussian pdf is positive when the variance is not zero. -/
lemma gaussianPDFReal_pos (μ : ℝ) (v : ℝ≥0) (x : ℝ) (hv : v ≠ 0) : 0 < gaussianPDFReal μ v x
-- Mathlib/Topology/Sets/Closeds.lean
@[ext]
protected theorem ext {s t : IrreducibleCloseds α} (h : (s : Set α) = t) : s = t
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem IsGLB.ciInf_set_eq {s : Set β} {f : β → α} (H : IsGLB (f '' s) a) (Hne : s.Nonempty) :
    ⨅ i : s, f i = a
-- Mathlib/SetTheory/Game/PGame.lean
theorem le_congr_left {x₁ x₂ y : PGame} (hx : x₁ ≈ x₂) : x₁ ≤ y ↔ x₂ ≤ y
-- Mathlib/CategoryTheory/Limits/Constructions/LimitsOfProductsAndEqualizers.lean
/-- Any category with products and equalizers has all limits.

See <https://stacks.math.columbia.edu/tag/002N>.
-/
theorem has_limits_of_hasEqualizers_and_products [HasProducts.{w} C] [HasEqualizers C] :
    HasLimitsOfSize.{w, w} C
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem lt_nmul_iff₃' :
    d < a ⨳ (b ⨳ c) ↔
      ∃ a' < a, ∃ b' < b, ∃ c' < c,
        d ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c') ≤
          a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c')
-- Mathlib/Combinatorics/Enumerative/Composition.lean
@[simp]
theorem boundary_zero : c.boundary 0 = 0
-- Mathlib/Data/Set/Basic.lean
theorem insert_subset_iff : insert a s ⊆ t ↔ a ∈ t ∧ s ⊆ t
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem DifferentiableWithinAt.hasFDerivWithinAt (h : DifferentiableWithinAt 𝕜 f s x) :
    HasFDerivWithinAt f (fderivWithin 𝕜 f s x) s x
-- Mathlib/Data/ENNReal/Basic.lean
lemma coe_ne_coe : (p : ℝ≥0∞) ≠ q ↔ p ≠ q
-- Mathlib/Algebra/Symmetrized.lean
@[to_additive (attr := simp)]
theorem unsym_one [One α] : unsym (1 : αˢʸᵐ) = 1
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem prime_iff_prime_int {p : ℕ} : p.Prime ↔ _root_.Prime (p : ℤ)
-- .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Omega/MinNatAbs.lean
theorem nonzeroMinimum_eq_of_nonzero {xs : List Nat} (h : xs.nonzeroMinimum ≠ 0) :
    ∃ x ∈ xs, xs.nonzeroMinimum = x
-- Mathlib/RingTheory/OreLocalization/Ring.lean
theorem universalHom_unique (φ : R[S⁻¹] →+* T) (huniv : ∀ r : R, φ (numeratorHom r) = f r) :
    φ = universalHom f fS hf
-- Mathlib/FieldTheory/Adjoin.lean
theorem _root_.minpoly.degree_le (x : L) [FiniteDimensional K L] :
    (minpoly K x).degree ≤ finrank K L
-- Mathlib/Computability/Partrec.lean
nonrec theorem comp {f : β → σ} {g : α → β} (hf : Computable f) (hg : Computable g) :
    Computable fun a => f (g a)
-- Mathlib/Algebra/Polynomial/Smeval.lean
theorem aeval_coe_eq_smeval {R : Type*} [CommSemiring R] {S : Type*} [Semiring S] [Algebra R S]
    (x : S) : ⇑(aeval x) = fun (p : R[X]) => p.smeval x
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem dvd_gcd_mul_of_dvd_mul [GCDMonoid α] {m n k : α} (H : k ∣ m * n) : k ∣ gcd k m * n
-- Mathlib/Data/List/Rotate.lean
theorem rotate_reverse (l : List α) (n : ℕ) :
    l.reverse.rotate n = (l.rotate (l.length - n % l.length)).reverse
-- Mathlib/Analysis/Normed/Group/Seminorm.lean
@[simp, norm_cast]
theorem coe_le_coe : (p : E → ℝ) ≤ q ↔ p ≤ q
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
protected theorem add_le_add_iff_right [LE α] [CovariantClass α α (swap (· + ·)) (· ≤ ·)]
    [ContravariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊤) : b + a ≤ c + a ↔ b ≤ c
-- Mathlib/Data/Fin/Basic.lean
@[deprecated Fin.ext_iff (since := "2024-02-20")]
theorem eq_iff_veq (a b : Fin n) : a = b ↔ a.1 = b.1
-- Mathlib/Analysis/Convex/Basic.lean
theorem Antitone.convex_le (hf : Antitone f) (r : β) : Convex 𝕜 { x | f x ≤ r }
-- Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean
/-- An equivalence of groups, from the center of the special linear group to the roots of unity. -/
@[simps]
def center_equiv_rootsOfUnity' (i : n) :
    center (SpecialLinearGroup n R) ≃* rootsOfUnity (Fintype.card n).toPNat' R
-- Mathlib/Algebra/Order/AddTorsor.lean
/-- A scalar multiplication is cancellative if it is pointwise injective on the left and right. -/
@[to_additive]
class IsCancelSMul (G P : Type*) [SMul G P] : Prop where
  protected left_cancel : ∀ (a : G) (b c : P), a • b = a • c → b = c
  protected right_cancel : ∀ (a b : G) (c : P), a • c = b • c → a = b
-- Mathlib/Data/Real/Hyperreal.lean
@[simp, norm_cast]
theorem coe_max (x y : ℝ) : ((max x y : ℝ) : ℝ*) = max ↑x ↑y
-- Mathlib/Data/Nat/Factors.lean
theorem primeFactorsList_sublist_right {n k : ℕ} (h : k ≠ 0) :
    n.primeFactorsList <+ (n * k).primeFactorsList
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem UInt32.toNat_mod (x y : UInt32) : (x % y).toNat = x.toNat % y.toNat
-- Mathlib/Data/Finsupp/Multiset.lean
theorem toMultiset_zero : toMultiset (0 : α →₀ ℕ) = 0
-- Mathlib/Analysis/Normed/Ring/SeminormFromBounded.lean
/-- If `f : R → ℝ` is a nonzero, nonnegative, multiplicatively bounded function, then `f 1 ≠ 0`. -/
theorem map_one_ne_zero (f_ne_zero : f ≠ 0) (f_nonneg : 0 ≤ f)
    (f_mul : ∀ x y : R, f (x * y) ≤ c * f x * f y) : f 1 ≠ 0
-- Mathlib/Topology/Order/DenselyOrdered.lean
theorem nhdsWithin_Ioi_neBot' {a b : α} (H₁ : (Ioi a).Nonempty) (H₂ : a ≤ b) :
    NeBot (𝓝[Ioi a] b)
-- Mathlib/Algebra/Polynomial/Roots.lean
@[simp]
theorem rootSet_C [CommRing S] [IsDomain S] [Algebra T S] (a : T) : (C a).rootSet S = ∅
-- Mathlib/Analysis/NormedSpace/AddTorsor.lean
@[simp]
theorem nndist_lineMap_left (p₁ p₂ : P) (c : 𝕜) :
    nndist (lineMap p₁ p₂ c) p₁ = ‖c‖₊ * nndist p₁ p₂
-- Mathlib/Data/Bool/Basic.lean
theorem ne_not {a b : Bool} : a ≠ !b ↔ a = b
-- Mathlib/RingTheory/Derivation/Lie.lean
@[simp]
theorem commutator_coe_linear_map : ↑⁅D1, D2⁆ = ⁅(D1 : Module.End R A), (D2 : Module.End R A)⁆
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
theorem mem_closure_iff {s : Set R} {x} :
    x ∈ closure s ↔ x ∈ AddSubmonoid.closure (Subsemigroup.closure s : Set R)
-- Mathlib/Data/Complex/Exponential.lean
theorem cosh_sub : cosh (x - y) = cosh x * cosh y - sinh x * sinh y
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive (attr := simp)]
theorem lift_id (x) : f.lift f.map_units x = x
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
@[simp] lemma map_fst_prod : Measure.map Prod.fst (μ.prod ν) = (ν univ) • μ
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem neg_apply : (-f) x = -f x
-- Mathlib/Data/Complex/Exponential.lean
@[simp]
theorem tan_ofReal_im (x : ℝ) : (tan x).im = 0
-- Mathlib/Logic/Relation.lean
theorem head (hab : r a b) (hbc : TransGen r b c) : TransGen r a c
-- Mathlib/Computability/Primrec.lean
theorem cond {c : α → Bool} {f : α → σ} {g : α → σ} (hc : Primrec c) (hf : Primrec f)
    (hg : Primrec g) : Primrec fun a => bif (c a) then (f a) else (g a)
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem partition_eq_of_isConj {σ τ : Perm α} : IsConj σ τ ↔ σ.partition = τ.partition
-- Mathlib/Topology/MetricSpace/ThickenedIndicator.lean
/-- Pointwise, the multiplicative indicators of closed δ-thickenings of a set eventually coincide
with the multiplicative indicator of the set as δ tends to zero. -/
@[to_additive "Pointwise, the indicators of closed δ-thickenings of a set eventually coincide
with the indicator of the set as δ tends to zero."]
lemma mulIndicator_cthickening_eventually_eq_mulIndicator_closure (f : α → β) (E : Set α) (x : α) :
    ∀ᶠ δ in 𝓝 (0 : ℝ),
      (Metric.cthickening δ E).mulIndicator f x = (closure E).mulIndicator f x
-- Mathlib/Analysis/BoxIntegral/Basic.lean
nonrec theorem HasIntegral.add (h : HasIntegral I l f vol y) (h' : HasIntegral I l g vol y') :
    HasIntegral I l (f + g) vol (y + y')
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem init_eq_of_concat_eq {a b : α} {l₁ l₂ : List α} : concat l₁ a = concat l₂ b → l₁ = l₂
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
theorem inv_hom_id : inv P Q L ≫ hom P Q L = 𝟙 _
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- A multiple of the difference between two points (reversed) lies in their `vectorSpan`. -/
theorem smul_vsub_rev_mem_vectorSpan_pair (r : k) (p₁ p₂ : P) :
    r • (p₂ -ᵥ p₁) ∈ vectorSpan k ({p₁, p₂} : Set P)
-- Mathlib/FieldTheory/IsPerfectClosure.lean
@[simp]
theorem liftAux_id : liftAux (RingHom.id K) j p = j
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[reassoc]
theorem prod_rightUnitor_inv_naturality [HasBinaryProducts C] (f : X ⟶ Y) :
    (prod.rightUnitor X).inv ≫ prod.map f (𝟙 _) = f ≫ (prod.rightUnitor Y).inv
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
@[simp]
theorem derivWithin_univ : derivWithin f univ = deriv f
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem comp_add_left (hf : IntervalIntegrable f volume a b) (c : ℝ) :
    IntervalIntegrable (fun x => f (c + x)) volume (a - c) (b - c)
-- Mathlib/Topology/Basic.lean
theorem tendsto_pure_nhds (f : α → X) (a : α) : Tendsto f (pure a) (𝓝 (f a))
-- Mathlib/Computability/Halting.lean
theorem merge {f g : α →. σ} (hf : Partrec f) (hg : Partrec g)
    (H : ∀ (a), ∀ x ∈ f a, ∀ y ∈ g a, x = y) :
    ∃ k : α →. σ, Partrec k ∧ ∀ a x, x ∈ k a ↔ x ∈ f a ∨ x ∈ g a
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
theorem smulTower_leftMulMatrix_algebraMap_eq (x : S) (i j k) :
    leftMulMatrix (b.smulTower c) (algebraMap _ _ x) (i, k) (j, k) = leftMulMatrix b x i j
-- Mathlib/GroupTheory/Perm/Support.lean
theorem one_lt_card_support_of_ne_one {f : Perm α} (h : f ≠ 1) : 1 < f.support.card
-- Mathlib/ModelTheory/Definability.lean
theorem empty_definable_iff :
    (∅ : Set M).Definable L s ↔ ∃ φ : L.Formula α, s = setOf φ.Realize
-- Mathlib/Topology/SeparatedMap.lean
theorem isLocallyInjective_iff_isOpenMap {f : X → Y} :
    IsLocallyInjective f ↔ IsOpenMap (toPullbackDiag f)
-- Mathlib/Combinatorics/SimpleGraph/Acyclic.lean
/-- A *tree* is a connected acyclic graph. -/
@[mk_iff]
structure IsTree : Prop where
  /-- Graph is connected. -/
  protected isConnected : G.Connected
  /-- Graph is acyclic. -/
  protected IsAcyclic : G.IsAcyclic
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- The product map of two `C^n` functions within a set at a point is `C^n`
within the product set at the product point. -/
theorem ContDiffAt.prod_map {f : E → F} {g : E' → F'} {x : E} {y : E'} (hf : ContDiffAt 𝕜 n f x)
    (hg : ContDiffAt 𝕜 n g y) : ContDiffAt 𝕜 n (Prod.map f g) (x, y)
-- Mathlib/Algebra/Lie/Weights/Killing.lean
/-- The contrapositive of this result is very useful, taking `x` to be the element of `H`
corresponding to a root `α` under the identification between `H` and `H^*` provided by the Killing
form. -/
lemma eq_zero_of_apply_eq_zero_of_mem_corootSpace
    (x : H) (α : H → K) (hαx : α x = 0) (hx : x ∈ corootSpace α) :
    x = 0
-- Mathlib/Topology/Basic.lean
/-- `x` is an accumulation point of a set `C` iff
there are points near `x` in `C` and different from `x`. -/
theorem accPt_iff_frequently (x : X) (C : Set X) : AccPt x (𝓟 C) ↔ ∃ᶠ y in 𝓝 x, y ≠ x ∧ y ∈ C
-- Mathlib/GroupTheory/Perm/List.lean
theorem formPerm_pow_apply_head (x : α) (l : List α) (h : Nodup (x :: l)) (n : ℕ) :
    (formPerm (x :: l) ^ n) x =
      (x :: l).get ⟨(n % (x :: l).length), (Nat.mod_lt _ (Nat.zero_lt_succ _))⟩
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
@[simp]
lemma homologyMap_zero : homologyMap (0 : K ⟶ L) i = 0
-- Mathlib/Data/Matroid/Dual.lean
theorem Base.inter_basis_iff_compl_inter_basis_dual (hB : M.Base B) (hX : X ⊆ M.E := by aesop_mat) :
    M.Basis (B ∩ X) X ↔ M✶.Basis ((M.E \ B) ∩ (M.E \ X)) (M.E \ X)
-- Mathlib/RingTheory/PowerSeries/Basic.lean
@[simp]
theorem coeff_comp_monomial (n : ℕ) : (coeff R n).comp (monomial R n) = LinearMap.id
-- Mathlib/Topology/IsLocalHomeomorph.lean
protected theorem continuousAt (hf : IsLocalHomeomorphOn f s) {x : X} (hx : x ∈ s) :
    ContinuousAt f x
-- Mathlib/Topology/Order/IsLUB.lean
theorem IsLUB.mem_lowerBounds_of_tendsto [Preorder γ] [TopologicalSpace γ] [OrderClosedTopology γ]
    {f : α → γ} {s : Set α} {a : α} {b : γ} (hf : AntitoneOn f s) (ha : IsLUB s a)
    (hb : Tendsto f (𝓝[s] a) (𝓝 b)) : b ∈ lowerBounds (f '' s)
-- Mathlib/LinearAlgebra/Ray.lean
/-- `someVector` is nonzero. -/
@[simp]
theorem someVector_ne_zero (x : Module.Ray R M) : x.someVector ≠ 0
-- Mathlib/Algebra/Polynomial/Splits.lean
/-- If `P` is a monic polynomial that splits, then `coeff P 0` equals the product of the roots. -/
theorem prod_roots_eq_coeff_zero_of_monic_of_split {P : K[X]} (hmo : P.Monic)
    (hP : P.Splits (RingHom.id K)) : coeff P 0 = (-1) ^ P.natDegree * P.roots.prod
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
@[simp]
theorem quotientEquiv.symm_apply [Fintype ι] (x : fundamentalDomain b) :
    (quotientEquiv b).symm x = Submodule.Quotient.mk ↑x
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
theorem aeval_natCast (n : ℕ) : aeval x (n : R[X]) = n