ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Star/Basic.lean
@[simp]
theorem coe_star (u : Rˣ) : ↑(star u) = (star ↑u : R)
-- Mathlib/Data/List/Perm.lean
@[deprecated (since := "2024-06-12")]
theorem permutations'Aux_get_zero (s : List α) (x : α)
    (hn : 0 < length (permutations'Aux x s) := (by simp)) :
    (permutations'Aux x s).get ⟨0, hn⟩ = x :: s
-- Mathlib/Data/List/Basic.lean
theorem indexOf_le_length {a : α} {l : List α} : indexOf a l ≤ length l
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
@[reassoc (attr := simp)]
lemma π_leftRightHomologyComparison'_ι :
    h₁.π ≫ leftRightHomologyComparison' h₁ h₂ ≫ h₂.ι = h₁.i ≫ h₂.p
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
@[simp]
protected theorem diff (hs : NullMeasurableSet s μ) (ht : NullMeasurableSet t μ) :
    NullMeasurableSet (s \ t) μ
-- Mathlib/Algebra/GCDMonoid/Multiset.lean
@[simp]
theorem lcm_dedup (s : Multiset α) : (dedup s).lcm = s.lcm
-- Mathlib/Algebra/MvPolynomial/PDeriv.lean
@[simp]
theorem pderiv_monomial {i : σ} :
    pderiv i (monomial s a) = monomial (s - single i 1) (a * s i)
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_Prop : #Prop = 2
-- Mathlib/Order/UpperLower/Basic.lean
lemma IsLowerSet.sdiff (hs : IsLowerSet s) (ht : ∀ b ∈ s, ∀ c ∈ t, c ≤ b → b ∈ t) :
    IsLowerSet (s \ t)
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
/-- ```
 X ⊞ Y --fst--> X
   |            |
  snd           0
   |            |
   v            v
   Y -----0---> 0
```
is a bicartesian square.
-/
@[simp]
theorem of_has_biproduct₁ [HasBinaryBiproduct X Y] :
    BicartesianSq biprod.fst biprod.snd (0 : X ⟶ 0) (0 : Y ⟶ 0)
-- Mathlib/CategoryTheory/Adjunction/Reflective.lean
/-- For a reflective functor `i` (with left adjoint `L`), with unit `η`, we have `η_iL = iL η`.
-/
theorem unit_obj_eq_map_unit [Reflective i] (X : C) :
    (reflectorAdjunction i).unit.app (i.obj ((reflector i).obj X)) =
      i.map ((reflector i).map ((reflectorAdjunction i).unit.app X))
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma mor₁_eq_zero_iff_epi₃ : T.mor₁ = 0 ↔ Epi T.mor₃
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem coe_comp (g : P₂ →ᵃⁱ[𝕜] P₃) (f : P →ᵃⁱ[𝕜] P₂) : ⇑(g.comp f) = g ∘ f
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
/-- The isomorphism `S₁.leftHomology ≅ S₂.leftHomology` induced by an isomorphism of
short complexes `S₁ ≅ S₂`. -/
@[simps]
noncomputable def leftHomologyMapIso (e : S₁ ≅ S₂) [S₁.HasLeftHomology]
    [S₂.HasLeftHomology] : S₁.leftHomology ≅ S₂.leftHomology
-- Mathlib/Data/Nat/Defs.lean
lemma eq_of_dvd_of_div_eq_one (hab : a ∣ b) (h : b / a = 1) : a = b
-- .lake/packages/lean4/src/lean/Init/Control/Lawful/Basic.lean
theorem seqLeft_eq_bind [Monad m] [LawfulMonad m] (x : m α) (y : m β) : x <* y = x >>= fun a => y >>= fun _ => pure a
-- Mathlib/Algebra/Free.lean
@[to_additive (attr := simp)]
theorem lift_of (x) : lift f (of x) = f x
-- Mathlib/Order/Cover.lean
@[simp]
theorem apply_wcovBy_apply_iff {E : Type*} [EquivLike E α β] [OrderIsoClass E α β] (e : E) :
    e a ⩿ e b ↔ a ⩿ b
-- Mathlib/Data/Int/ModEq.lean
theorem mod_mul_right_mod (a b c : ℤ) : a % (b * c) % b = a % b
-- Mathlib/Algebra/Order/Hom/Monoid.lean
theorem mul_comp (g₁ g₂ : β →*₀o γ) (f : α →*₀o β) : (g₁ * g₂).comp f = g₁.comp f * g₂.comp f
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma CFC.spectrum_algebraMap_subset (r : R) : spectrum R (algebraMap R A r) ⊆ {r}
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem coe_mk' (f : M₁ →ₛₗ[σ₁₂] M₂) (h) : (mk f h : M₁ → M₂) = f
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem lmul'_apply_tmul (a b : S) : lmul' (S := S) R (a ⊗ₜ[R] b) = a * b
-- Mathlib/RingTheory/Polynomial/Nilpotent.lean
lemma isNilpotent_pow_X_mul_C_of_isNilpotent (n : ℕ) (hnil : IsNilpotent r) :
    IsNilpotent (X ^ n * (C r))
-- Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean
@[to_additive nsmul_pos]
theorem one_lt_pow' {a : M} (ha : 1 < a) {k : ℕ} (hk : k ≠ 0) : 1 < a ^ k
-- Mathlib/Topology/Instances/Real.lean
theorem closure_of_rat_image_lt {q : ℚ} :
    closure (((↑) : ℚ → ℝ) '' { x | q < x }) = { r | ↑q ≤ r }
-- Mathlib/Topology/Algebra/Module/CharacterSpace.lean
@[simp, norm_cast]
protected theorem coe_coe (φ : characterSpace 𝕜 A) : ⇑(φ : WeakDual 𝕜 A) = (φ : A → 𝕜)
-- Mathlib/Data/Int/Defs.lean
lemma neg_pred (a : ℤ) : -pred a = succ (-a)
-- Mathlib/Analysis/NormedSpace/QuaternionExponential.lean
theorem im_exp (q : ℍ[ℝ]) : (exp ℝ q).im = (exp ℝ q.re * (Real.sin ‖q.im‖ / ‖q.im‖)) • q.im
-- Mathlib/FieldTheory/SeparableDegree.lean
/-- The minimal polynomial of an element `x` of `E / F` of exponential characteristic `q` has
separable degree one if and only if `x ^ (q ^ n) ∈ F` for some `n : ℕ`. -/
theorem natSepDegree_eq_one_iff_pow_mem : (minpoly F x).natSepDegree = 1 ↔
    ∃ n : ℕ, x ^ q ^ n ∈ (algebraMap F E).range
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_apply_le (s t : Set α) : μ.restrict s t ≤ μ t
-- Mathlib/Probability/Kernel/Composition.lean
/-- Lebesgue integral against the composition-product of two kernels. -/
theorem lintegral_compProd' (κ : Kernel α β) [IsSFiniteKernel κ] (η : Kernel (α × β) γ)
    [IsSFiniteKernel η] (a : α) {f : β → γ → ℝ≥0∞} (hf : Measurable (Function.uncurry f)) :
    ∫⁻ bc, f bc.1 bc.2 ∂(κ ⊗ₖ η) a = ∫⁻ b, ∫⁻ c, f b c ∂η (a, b) ∂κ a
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
@[reassoc]
lemma liftCycles_leftHomologyπ_eq_zero_of_boundary (x : A ⟶ S.X₁) (hx : k = x ≫ S.f) :
    S.liftCycles k (by rw [hx, assoc, S.zero, comp_zero]) ≫ S.leftHomologyπ = 0
-- Mathlib/Data/Analysis/Topology.lean
theorem isClosed_iff [TopologicalSpace α] (F : Realizer α) {s : Set α} :
    IsClosed s ↔ ∀ a, (∀ b, a ∈ F.F b → ∃ z, z ∈ F.F b ∩ s) → a ∈ s
-- Mathlib/LinearAlgebra/Dimension/Basic.lean
theorem rank_range_le (f : M →ₗ[R] M₁) : Module.rank R (LinearMap.range f) ≤ Module.rank R M
-- Mathlib/Algebra/ContinuedFractions/Determinant.lean
/-- The determinant formula `Aₙ * Bₙ₊₁ - Bₙ * Aₙ₊₁ = (-1)^(n + 1)`. -/
theorem determinant (not_terminatedAt_n : ¬(↑s : GenContFract K).TerminatedAt n) :
    (↑s : GenContFract K).nums n * (↑s : GenContFract K).dens (n + 1) -
      (↑s : GenContFract K).dens n * (↑s : GenContFract K).nums (n + 1) = (-1) ^ (n + 1)
-- Mathlib/Algebra/Algebra/Equiv.lean
/-- If `A₁` is equivalent to `A₂` and `A₁'` is equivalent to `A₂'`, then the type of maps
`A₁ ≃ₐ[R] A₁'` is equivalent to the type of maps `A₂ ≃ ₐ[R] A₂'`.

This is the `AlgEquiv` version of `AlgEquiv.arrowCongr`. -/
@[simps apply]
def equivCongr (e : A₁ ≃ₐ[R] A₂) (e' : A₁' ≃ₐ[R] A₂') : (A₁ ≃ₐ[R] A₁') ≃ A₂ ≃ₐ[R] A₂'
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem Prime.odd_of_ne_two {p : ℕ} (hp : p.Prime) (h_two : p ≠ 2) : Odd p
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[to_additive (attr := simp)]
theorem unbot_one' (d : α) : (1 : WithBot α).unbot' d = 1
-- Mathlib/Algebra/Star/Basic.lean
@[simp]
theorem star_neg [AddGroup R] [StarAddMonoid R] (r : R) : star (-r) = -star r
-- Mathlib/Algebra/Order/Group/Synonym.lean
@[to_additive (attr := simp)]
theorem toLex_one [One α] : toLex (1 : α) = 1
-- Mathlib/Topology/MetricSpace/PiNat.lean
protected theorem dist_triangle (x y z : ∀ n, E n) : dist x z ≤ dist x y + dist y z
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_add_const_Icc : (fun x => x + a) ⁻¹' Icc b c = Icc (b - a) (c - a)
-- Mathlib/SetTheory/Game/Basic.lean
@[simp]
theorem quot_left_distrib (x y z : PGame) : (⟦x * (y + z)⟧ : Game) = ⟦x * y⟧ + ⟦x * z⟧
-- Mathlib/Algebra/Group/Units.lean
@[field_simps]
theorem divp_eq_divp_iff {x y : α} {ux uy : αˣ} : x /ₚ ux = y /ₚ uy ↔ x * uy = y * ux
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
lemma pow_injOn_Iio_orderOf : (Set.Iio <| orderOf x).InjOn (x ^ ·)
-- Mathlib/Analysis/Complex/ReImTopology.lean
theorem interior_preimage_re (s : Set ℝ) : interior (re ⁻¹' s) = re ⁻¹' interior s
-- Mathlib/Data/Fintype/Lattice.lean
@[simp]
theorem fold_sup_univ [SemilatticeSup α] [OrderTop α] (a : α) :
    -- Porting note: added `haveI`
    haveI : Std.Commutative (α := α) (· ⊔ ·) := inferInstance
    (Finset.univ.fold (· ⊔ ·) a fun x => x) = ⊤
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
theorem of_epi {X Y : C} (f : X ⟶ Y) [Epi f] (i : IsZero X) : IsZero Y
-- Mathlib/Analysis/Normed/Group/AddCircle.lean
theorem le_add_order_smul_norm_of_isOfFinAddOrder {u : AddCircle p} (hu : IsOfFinAddOrder u)
    (hu' : u ≠ 0) : p ≤ addOrderOf u • ‖u‖
-- Mathlib/Probability/Independence/Kernel.lean
lemma iIndepSets.meas_biInter (h : iIndepSets π κ μ) (s : Finset ι)
    {f : ι → Set Ω} (hf : ∀ i, i ∈ s → f i ∈ π i) :
    ∀ᵐ a ∂μ, κ a (⋂ i ∈ s, f i) = ∏ i ∈ s, κ a (f i)
-- Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean
/-- See note [partially-applied ext lemmas]. -/
@[ext]
theorem hom_ext {f g : ExteriorAlgebra R M →ₐ[R] A}
    (h : f.toLinearMap.comp (ι R) = g.toLinearMap.comp (ι R)) : f = g
-- Mathlib/Combinatorics/Additive/ETransform.lean
/-- The **Dyson e-transform**. Turns `(s, t)` into `(s ∪ e • t, t ∩ e⁻¹ • s)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "The **Dyson e-transform**.
Turns `(s, t)` into `(s ∪ e +ᵥ t, t ∩ -e +ᵥ s)`. This reduces the sum of the two sets."]
def mulDysonETransform : Finset α × Finset α
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem upcrossingsBefore_le (f : ℕ → Ω → ℝ) (ω : Ω) (hab : a < b) :
    upcrossingsBefore a b f N ω ≤ N
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem piPremeasure_pi' {s : ∀ i, Set (α i)} : piPremeasure m (pi univ s) = ∏ i, m i (s i)
-- Mathlib/Algebra/Lie/Basic.lean
@[simp]
theorem symm_apply_apply (e : L₁ ≃ₗ⁅R⁆ L₂) : ∀ x, e.symm (e x) = x
-- Mathlib/CategoryTheory/Subobject/MonoOver.lean
/-- Construct a `MonoOver X`. -/
@[simps]
def mk' {X A : C} (f : A ⟶ X) [hf : Mono f] : MonoOver X
-- Mathlib/Order/Cover.lean
theorem covBy_iff_wcovBy_and_not_le : a ⋖ b ↔ a ⩿ b ∧ ¬b ≤ a
-- Mathlib/Algebra/Polynomial/Laurent.lean
@[simp]
theorem degree_eq_bot_iff {f : R[T;T⁻¹]} : f.degree = ⊥ ↔ f = 0
-- Mathlib/Data/Fin/Basic.lean
lemma castSucc_injective (n : ℕ) : Injective (@Fin.castSucc n)
-- Mathlib/Topology/NhdsSet.lean
theorem mem_nhdsSet_interior : s ∈ 𝓝ˢ (interior s)
-- Mathlib/LinearAlgebra/StdBasis.lean
@[simp]
theorem basis_repr_stdBasis [DecidableEq η] (s : ∀ j, Basis (ιs j) R (Ms j)) (j i) :
    (Pi.basis s).repr (stdBasis R _ j (s j i)) = Finsupp.single ⟨j, i⟩ 1
-- Mathlib/Data/Set/Function.lean
theorem InjOn.congr (h₁ : InjOn f₁ s) (h : EqOn f₁ f₂ s) : InjOn f₂ s
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem fval_ex (F A : Class.{u}) : F ′ A ∈ univ.{u}
-- Mathlib/Data/Quot.lean
@[simp]
theorem map₂'_mk'' (f : α → β → γ) (h) (x : α) :
    (Quotient.mk'' x : Quotient s₁).map₂' f h =
      (Quotient.map' (f x) (h (Setoid.refl x)) : Quotient s₂ → Quotient s₃)
-- Mathlib/AlgebraicGeometry/StructureSheaf.lean
/-- The ring isomorphism between the stalk of the structure sheaf of `R` at a point `p`
corresponding to a prime ideal in `R` and the localization of `R` at `p`. -/
@[simps]
def stalkIso (x : PrimeSpectrum.Top R) :
    (structureSheaf R).presheaf.stalk x ≅ CommRingCat.of (Localization.AtPrime x.asIdeal)
-- Mathlib/Analysis/Normed/Lp/LpEquiv.lean
theorem coe_addEquiv_lpPiLp_symm (f : PiLp p E) :
    (AddEquiv.lpPiLp.symm f : ∀ i, E i) = f
-- Mathlib/Algebra/Homology/ExactSequence.lean
/-- Functoriality maps for `ComposableArrows.sc`. -/
@[simps!]
def scMap {S₁ S₂ : ComposableArrows C n} (φ : S₁ ⟶ S₂) (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex)
    (i : ℕ) (hi : i + 2 ≤ n := by omega) :
    S₁.sc h₁ i ⟶ S₂.sc h₂ i
-- Mathlib/Order/UpperLower/Basic.lean
@[simp 1100, norm_cast] lemma coe_ssubset_coe : (s : Set α) ⊂ t ↔ t < s
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_add {x : ℝ≥0∞} (y z : ℝ) (hx : x ≠ 0) (h'x : x ≠ ⊤) : x ^ (y + z) = x ^ y * x ^ z
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem DifferentiableAt.hasFDerivAt (h : DifferentiableAt 𝕜 f x) :
    HasFDerivAt f (fderiv 𝕜 f x) x
-- Mathlib/NumberTheory/Cyclotomic/CyclotomicCharacter.lean
theorem rootsOfUnity.integer_power_of_ringEquiv' (g : L ≃+* L) :
    ∃ m : ℤ, ∀ t ∈ rootsOfUnity n L, g (t : Lˣ) = (t ^ m : Lˣ)
-- Mathlib/Geometry/Manifold/LocalDiffeomorph.lean
/-- A `C^n` local diffeomorphism on `s` is `C^n` on `s`. -/
lemma IsLocalDiffeomorphOn.contMDiffOn (hf : IsLocalDiffeomorphOn I J n f s) :
    ContMDiffOn I J n f s
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
@[simp]
theorem count_zero (hp : Irreducible p) : count p (0 : FactorSet α) = 0
-- Mathlib/GroupTheory/Exponent.lean
/-- If `f : M₁ →⋆ M₂` is surjective, then the exponent of `M₂` divides the exponent of `M₁`. -/
@[to_additive]
theorem MonoidHom.exponent_dvd {F M₁ M₂ : Type*} [Monoid M₁] [Monoid M₂]
    [FunLike F M₁ M₂] [MonoidHomClass F M₁ M₂]
    {f : F} (hf : Function.Surjective f) : exponent M₂ ∣ exponent M₁
-- Mathlib/Logic/Godel/GodelBetaFunction.lean
lemma coprimes_lt (a : Fin m → ℕ) (i) : a i < coprimes a i
-- Mathlib/Algebra/BigOperators/Group/Multiset.lean
@[to_additive]
lemma _root_.map_multiset_prod [FunLike F α β] [MonoidHomClass F α β] (f : F) (s : Multiset α) :
    f s.prod = (s.map f).prod
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
theorem le_trailingDegree_mul : p.trailingDegree + q.trailingDegree ≤ (p * q).trailingDegree
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
@[simp]
theorem logb_neg_eq_logb (x : ℝ) : logb b (-x) = logb b x
-- Mathlib/Order/RelIso/Set.lean
theorem RelIso.preimage_eq_image_symm (e : r ≃r s) (t : Set β) : e ⁻¹' t = e.symm '' t
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
/-- Coercion from `Subgraph G` to `SimpleGraph V`.  If `G'` is a spanning
subgraph, then `G'.spanningCoe` yields an isomorphic graph.
In general, this adds in all vertices from `V` as isolated vertices. -/
@[simps]
protected def spanningCoe (G' : Subgraph G) : SimpleGraph V
-- Mathlib/Combinatorics/SimpleGraph/DegreeSum.lean
theorem dart_edge_fiber_card [DecidableEq V] (e : Sym2 V) (h : e ∈ G.edgeSet) :
    (univ.filter fun d : G.Dart => d.edge = e).card = 2
-- Mathlib/Data/PNat/Xgcd.lean
/-- We will apply the above step recursively.  The following result
 is used to ensure that the process terminates. -/
theorem step_wf (hr : u.r ≠ 0) : SizeOf.sizeOf u.step < SizeOf.sizeOf u
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem peirce' {a : Prop} (H : ∀ b : Prop, (a → b) → a) : a
-- Mathlib/CategoryTheory/Limits/FunctorCategory.lean
/-- The colimit of a diagram `F : J ⥤ K ⥤ C` is isomorphic to the functor given by
the individual colimits on objects. -/
@[simps!]
def colimitIsoFlipCompColim [HasColimitsOfShape J C] (F : J ⥤ K ⥤ C) : colimit F ≅ F.flip ⋙ colim
-- Mathlib/Algebra/BigOperators/Finprod.lean
/-- A more general version of `MonoidHom.map_finprod_mem` that requires `s ∩ mulSupport f` rather
than `s` to be finite. -/
@[to_additive
      "A more general version of `AddMonoidHom.map_finsum_mem` that requires
      `s ∩ support f` rather than `s` to be finite."]
theorem MonoidHom.map_finprod_mem' {f : α → M} (g : M →* N) (h₀ : (s ∩ mulSupport f).Finite) :
    g (∏ᶠ j ∈ s, f j) = ∏ᶠ i ∈ s, g (f i)
-- Mathlib/Analysis/Normed/Lp/WithLp.lean
@[simp]
theorem equiv_zero : WithLp.equiv p V 0 = 0
-- Mathlib/Algebra/Order/AbsoluteValue.lean
theorem abv_inv (a : R) : abv a⁻¹ = (abv a)⁻¹
-- Mathlib/Data/Int/ModEq.lean
@[simp]
theorem modEq_zero_iff : a ≡ b [ZMOD 0] ↔ a = b
-- Mathlib/Topology/Connected/PathConnected.lean
theorem locPathConnected_of_isOpen [LocPathConnectedSpace X] {U : Set X} (h : IsOpen U) :
    LocPathConnectedSpace U
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
/-- Given a `p : R[X]` and a root `x : S`,
then `p.leadingCoeff • x : S` is integral over `R`. -/
theorem isIntegral_leadingCoeff_smul [Algebra R S] (h : aeval x p = 0) :
    IsIntegral R (p.leadingCoeff • x)
-- Mathlib/Order/CompleteSublattice.lean
@[simp] theorem coe_bot : (↑(⊥ : L) : α) = ⊥
-- Mathlib/Analysis/ODE/PicardLindelof.lean
theorem dist_le_of_forall {f₁ f₂ : FunSpace v} {d : ℝ} (h : ∀ t, dist (f₁ t) (f₂ t) ≤ d) :
    dist f₁ f₂ ≤ d
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem mul_left_cancel {n m k : Nat} (np : 0 < n) (h : n * m = n * k) : m = k
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
theorem mem_inv_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : Submonoid M) (x : M) :
    x ∈ a⁻¹ • S ↔ a • x ∈ S
-- Mathlib/Data/PFun.lean
@[simp]
theorem mem_core (x : α) (s : Set β) : x ∈ f.core s ↔ ∀ y, y ∈ f x → y ∈ s
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
theorem MeasurePreserving.integrableOn_image [MeasurableSpace β] {e : α → β} {ν}
    (h₁ : MeasurePreserving e μ ν) (h₂ : MeasurableEmbedding e) {f : β → E} {s : Set α} :
    IntegrableOn f (e '' s) ν ↔ IntegrableOn (f ∘ e) s μ
-- Mathlib/CategoryTheory/Comma/Over.lean
@[simp]
theorem isoMk_inv_right {f g : Under X} (hr : f.right ≅ g.right) (hw : f.hom ≫ hr.hom = g.hom) :
    (isoMk hr hw).inv.right = hr.inv
-- Mathlib/Algebra/Group/Equiv/TypeTags.lean
/-- Reinterpret `Additive G ≃+ H` as `G ≃* Multiplicative H`. -/
@[simps]
def AddEquiv.toMultiplicative' [MulOneClass G] [AddZeroClass H] :
    Additive G ≃+ H ≃ (G ≃* Multiplicative H)
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
theorem kerLiftAlg_toRingHom (f : A →ₐ[R₁] B) :
    (kerLiftAlg f : A ⧸ ker f →+* B) = RingHom.kerLift (f : A →+* B)
-- Mathlib/Algebra/Star/StarRingHom.lean
@[simp]
theorem symm_trans_apply (e₁ : A ≃⋆+* B) (e₂ : B≃⋆+* C) (x : C) :
    (e₁.trans e₂).symm x = e₁.symm (e₂.symm x)
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
theorem restrict_measure_eq (μ : FiniteMeasure Ω) (A : Set Ω) :
    (μ.restrict A : Measure Ω) = (μ : Measure Ω).restrict A
-- Mathlib/Order/WithBot.lean
theorem lt_iff_exists_coe_btwn [Preorder α] [DenselyOrdered α] [NoMaxOrder α] {a b : WithTop α} :
    a < b ↔ ∃ x : α, a < ↑x ∧ ↑x < b
-- Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean
@[simp]
theorem AffineMap.map_midpoint (f : P →ᵃ[R] P') (a b : P) :
    f (midpoint R a b) = midpoint R (f a) (f b)
-- Mathlib/Combinatorics/Additive/Dissociation.lean
@[to_additive (attr := simp)] lemma mulDissociated_inv : MulDissociated s⁻¹ ↔ MulDissociated s
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem sdiff_sup_self (a b : α) : b \ a ⊔ a = b ⊔ a
-- Mathlib/MeasureTheory/Measure/AEMeasurable.lean
@[to_additive] -- @[to_additive (attr := simp)] -- Porting note (#10618): simp can prove this
theorem aemeasurable_one [One β] : AEMeasurable (fun _ : α => (1 : β)) μ
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
theorem abs_sum_le_sum_abs {G : Type*} [LinearOrderedAddCommGroup G] (f : ι → G) (s : Finset ι) :
    |∑ i ∈ s, f i| ≤ ∑ i ∈ s, |f i|
-- Mathlib/Algebra/Squarefree/Basic.lean
theorem irreducible_sq_not_dvd_iff_eq_zero_and_no_irreducibles_or_squarefree (r : R) :
    (∀ x : R, Irreducible x → ¬x * x ∣ r) ↔ (r = 0 ∧ ∀ x : R, ¬Irreducible x) ∨ Squarefree r
-- Mathlib/Tactic/IntervalCases.lean
theorem _root_.Int.le_sub_one_of_not_le {a b : ℤ} (h : ¬b ≤ a) : a ≤ b - 1
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
/-- `rotateRight` equals the bit fiddling definition of `rotateRightAux` when the rotation amount is
smaller than the bitwidth. -/
theorem rotateRight_eq_rotateRightAux_of_lt {x : BitVec w} {r : Nat} (hr : r < w) :
    x.rotateRight r = x.rotateRightAux r
-- Mathlib/Topology/Irreducible.lean
theorem Set.Subsingleton.isPreirreducible (hs : s.Subsingleton) : IsPreirreducible s
-- Mathlib/Order/LiminfLimsup.lean
lemma blimsup_eq_limsup {f : Filter β} {u : β → α} {p : β → Prop} :
    blimsup u f p = limsup u (f ⊓ 𝓟 {x | p x})
-- Mathlib/Data/Nat/MaxPowDiv.lean
theorem base_mul_eq_succ {p n : ℕ} (hp : 1 < p) (hn : 0 < n) :
    p.maxPowDiv (p*n) = p.maxPowDiv n + 1
-- Mathlib/Data/Finset/Lattice.lean
@[simp]
protected theorem inf_eq_top_iff (f : β → α) (S : Finset β) : S.inf f = ⊤ ↔ ∀ s ∈ S, f s = ⊤
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIocDiv_eq_neg_floor (a b : α) : toIocDiv hp a b = -⌊(a + p - b) / p⌋
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem getElem?_inj
    (h₀ : i < xs.length) (h₁ : Nodup xs) (h₂ : xs[i]? = xs[j]?) : i = j
-- Mathlib/Algebra/Category/CoalgebraCat/ComonEquivalence.lean
/-- The natural functor from `R`-coalgebras to comonoid objects in the category of `R`-modules. -/
@[simps]
def toComon : CoalgebraCat R ⥤ Comon_ (ModuleCat R)
-- Mathlib/Algebra/Order/Module/Algebra.lean
@[mono] lemma algebraMap_strictMono : StrictMono (algebraMap α β)
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive]
theorem mul_le_of_mul_le_left [CovariantClass α α (· * ·) (· ≤ ·)] {a b c d : α} (h : a * b ≤ c)
    (hle : d ≤ b) :
    a * d ≤ c
-- Mathlib/Algebra/Order/Archimedean.lean
theorem archimedean_iff_nat_le : Archimedean α ↔ ∀ x : α, ∃ n : ℕ, x ≤ n
-- Mathlib/Algebra/Lie/Basic.lean
theorem symm_bijective : Function.Bijective (LieEquiv.symm : (L₁ ≃ₗ⁅R⁆ L₂) → L₂ ≃ₗ⁅R⁆ L₁)
-- Mathlib/Analysis/Convex/Function.lean
theorem StrictConvexOn.sub (hf : StrictConvexOn 𝕜 s f) (hg : StrictConcaveOn 𝕜 s g) :
    StrictConvexOn 𝕜 s (f - g)
-- Mathlib/Topology/Basic.lean
theorem tendsto_lift'_closure_nhds (hf : Continuous f) (x : X) :
    Tendsto f ((𝓝 x).lift' closure) ((𝓝 (f x)).lift' closure)
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
theorem logb_injOn_pos : Set.InjOn (logb b) (Set.Ioi 0)
-- Mathlib/Data/Matrix/Notation.lean
@[simp]
theorem empty_vecMul (v : Fin 0 → α) (B : Matrix (Fin 0) o' α) : v ᵥ* B = 0
-- Mathlib/Data/Nat/Cast/Order/Ring.lean
/-- Specialisation of `Nat.ofNat_pos'`, which seems to be easier for Lean to use. -/
-- See note [no_index around OfNat.ofNat]
@[simp]
theorem ofNat_pos {α} [OrderedSemiring α] [Nontrivial α] {n : ℕ} [n.AtLeastTwo] :
    0 < (no_index (OfNat.ofNat n : α))
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
protected theorem image' {q : ℚ_[p]} : q ≠ 0 → ∃ n : ℤ, padicNormE q = (p : ℚ) ^ (-n)
-- Mathlib/Analysis/Convex/Basic.lean
theorem Convex.translate (hs : Convex 𝕜 s) (z : E) : Convex 𝕜 ((fun x => z + x) '' s)
-- Mathlib/Geometry/Euclidean/Circumcenter.lean
/-- Two simplices with the same points have the same circumcenter. -/
theorem circumcenter_eq_of_range_eq {n : ℕ} {s₁ s₂ : Simplex ℝ P n}
    (h : Set.range s₁.points = Set.range s₂.points) : s₁.circumcenter = s₂.circumcenter
-- Mathlib/Combinatorics/SimpleGraph/Density.lean
theorem edgeDensity_comm (s t : Finset α) : G.edgeDensity s t = G.edgeDensity t s
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
lemma coe_nonempty (s : Subgroup G) : (s : Set G).Nonempty
-- Mathlib/Topology/NhdsSet.lean
@[simp]
theorem nhdsSet_singleton : 𝓝ˢ {x} = 𝓝 x
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem neg_right : IsRelPrime x (-y)
-- Mathlib/NumberTheory/Divisors.lean
theorem sum_properDivisors_eq_one_iff_prime : ∑ x ∈ n.properDivisors, x = 1 ↔ n.Prime
-- Mathlib/Analysis/Analytic/Within.lean
/-- `f` is analytic within `s` at `x` iff some local extension of `f` is analytic at `x` -/
lemma analyticWithinAt_iff_exists_analyticAt [CompleteSpace F] {f : E → F} {s : Set E} {x : E} :
    AnalyticWithinAt 𝕜 f s x ↔
      ContinuousWithinAt f s x ∧ ∃ g, f =ᶠ[𝓝[s] x] g ∧ AnalyticAt 𝕜 g x
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem mul_div_left_comm : a * (b / c) = b * (a / c)
-- Mathlib/Algebra/Ring/BooleanRing.lean
@[simp]
theorem ofBoolAlg_inf (a b : AsBoolAlg α) : ofBoolAlg (a ⊓ b) = ofBoolAlg a * ofBoolAlg b
-- Mathlib/RingTheory/LocalRing/RingHom/Basic.lean
theorem isLocalRingHom_of_comp (f : R →+* S) (g : S →+* T) [IsLocalRingHom (g.comp f)] :
    IsLocalRingHom f
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The span of a union of sets is the sup of their spans. -/
theorem span_union (s t : Set P) : affineSpan k (s ∪ t) = affineSpan k s ⊔ affineSpan k t
-- Mathlib/Data/Matroid/Basic.lean
/-- An `InfiniteRk` matroid is one whose bases are infinite. -/
class InfiniteRk (M : Matroid α) : Prop where
  /-- There is an infinite base -/
  exists_infinite_base : ∃ B, M.Base B ∧ B.Infinite
-- Mathlib/Algebra/Order/Monovary.lean
/-- Two functions monovary iff the rearrangement inequality holds. -/
lemma monovary_iff_smul_rearrangement :
    Monovary f g ↔ ∀ i j, f i • g j + f j • g i ≤ f i • g i + f j • g j
-- Mathlib/Analysis/NormedSpace/Exponential.lean
theorem invOf_exp (x : 𝔸) [Invertible (exp 𝕂 x)] : ⅟ (exp 𝕂 x) = exp 𝕂 (-x)