ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/Noetherian.lean
theorem isNoetherian_of_injective [IsNoetherian R P] (f : M →ₗ[R] P) (hf : Function.Injective f) :
    IsNoetherian R M
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
theorem embDomain_one [NonAssocSemiring R] (f : Γ ↪o Γ') (hf : f 0 = 0) :
    embDomain f (1 : HahnSeries Γ R) = (1 : HahnSeries Γ' R)
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem ofNat_mulVec (x : ℕ) [x.AtLeastTwo] (v : m → α) :
    OfNat.ofNat (no_index x) *ᵥ v = (OfNat.ofNat x : α) • v
-- Mathlib/Topology/Homotopy/HomotopyGroup.lean
theorem homotopicTo (i : N) {p q : Ω^ N X x} :
    Homotopic p q → (toLoop i p).Homotopic (toLoop i q)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
theorem testBit_two_pow_add_gt {i j : Nat} (j_lt_i : j < i) (x : Nat) :
    testBit (2^i + x) j = testBit x j
-- Mathlib/Algebra/GeomSum.lean
theorem mul_geom_sum [Ring α] (x : α) (n : ℕ) : ((x - 1) * ∑ i ∈ range n, x ^ i) = x ^ n - 1
-- Mathlib/CategoryTheory/Limits/Lattice.lean
/-- The limit of a functor into a complete lattice is the infimum of the objects in the image.
-/
theorem limit_eq_iInf (F : J ⥤ α) : limit F = iInf F.obj
-- Mathlib/AlgebraicGeometry/Scheme.lean
@[simp]
theorem preimage_basicOpen {X Y : Scheme.{u}} (f : X ⟶ Y) {U : Y.Opens} (r : Γ(Y, U)) :
    f ⁻¹ᵁ (Y.basicOpen r) = X.basicOpen (f.app U r)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
@[simp]
theorem Differentiable.ccosh (hc : Differentiable ℂ f) :
    Differentiable ℂ fun x => Complex.cosh (f x)
-- Mathlib/Data/List/Basic.lean
theorem erase_get [DecidableEq ι] {l : List ι} (i : Fin l.length) :
    Perm (l.erase (l.get i)) (l.eraseIdx ↑i)
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
@[simp]
theorem homogeneousComponent_C_mul (n : ℕ) (r : R) :
    homogeneousComponent n (C r * φ) = C r * homogeneousComponent n φ
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem inclusion_comp_inclusion {α} {s t u : Set α} (hst : s ⊆ t) (htu : t ⊆ u) :
    inclusion htu ∘ inclusion hst = inclusion (hst.trans htu)
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
/-- If `Fₙ` tends locally uniformly to `f` on a set `s`, and `gₙ` tends to `x` within `s`, then
`Fₙ gₙ` tends to `f x` if `f` is continuous at `x` within `s` and `x ∈ s`. -/
theorem TendstoLocallyUniformlyOn.tendsto_comp (h : TendstoLocallyUniformlyOn F f p s)
    (hf : ContinuousWithinAt f s x) (hx : x ∈ s) (hg : Tendsto g p (𝓝[s] x)) :
    Tendsto (fun n => F n (g n)) p (𝓝 (f x))
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem coe_comap (s : Subfield L) : (s.comap f : Set K) = f ⁻¹' s
-- .lake/packages/lean4/src/lean/Init/Data/List/Impl.lean
@[csimp] theorem join_eq_joinTR : @join = @joinTR
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
theorem quotQuotEquivQuotOfLEₐ_symm_toRingEquiv (h : I ≤ J) :
    ((quotQuotEquivQuotOfLEₐ R h).symm : _ ≃+* _ ⧸ J.map (Quotient.mkₐ R I)) =
      (quotQuotEquivQuotOfLE h).symm
-- Mathlib/Algebra/Group/Submonoid/Units.lean
@[to_additive]
lemma Subgroup.ofUnits_mono : Monotone (Subgroup.ofUnits (M := M))
-- Mathlib/Data/Sum/Interval.lean
lemma Icc_inr_inr :
    Icc (inrₗ b₁ : α ⊕ₗ β) (inrₗ b₂) = (Icc b₁ b₂).map (Embedding.inr.trans toLex.toEmbedding)
-- Mathlib/Topology/Connected/PathConnected.lean
@[simp]
protected theorem source : γ 0 = x
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
lemma isIso_ι (hg : S.g = 0) : IsIso h.ι
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
/-- Integration of (nonnegative bounded continuous) test functions against finite Borel measures
depends continuously on the measure. -/
theorem continuous_testAgainstNN_eval (f : Ω →ᵇ ℝ≥0) :
    Continuous fun μ : FiniteMeasure Ω => μ.testAgainstNN f
-- .lake/packages/batteries/Batteries/Data/RBMap/Alter.lean
/-- The `alter` function preserves the balance invariants. -/
protected theorem Balanced.alter {t : RBNode α}
    (h : t.Balanced c n) : ∃ c n, (t.alter cut f).Balanced c n
-- Mathlib/Analysis/Convex/Combination.lean
theorem Convex.sum_mem (hs : Convex R s) (h₀ : ∀ i ∈ t, 0 ≤ w i) (h₁ : ∑ i ∈ t, w i = 1)
    (hz : ∀ i ∈ t, z i ∈ s) : (∑ i ∈ t, w i • z i) ∈ s
-- Mathlib/Order/Bounds/Basic.lean
@[simp] theorem isLeast_univ_iff : IsLeast univ a ↔ IsBot a
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem rpow_inv_le_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) :
    x ^ z⁻¹ ≤ y ↔ y ^ z ≤ x
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem embedding_comp_inv (j : Fin n) : c.embedding (c.index j) (c.invEmbedding j) = j
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
theorem normalize_eq_of_nonzero (nonzero : μ ≠ 0) (s : Set Ω) : μ.normalize s = μ.mass⁻¹ * μ s
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem sumCongr_trans (e : α₁ ≃ β₁) (f : α₂ ≃ β₂) (g : β₁ ≃ γ₁) (h : β₂ ≃ γ₂) :
    (Equiv.sumCongr e f).trans (Equiv.sumCongr g h) = Equiv.sumCongr (e.trans g) (f.trans h)
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
lemma toSpec_base_apply_eq {f} (x : Proj| pbo f) :
    (toSpec 𝒜 f).1.base x = ProjIsoSpecTopComponent.toSpec 𝒜 f x
-- Mathlib/Analysis/Complex/TaylorSeries.lean
/-- A function that is complex differentiable on the complex plane is given by evaluating
its Taylor series at any point `c`. -/
lemma taylorSeries_eq_of_entire :
    ∑' n : ℕ, (n ! : ℂ)⁻¹ • (z - c) ^ n • iteratedDeriv n f c = f z
-- Mathlib/Topology/Compactness/SigmaCompact.lean
theorem subset_interior_succ (n : ℕ) : K n ⊆ interior (K (n + 1))
-- Mathlib/Analysis/BoundedVariation.lean
protected theorem eq_zero_iff_of_ge {f : α → E} {s : Set α} (hf : LocallyBoundedVariationOn f s)
    {a b : α} (ha : a ∈ s) (hb : b ∈ s) (ba : b ≤ a) :
    variationOnFromTo f s a b = 0 ↔
      ∀ ⦃x⦄ (_hx : x ∈ s ∩ Icc b a) ⦃y⦄ (_hy : y ∈ s ∩ Icc b a), edist (f x) (f y) = 0
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
/-- This lemma demonstrates the relation between `Equiv.Perm.IsCycle` and `Equiv.Perm.IsCycleOn`
in non-degenerate cases. -/
theorem isCycle_iff_exists_isCycleOn :
    f.IsCycle ↔ ∃ s : Set α, s.Nontrivial ∧ f.IsCycleOn s ∧ ∀ ⦃x⦄, ¬IsFixedPt f x → x ∈ s
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem repr_symm_apply (v) : b.repr.symm v = Finsupp.total ι M R b v
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
lemma opcyclesMap_comm [S₁.HasRightHomology] [S₂.HasRightHomology] :
    opcyclesMap φ ≫ h₂.opcyclesIso.hom = h₁.opcyclesIso.hom ≫ γ.φQ
-- Mathlib/AlgebraicGeometry/Pullbacks.lean
/-- We show that the map `W ×[X] Uᵢ ⟶ Uᵢ ×[Z] Y ⟶ W` is the first projection, where the
first map is given by the lift of `W ×[X] Uᵢ ⟶ Uᵢ` and `W ×[X] Uᵢ ⟶ W ⟶ Y`.

It suffices to show that the two map agrees when restricted onto `Uⱼ ×[Z] Y`. In this case,
both maps factor through `V j i` via `pullback_fst_ι_to_V` -/
theorem lift_comp_ι (i : 𝒰.J) :
    pullback.lift (pullback.snd _ _) (pullback.fst _ _ ≫ p2 𝒰 f g)
          (by rw [← pullback.condition_assoc, Category.assoc, p_comm]) ≫
        (gluing 𝒰 f g).ι i =
      (pullback.fst _ _ : pullback (p1 𝒰 f g) (𝒰.map i) ⟶ _)
-- Mathlib/RingTheory/PrimeSpectrum.lean
theorem vanishingIdeal_eq_top_iff {s : Set (PrimeSpectrum R)} : vanishingIdeal s = ⊤ ↔ s = ∅
-- Mathlib/RingTheory/Jacobson.lean
theorem isJacobson_of_isIntegral [Algebra R S] [Algebra.IsIntegral R S] (hR : IsJacobson R) :
    IsJacobson S
-- Mathlib/Data/Set/Prod.lean
theorem Nonempty.fst : (s ×ˢ t).Nonempty → s.Nonempty
-- .lake/packages/lean4/src/lean/Init/Data/Char/Basic.lean
theorem isValidChar_of_isValidCharNat (n : Nat) (h : isValidCharNat n) : isValidChar (UInt32.ofNat' n (isValidUInt32 n h))
-- Mathlib/Order/Interval/Finset/Defs.lean
@[simp]
lemma toFinset_Iio (a : α) [Fintype (Iio a)] : (Iio a).toFinset = Finset.Iio a
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
theorem prod_dist_eq_add (hp : 0 < p.toReal) (f g : WithLp p (α × β)) :
    dist f g = (dist f.fst g.fst ^ p.toReal + dist f.snd g.snd ^ p.toReal) ^ (1 / p.toReal)
-- Mathlib/Analysis/BoundedVariation.lean
theorem comp_eq_of_monotoneOn (f : α → E) {t : Set β} (φ : β → α) (hφ : MonotoneOn φ t) :
    eVariationOn (f ∘ φ) t = eVariationOn f (φ '' t)
-- Mathlib/NumberTheory/Modular.lean
theorem re_T_zpow_smul (n : ℤ) : (T ^ n • z).re = z.re + n
-- Mathlib/Topology/Compactness/Lindelof.lean
/-- The preimage of a Lindelöf set under a closed embedding is a Lindelöf set. -/
theorem ClosedEmbedding.isLindelof_preimage {f : X → Y} (hf : ClosedEmbedding f)
    {K : Set Y} (hK : IsLindelof K) : IsLindelof (f ⁻¹' K)
-- Mathlib/Order/Bounds/Basic.lean
protected theorem BddAbove.insert [IsDirected α (· ≤ ·)] {s : Set α} (a : α) :
    BddAbove s → BddAbove (insert a s)
-- Mathlib/Computability/TuringMachine.lean
theorem ListBlank.map_modifyNth {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (F : PointedMap Γ Γ')
    (f : Γ → Γ) (f' : Γ' → Γ') (H : ∀ x, F (f x) = f' (F x)) (n) (L : ListBlank Γ) :
    (L.modifyNth f n).map F = (L.map F).modifyNth f' n
-- Mathlib/Algebra/MvPolynomial/Counit.lean
theorem counit_C (n : ℤ) : counit R (C n) = n
-- Mathlib/Data/Real/EReal.lean
@[simp]
lemma preimage_coe_Ioi_bot : Real.toEReal ⁻¹' Ioi ⊥ = univ
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
theorem measurableSet_bot_iff {s : Set α} : MeasurableSet[⊥] s ↔ s = ∅ ∨ s = univ
-- Mathlib/MeasureTheory/Measure/Restrict.lean
@[simp]
theorem restrict_empty : μ.restrict ∅ = 0
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
theorem bounds_nonempty {f : ContinuousMultilinearMap 𝕜 E G} :
    ∃ c, c ∈ { c | 0 ≤ c ∧ ∀ m, ‖f m‖ ≤ c * ∏ i, ‖m i‖ }
-- Mathlib/CategoryTheory/Equivalence.lean
/-- Compatibility of `changeFunctor` with identity isomorphisms of functors -/
theorem changeFunctor_refl (e : C ≌ D) : e.changeFunctor (Iso.refl _) = e
-- Mathlib/Data/Complex/Module.lean
theorem imaginaryPart_smul (z : ℂ) (a : A) : ℑ (z • a) = z.re • ℑ a + z.im • ℜ a
-- Mathlib/Topology/Order/Priestley.lean
theorem exists_isClopen_upper_of_not_le :
    ¬x ≤ y → ∃ U : Set α, IsClopen U ∧ IsUpperSet U ∧ x ∈ U ∧ y ∉ U
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma IsUnramifiedAtInfinitePlaces_of_odd_card_aut [IsGalois k K] [FiniteDimensional k K]
    (h : Odd (Fintype.card <| K ≃ₐ[k] K)) : IsUnramifiedAtInfinitePlaces k K
-- Mathlib/MeasureTheory/Function/SpecialFunctions/RCLike.lean
theorem measurable_of_re_im (hre : Measurable fun x => RCLike.re (f x))
    (him : Measurable fun x => RCLike.im (f x)) : Measurable f
-- Mathlib/Topology/Sets/Compacts.lean
protected theorem isCompact (s : NonemptyCompacts α) : IsCompact (s : Set α)
-- Mathlib/Tactic/Abel.lean
theorem const_add_term {α} [AddCommMonoid α] (k n x a a') (h : k + a = a') :
    k + @term α _ n x a = term n x a'
-- Mathlib/Analysis/NormedSpace/ContinuousAffineMap.lean
theorem coe_linear_eq_coe_contLinear (f : P →ᴬ[R] Q) :
    ((f : P →ᵃ[R] Q).linear : V → W) = (⇑f.contLinear : V → W)
-- Mathlib/Analysis/Calculus/LocalExtr/Basic.lean
/-- **Fermat's Theorem**: the derivative of a function at a local minimum equals zero. -/
theorem IsLocalMin.hasDerivAt_eq_zero (h : IsLocalMin f a) (hf : HasDerivAt f f' a) : f' = 0
-- Mathlib/Logic/Function/Defs.lean
theorem injective_id : Injective (@id α)
-- Mathlib/CategoryTheory/Sites/LocallyBijective.lean
lemma isLocallySurjective_presheafToSheaf_map_iff :
    Sheaf.IsLocallySurjective ((presheafToSheaf J A).map φ) ↔ IsLocallySurjective J φ
-- Mathlib/Order/Lattice.lean
theorem lt_sup_of_lt_right (h : c < b) : c < a ⊔ b
-- Mathlib/Logic/Relator.lean
protected lemma trans (hr : ∀ (a : α) (b : β) (c : γ), r₁₂ a b → r₂₃ b c → r₁₃ a c) :
    RightTotal r₁₂ → RightTotal r₂₃ → RightTotal r₁₃
-- Mathlib/Topology/Order/DenselyOrdered.lean
@[simp]
theorem frontier_Ico [NoMinOrder α] {a b : α} (h : a < b) : frontier (Ico a b) = {a, b}
-- Mathlib/Topology/Instances/Matrix.lean
@[simp]
theorem summable_matrix_conjTranspose [StarAddMonoid R] [ContinuousStar R] {f : X → Matrix m n R} :
    (Summable fun x => (f x)ᴴ) ↔ Summable f
-- Mathlib/Topology/UniformSpace/Equiv.lean
@[simp]
theorem coe_prodComm : ⇑(prodComm α β) = Prod.swap
-- Mathlib/Algebra/Module/Submodule/Map.lean
@[simp]
theorem _root_.MonoidHom.coe_toAdditive_map {G G₂ : Type*} [Group G] [Group G₂] (f : G →* G₂)
    (s : Subgroup G) :
    s.toAddSubgroup.map (MonoidHom.toAdditive f) = Subgroup.toAddSubgroup (s.map f)
-- Mathlib/Topology/Algebra/Order/UpperLower.lean
protected theorem IsLowerSet.closure : IsLowerSet s → IsLowerSet (closure s)
-- Mathlib/AlgebraicGeometry/Scheme.lean
@[simp]
lemma stalkMap_hom_inv_apply (e : X ≅ Y) (y : Y) (z) :
    e.inv.stalkMap y (e.hom.stalkMap (e.inv.val.base y) z) =
      Y.presheaf.stalkSpecializes (specializes_of_eq <| by simp) z
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive (attr := simp) add_lt_iff_neg_left]
theorem mul_lt_iff_lt_one_left' [CovariantClass α α (· * ·) (· < ·)]
    [ContravariantClass α α (· * ·) (· < ·)] {a b : α} :
    a * b < a ↔ b < 1
-- Mathlib/Logic/Basic.lean
theorem imp_iff_or_not {b a : Prop} : b → a ↔ a ∨ ¬b
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem front_eq (s : String) : front s = s.1.headD default
-- Mathlib/FieldTheory/IsPerfectClosure.lean
theorem lift_id_apply (x : K) : lift (RingHom.id K) j p x = j x
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
@[simp]
protected theorem isPath {u v : V} (p : G.Path u v) : (p : G.Walk u v).IsPath
-- Mathlib/Topology/LocallyFinite.lean
theorem preimage_continuous {g : Y → X} (hf : LocallyFinite f) (hg : Continuous g) :
    LocallyFinite (g ⁻¹' f ·)
-- Mathlib/Algebra/Quandle.lean
/-- Show that `toEnvelGroup.mapAux` sends equivalent expressions to equal terms.
-/
theorem well_def {R : Type*} [Rack R] {G : Type*} [Group G] (f : R →◃ Quandle.Conj G) :
    ∀ {a b : PreEnvelGroup R},
      PreEnvelGroupRel' R a b → toEnvelGroup.mapAux f a = toEnvelGroup.mapAux f b
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem decide_and (p q : Prop) [dpq : Decidable (p ∧ q)] [dp : Decidable p] [dq : Decidable q] :
    decide (p ∧ q) = (p && q)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem bfamilyOfFamily'_typein {ι} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → α) (i) :
    bfamilyOfFamily' r f (typein r i) (typein_lt_type r i) = f i
-- Mathlib/Topology/ContinuousOn.lean
@[simp]
theorem nhdsWithin_empty (a : α) : 𝓝[∅] a = ⊥
-- Mathlib/Algebra/Polynomial/Roots.lean
theorem zero_of_eval_zero [Infinite R] (p : R[X]) (h : ∀ x, p.eval x = 0) : p = 0
-- Mathlib/Algebra/Tropical/Basic.lean
theorem add_eq_iff {x y z : Tropical R} : x + y = z ↔ x = z ∧ x ≤ y ∨ y = z ∧ y ≤ x
-- Mathlib/Data/List/Basic.lean
theorem foldr_eq_of_comm' : ∀ a b l, foldr f a (b :: l) = foldr f (f b a) l
-- Mathlib/Computability/Primrec.lean
theorem nat_casesOn {f : α → ℕ} {g : α → β} {h : α → ℕ → β} (hf : Primrec f) (hg : Primrec g)
    (hh : Primrec₂ h) : Primrec fun a => ((f a).casesOn (g a) (h a) : β)
-- Mathlib/Data/FunLike/Fintype.lean
/-- All `DFunLike`s are finite if their domain and codomain are.

Can't be an instance because it can cause infinite loops.
-/
theorem DFunLike.finite [Finite α] [∀ i, Finite (β i)] : Finite F
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/ArctanDeriv.lean
theorem hasDerivAt_arctan (x : ℝ) : HasDerivAt arctan (1 / (1 + x ^ 2)) x
-- Mathlib/LinearAlgebra/TensorAlgebra/Basic.lean
/-- The canonical linear map `M →ₗ[R] TensorAlgebra R M`.
-/
irreducible_def ι : M →ₗ[R] TensorAlgebra R M
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
/-- If `P` is a sheaf for `S`, and it is iso to `P'`, then `P'` is a sheaf for `S`. This shows that
"being a sheaf for a presieve" is a mathematical or hygienic property.
-/
theorem isSheafFor_iso {P' : Cᵒᵖ ⥤ Type w} (i : P ≅ P') : IsSheafFor P R → IsSheafFor P' R
-- Mathlib/RingTheory/Ideal/AssociatedPrime.lean
theorem IsAssociatedPrime.map_of_injective (h : IsAssociatedPrime I M) (hf : Function.Injective f) :
    IsAssociatedPrime I M'
-- Mathlib/Data/ZMod/Basic.lean
theorem val_intCast {n : ℕ} (a : ℤ) [NeZero n] : ↑(a : ZMod n).val = a % n
-- Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
@[simp]
theorem ι_range_map_map (f : Q₁ →qᵢ Q₂) :
    (ι Q₁).range.map (map f).toLinearMap = f.range.map (ι Q₂)
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem coe_dualDual : ⇑(dualDual α) = toDual ∘ toDual
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
/-- The product of two smooth partial homeomorphisms is smooth. -/
theorem contDiffGroupoid_prod {I : ModelWithCorners 𝕜 E H} {I' : ModelWithCorners 𝕜 E' H'}
    {e : PartialHomeomorph H H} {e' : PartialHomeomorph H' H'} (he : e ∈ contDiffGroupoid ⊤ I)
    (he' : e' ∈ contDiffGroupoid ⊤ I') : e.prod e' ∈ contDiffGroupoid ⊤ (I.prod I')
-- Mathlib/CategoryTheory/Bicategory/LocallyDiscrete.lean
@[simp]
lemma id_as (a : LocallyDiscrete C) : (𝟙 a : Discrete (a.as ⟶ a.as)).as = 𝟙 a.as
-- Mathlib/Algebra/Group/Equiv/Basic.lean
@[to_additive (attr := simp)]
theorem toMulHom_eq_coe (f : M ≃* N) : f.toMulHom = ↑f
-- Mathlib/Algebra/Ring/Subring/Pointwise.lean
theorem subset_pointwise_smul_iff {a : M} {S T : Subring R} : S ≤ a • T ↔ a⁻¹ • S ≤ T
-- Mathlib/Data/Set/Finite.lean
theorem infinite_of_forall_exists_gt (h : ∀ a, ∃ b ∈ s, a < b) : s.Infinite
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem blockDiagonal_sub [AddGroup α] (M N : o → Matrix m n α) :
    blockDiagonal (M - N) = blockDiagonal M - blockDiagonal N
-- Mathlib/LinearAlgebra/Lagrange.lean
theorem X_sub_C_dvd_nodal (v : ι → R) {i : ι} (hi : i ∈ s) : X - C (v i) ∣ nodal s v
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioi_injective : Injective (Ioi : α → Set α)
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- Suppose that the topology on `α` is defined by its restrictions to the sets of `𝔖`.

Then the set of continuous functions is closed
in the topology of uniform convergence on the sets of `𝔖`. -/
theorem isClosed_setOf_continuous [TopologicalSpace α] (h : RestrictGenTopology 𝔖) :
    IsClosed {f : α →ᵤ[𝔖] β | Continuous (toFun 𝔖 f)}
-- Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean
theorem comp_symm_deriv {x : M'} (hx : x ∈ e.target) :
    (mfderiv I I' e (e.symm x)).comp (mfderiv I' I e.symm x) =
      ContinuousLinearMap.id 𝕜 (TangentSpace I' x)
-- Mathlib/Combinatorics/Quiver/SingleObj.lean
theorem pathToList_listToPath (l : List α) : pathToList (listToPath l) = l
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem floor_int_add (z : ℤ) (a : α) : ⌊↑z + a⌋ = z + ⌊a⌋
-- Mathlib/Computability/TMToPartrec.lean
theorem trStmts₁_supports {S q} (H₁ : (q : Λ').Supports S) (HS₁ : trStmts₁ q ⊆ S) :
    Supports (trStmts₁ q) S
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem coe_toSubring (s : Subfield K) : (s.toSubring : Set K) = s
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem zero_lt_card {o} : 0 < card o ↔ 0 < o
-- Mathlib/Topology/Separation.lean
theorem HasSeparatingCover.mono {s₁ s₂ t₁ t₂ : Set X} (sc_st : HasSeparatingCover s₂ t₂)
    (s_sub : s₁ ⊆ s₂) (t_sub : t₁ ⊆ t₂) : HasSeparatingCover s₁ t₁
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- The cosine of the oriented angle between two nonzero vectors is the inner product divided by
the product of the norms. -/
theorem cos_oangle_eq_inner_div_norm_mul_norm {x y : V} (hx : x ≠ 0) (hy : y ≠ 0) :
    Real.Angle.cos (o.oangle x y) = ⟪x, y⟫ / (‖x‖ * ‖y‖)
-- Mathlib/RingTheory/WittVector/Basic.lean
private theorem ghostFun_intCast (i : ℤ) : ghostFun (i : 𝕎 R) = i
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem disjoint_singleton {l : Multiset α} {a : α} : Disjoint l {a} ↔ a ∉ l
-- Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean
lemma eventually_atTop_ge {b : ℝ} (hb : b ∈ Set.Ioo 0 1) (hf : GrowsPolynomially f) :
    ∃ c > 0, ∀ᶠ x in atTop, ∀ u ∈ Set.Icc (b * x) x, c * f x ≤ f u
-- Mathlib/CategoryTheory/Limits/FilteredColimitCommutesFiniteLimit.lean
/-- `(G ⋙ lim).obj j` = `limit (G.obj j)` definitionally, so this
is just a variant of `limit_ext'`. -/
@[ext] lemma comp_lim_obj_ext {j : J} {G : J ⥤ K ⥤ Type v} (x y : (G ⋙ lim).obj j)
    (w : ∀ (k : K), limit.π (G.obj j) k x = limit.π (G.obj j) k y) : x = y
-- Mathlib/Geometry/RingedSpace/PresheafedSpace.lean
theorem ofRestrict_top_c (X : PresheafedSpace C) :
    (X.ofRestrict (Opens.openEmbedding ⊤)).c =
      eqToHom
        (by
          rw [restrict_top_presheaf, ← Presheaf.Pushforward.comp_eq]
          erw [Iso.inv_hom_id]
          rw [Presheaf.id_pushforward]
          dsimp)
-- Mathlib/Data/Multiset/Basic.lean
@[simp] theorem zero_union : 0 ∪ s = s
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
theorem combo_eq_smul_add_smul (a : Int) (xs : IntList) (b : Int) (ys : IntList) :
    combo a xs b ys = a * xs + b * ys
-- Mathlib/Analysis/Calculus/DiffContOnCl.lean
theorem sub (hf : DiffContOnCl 𝕜 f s) (hg : DiffContOnCl 𝕜 g s) : DiffContOnCl 𝕜 (f - g) s
-- Mathlib/Computability/Partrec.lean
theorem nat_div2 : Computable Nat.div2
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
lemma measure_compl₀ (h : NullMeasurableSet s μ) (hs : μ s ≠ ∞) :
    μ sᶜ = μ Set.univ - μ s
-- Mathlib/Data/Nat/MaxPowDiv.lean
@[simp]
theorem zero {p : ℕ} : maxPowDiv p 0 = 0
-- Mathlib/Algebra/GroupWithZero/Semiconj.lean
theorem div_right (h : SemiconjBy a x y) (h' : SemiconjBy a x' y') :
    SemiconjBy a (x / x') (y / y')
-- Mathlib/Data/Real/Basic.lean
theorem ext_cauchy {x y : Real} : x.cauchy = y.cauchy → x = y
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
/-- The restriction of a `K`-Lipschitz function is `K`-Lipschitz. -/
protected theorem restrict (hf : LipschitzWith K f) (s : Set α) : LipschitzWith K (s.restrict f)
-- Mathlib/RingTheory/PowerSeries/WellKnown.lean
theorem map_invUnitsSub (f : R →+* S) (u : Rˣ) :
    map f (invUnitsSub u) = invUnitsSub (Units.map (f : R →* S) u)
-- Mathlib/RepresentationTheory/Action/Monoidal.lean
theorem rightUnitor_hom_hom {X : Action V G} : Hom.hom (ρ_ X).hom = (ρ_ X.V).hom
-- Mathlib/Algebra/Order/Ring/Basic.lean
@[gcongr]
theorem pow_le_pow_right (ha : 1 ≤ a) (h : n ≤ m) : a ^ n ≤ a ^ m
-- Mathlib/Algebra/Order/Ring/Abs.lean
lemma pow_eq_pow_iff_of_ne_zero (hn : n ≠ 0) : a ^ n = b ^ n ↔ a = b ∨ a = -b ∧ Even n
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
theorem trim_eq_iInf' (s : Set α) : m.trim s = ⨅ t : { t // s ⊆ t ∧ MeasurableSet t }, m t
-- Mathlib/Order/SupClosed.lean
lemma supClosed_range [FunLike F α β] [SupHomClass F α β] (f : F) : SupClosed (Set.range f)
-- Mathlib/Logic/Equiv/PartialEquiv.lean
protected theorem union {s' t'} (h : e.IsImage s t) (h' : e.IsImage s' t') :
    e.IsImage (s ∪ s') (t ∪ t')
-- Mathlib/Probability/Independence/Kernel.lean
theorem indep_of_indep_of_le_right {m₁ m₂ m₃ : MeasurableSpace Ω} {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} (h_indep : Indep m₁ m₂ κ μ) (h32 : m₃ ≤ m₂) :
    Indep m₁ m₃ κ μ
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
theorem coeff_zero_X_mul (φ : MvPowerSeries σ R) (s : σ) : coeff R (0 : σ →₀ ℕ) (X s * φ) = 0
-- Mathlib/MeasureTheory/Measure/AddContent.lean
lemma addContent_sUnion (h_ss : ↑I ⊆ C)
    (h_dis : PairwiseDisjoint (I : Set (Set α)) id) (h_mem : ⋃₀ ↑I ∈ C) :
    m (⋃₀ I) = ∑ u ∈ I, m u
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem succ_mk (n i : Nat) (h : i < n) :
    Fin.succ ⟨i, h⟩ = ⟨i + 1, Nat.succ_lt_succ h⟩
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem tendstoLocallyUniformlyOn_biUnion {s : Set γ} {S : γ → Set α} (hS : ∀ i ∈ s, IsOpen (S i))
    (h : ∀ i ∈ s, TendstoLocallyUniformlyOn F f p (S i)) :
    TendstoLocallyUniformlyOn F f p (⋃ i ∈ s, S i)
-- Mathlib/RingTheory/PiTensorProduct.lean
@[simp] lemma tprod_mul_tprod (x y : (i : ι) → A i) :
    tprod R x * tprod R y = tprod R (x * y)
-- Mathlib/Data/Finsupp/Defs.lean
@[simp] theorem erase_update_eq_erase (f : α →₀ M) (a : α) (b : M) :
    erase a (update f a b) = erase a f
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem toLp_sub {f g : α → E} (hf : Memℒp f p μ) (hg : Memℒp g p μ) :
    (hf.sub hg).toLp (f - g) = hf.toLp f - hg.toLp g
-- Mathlib/RingTheory/PrimeSpectrum.lean
theorem zeroLocus_iUnion {ι : Sort*} (s : ι → Set R) :
    zeroLocus (⋃ i, s i) = ⋂ i, zeroLocus (s i)
-- Mathlib/FieldTheory/Separable.lean
/-- If the minimal polynomial of `x : K` over `F` is separable, then `x` is integral over `F`,
because the minimal polynomial of a non-integral element is `0`, which is not separable. -/
theorem IsSeparable.isIntegral {x : K} (h : IsSeparable F x) : IsIntegral F x