ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/AlgebraicGeometry/StructureSheaf.lean
@[simp, reassoc, elementwise]
theorem stalkSpecializes_stalk_to_fiber {R : Type*} [CommRing R] {x y : PrimeSpectrum R}
    (h : x ⤳ y) :
    (structureSheaf R).presheaf.stalkSpecializes h ≫ StructureSheaf.stalkToFiberRingHom R x =
      StructureSheaf.stalkToFiberRingHom R y ≫
      -- Porting note: `PrimeSpectrum.localizationMapOfSpecializes h` by itself is interpreted as a
      -- ring homomorphism, so it is changed in a way to force it being interpreted as categorical
      -- arrow.
      (show CommRingCat.of (Localization.AtPrime y.asIdeal) ⟶
        CommRingCat.of (Localization.AtPrime x.asIdeal)
        from PrimeSpectrum.localizationMapOfSpecializes h)
-- Mathlib/Analysis/Calculus/TangentCone.lean
theorem uniqueDiffOn_Icc {a b : ℝ} (hab : a < b) : UniqueDiffOn ℝ (Icc a b)
-- Mathlib/Data/List/Indexes.lean
theorem mapIdx_eq_ofFn (l : List α) (f : ℕ → α → β) :
    l.mapIdx f = ofFn fun i : Fin l.length ↦ f (i : ℕ) (l.get i)
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[arith_mult]
theorem intCast {f : ArithmeticFunction ℤ} [Ring R] (h : f.IsMultiplicative) :
    IsMultiplicative (f : ArithmeticFunction R)
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem isEquiv_valuation_valuationSubring : v.IsEquiv v.valuationSubring.valuation
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem get_cons_zero : get (a::l) (0 : Fin (l.length + 1)) = a
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
theorem mul_inv_rev (A B : Matrix n n α) : (A * B)⁻¹ = B⁻¹ * A⁻¹
-- Mathlib/GroupTheory/GroupAction/Hom.lean
/-- If Y/X/M forms a scalar tower, any map X → Y preserving X-action also preserves M-action. -/
theorem _root_.IsScalarTower.smulHomClass [MulOneClass X] [SMul X Y] [IsScalarTower M' X Y]
    [MulActionHomClass F X X Y] : MulActionHomClass F M' X Y
-- Mathlib/MeasureTheory/Constructions/Prod/Integral.lean
/-- Reversed version of **Fubini's Theorem**. -/
theorem integral_integral {f : α → β → E} (hf : Integrable (uncurry f) (μ.prod ν)) :
    ∫ x, ∫ y, f x y ∂ν ∂μ = ∫ z, f z.1 z.2 ∂μ.prod ν
-- Mathlib/Analysis/Normed/Operator/ContinuousLinearMap.lean
@[simp, norm_cast]
theorem LinearMap.mkContinuous_coe (C : ℝ) (h : ∀ x, ‖f x‖ ≤ C * ‖x‖) :
    (f.mkContinuous C h : E →ₛₗ[σ] F) = f
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem fst_prod_snd [Module R₁ M₂] : (fst R₁ M₁ M₂).prod (snd R₁ M₁ M₂) = id R₁ (M₁ × M₂)
-- Mathlib/RingTheory/DedekindDomain/Different.lean
lemma dual_inv_le :
    (dual A K I)⁻¹ ≤ I
-- Mathlib/Algebra/Order/GroupWithZero/Canonical.lean
lemma zero_eq_bot : (0 : WithZero α) = ⊥
-- Mathlib/NumberTheory/ModularForms/SlashInvariantForms.lean
@[simp]
theorem coe_mul {k₁ k₂ : ℤ} {Γ : Subgroup SL(2, ℤ)} (f : SlashInvariantForm Γ k₁)
    (g : SlashInvariantForm Γ k₂) : ⇑(f.mul g) = ⇑f * ⇑g
-- Mathlib/LinearAlgebra/Finsupp.lean
@[simp]
theorem mapRange.linearMap_id :
    mapRange.linearMap LinearMap.id = (LinearMap.id : (α →₀ M) →ₗ[R] _)
-- Mathlib/FieldTheory/PolynomialGaloisGroup.lean
/-- `gal p` embeds as a subgroup of permutations of the roots of `p` in `E`. -/
theorem galActionHom_injective [Fact (p.Splits (algebraMap F E))] :
    Function.Injective (galActionHom p E)
-- Mathlib/Data/Nat/Factorial/Basic.lean
theorem add_factorial_succ_lt_factorial_add_succ {i : ℕ} (n : ℕ) (hi : 2 ≤ i) :
    i + (n + 1)! < (i + n + 1)!
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
theorem fderivWithin_sum (hxs : UniqueDiffWithinAt 𝕜 s x)
    (h : ∀ i ∈ u, DifferentiableWithinAt 𝕜 (A i) s x) :
    fderivWithin 𝕜 (fun y => ∑ i ∈ u, A i y) s x = ∑ i ∈ u, fderivWithin 𝕜 (A i) s x
-- Mathlib/CategoryTheory/Sites/Sheaf.lean
@[reassoc (attr := simp)]
theorem IsSheaf.amalgamate_map {A : Type u₂} [Category.{v₂} A] {E : A} {X : C} {P : Cᵒᵖ ⥤ A}
    (hP : Presheaf.IsSheaf J P) (S : J.Cover X) (x : ∀ I : S.Arrow, E ⟶ P.obj (op I.Y))
    (hx : ∀ ⦃I₁ I₂ : S.Arrow⦄ (r : I₁.Relation I₂),
       x I₁ ≫ P.map r.g₁.op = x I₂ ≫ P.map r.g₂.op)
    (I : S.Arrow) :
    hP.amalgamate S x hx ≫ P.map I.f.op = x _
-- Mathlib/Topology/Sheaves/Stalks.lean
theorem app_surjective_of_stalkFunctor_map_bijective {F G : Sheaf C X} (f : F ⟶ G) (U : Opens X)
    (h : ∀ x : U, Function.Bijective ((stalkFunctor C x.val).map f.1)) :
    Function.Surjective (f.1.app (op U))
-- Mathlib/Data/NNRat/Defs.lean
theorem ne_iff {x y : ℚ≥0} : (x : ℚ) ≠ (y : ℚ) ↔ x ≠ y
-- Mathlib/CategoryTheory/Localization/FiniteProducts.lean
lemma hasProductsOfShape (J : Type) [Finite J] [HasProductsOfShape J C]
    (hW : W.IsStableUnderProductsOfShape J) :
    HasProductsOfShape J D
-- Mathlib/Algebra/Ring/Hom/Defs.lean
/-- Ring homomorphisms map zero to zero. -/
protected theorem map_zero (f : α →+* β) : f 0 = 0
-- Mathlib/Algebra/Algebra/Operations.lean
theorem mul_iSup (t : Submodule R A) (s : ι → Submodule R A) : (t * ⨆ i, s i) = ⨆ i, t * s i
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- A set is contained in its affine span. -/
theorem subset_affineSpan (s : Set P) : s ⊆ affineSpan k s
-- Mathlib/Algebra/Lie/TensorProduct.lean
/-- A useful alternative characterisation of Lie ideal operations on Lie submodules.

Given a Lie ideal `I ⊆ L` and a Lie submodule `N ⊆ M`, by tensoring the inclusion maps and then
applying the action of `L` on `M`, we obtain morphism of Lie modules `f : I ⊗ N → L ⊗ M → M`.

This lemma states that `⁅I, N⁆ = range f`. -/
theorem lieIdeal_oper_eq_tensor_map_range :
    ⁅I, N⁆ = ((toModuleHom R L M).comp (mapIncl I N : (↥I) ⊗[R] (↥N) →ₗ⁅R,L⁆ L ⊗[R] M)).range
-- Mathlib/Order/Lattice.lean
theorem inf_lt_of_right_lt (h : b < c) : a ⊓ b < c
-- Mathlib/RingTheory/AlgebraicIndependent.lean
/-- A set of algebraically independent elements in an algebra `A` over a ring `K` is also
algebraically independent over a subring `R` of `K`. -/
theorem AlgebraicIndependent.restrictScalars {K : Type*} [CommRing K] [Algebra R K] [Algebra K A]
    [IsScalarTower R K A] (hinj : Function.Injective (algebraMap R K))
    (ai : AlgebraicIndependent K x) : AlgebraicIndependent R x
-- Mathlib/Probability/ProbabilityMassFunction/Constructions.lean
@[simp]
theorem bernoulli_apply : bernoulli p h b = cond b p (1 - p)
-- Mathlib/Data/ENNReal/Real.lean
theorem toReal_nsmul (a : ℝ≥0∞) (n : ℕ) : (n • a).toReal = n • a.toReal
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- If `𝓕` is a filter on `β × β`, then the set of all `UniformFun.gen α β V` for
`V ∈ 𝓕` is a filter basis on `(α →ᵤ β) × (α →ᵤ β)`. This will only be applied to `𝓕 = 𝓤 β` when
`β` is equipped with a `UniformSpace` structure, but it is useful to define it for any filter in
order to be able to state that it has a lower adjoint (see `UniformFun.gc`). -/
protected theorem isBasis_gen (𝓑 : Filter <| β × β) :
    IsBasis (fun V : Set (β × β) => V ∈ 𝓑) (UniformFun.gen α β)
-- Mathlib/Data/FunLike/Equiv.lean
/-- This lemma is only supposed to be used in the generic context, when working with instances
of classes extending `EquivLike`.
For concrete isomorphism types such as `Equiv`, you should use `Equiv.apply_symm_apply`
or its equivalent.

TODO: define a generic form of `Equiv.symm`. -/
@[simp]
theorem apply_inv_apply (e : E) (b : β) : e (EquivLike.inv e b) = b
-- Mathlib/RingTheory/Ideal/Quotient.lean
theorem lift_surjective_of_surjective (I : Ideal R) {f : R →+* S} (H : ∀ a : R, a ∈ I → f a = 0)
    (hf : Function.Surjective f) : Function.Surjective (Ideal.Quotient.lift I f H)
-- Mathlib/Combinatorics/SimpleGraph/Density.lean
@[simp]
theorem edgeDensity_empty_right (s : Finset α) : G.edgeDensity s ∅ = 0
-- Mathlib/MeasureTheory/Function/ConvergenceInMeasure.lean
theorem exists_nat_measure_lt_two_inv (hfg : TendstoInMeasure μ f atTop g) (n : ℕ) :
    ∃ N, ∀ m ≥ N, μ { x | (2 : ℝ)⁻¹ ^ n ≤ dist (f m x) (g x) } ≤ (2⁻¹ : ℝ≥0∞) ^ n
-- Mathlib/Data/Finset/Piecewise.lean
lemma piecewise_le_of_le_of_le (hf : f ≤ h) (hg : g ≤ h) : s.piecewise f g ≤ h
-- Mathlib/CategoryTheory/EffectiveEpi/Preserves.lean
lemma finite_effectiveEpiFamily_of_map (F : C ⥤ D) [ReflectsFiniteEffectiveEpiFamilies F]
    {α : Type} [Finite α] {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B))
    (h : EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a))) :
    EffectiveEpiFamily X π
-- Mathlib/Data/ENNReal/Operations.lean
/-- This lemma has an abbreviated name because it is used frequently. -/
theorem cancel_of_lt {a : ℝ≥0∞} (h : a < ∞) : AddLECancellable a
-- Mathlib/RingTheory/WittVector/IsPoly.lean
/-- The composition of a binary polynomial function
 with a unary polynomial function in the second argument is polynomial. -/
theorem compRight {g f} [IsPoly₂ p g] [IsPoly p f] :
    IsPoly₂ p fun _R _Rcr x y => g x (f y)
-- Mathlib/Order/RelIso/Basic.lean
@[ext]
theorem ext ⦃f g : r →r s⦄ (h : ∀ x, f x = g x) : f = g
-- Mathlib/Data/Complex/Order.lean
lemma monotone_ofReal : Monotone ofReal'
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
/-- If `c ∉ {0, ∞}` and `m₁ d ≤ c * m₂ d` for `d < ε` for some `ε > 0`
(we use `≤ᶠ[𝓝[≥] 0]` to state this), then `mkMetric m₁ hm₁ ≤ c • mkMetric m₂ hm₂`. -/
theorem mkMetric_mono_smul {m₁ m₂ : ℝ≥0∞ → ℝ≥0∞} {c : ℝ≥0∞} (hc : c ≠ ∞) (h0 : c ≠ 0)
    (hle : m₁ ≤ᶠ[𝓝[≥] 0] c • m₂) : (mkMetric m₁ : OuterMeasure X) ≤ c • mkMetric m₂
-- Mathlib/Topology/Algebra/Valued/ValuationTopology.lean
theorem hasBasis_uniformity : (uniformity R).HasBasis (fun _ => True)
    fun γ : Γ₀ˣ => { p : R × R | v (p.2 - p.1) < (γ : Γ₀) }
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma add_of_Y_ne' {x₁ x₂ y₁ y₂ : F} {h₁ : W.Nonsingular x₁ y₁} {h₂ : W.Nonsingular x₂ y₂}
    (hy : y₁ ≠ W.negY x₂ y₂) :
    some h₁ + some h₂ = -some (nonsingular_negAdd h₁ h₂ fun _ ↦ hy)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem nontrivial_iff : Nontrivial (Subgroup G) ↔ Nontrivial G
-- Mathlib/Analysis/Normed/Lp/LpEquiv.lean
theorem equiv_lpPiLp_norm [Fintype α] (f : lp E p) : ‖Equiv.lpPiLp f‖ = ‖f‖
-- Mathlib/Topology/Order.lean
theorem coinduced_compose [tα : TopologicalSpace α] {f : α → β} {g : β → γ} :
    (tα.coinduced f).coinduced g = tα.coinduced (g ∘ f)
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem num_mul_eq_mul_denom_iff {x : RatFunc K} {p q : K[X]} (hq : q ≠ 0) :
    x.num * q = p * x.denom ↔ x = algebraMap _ _ p / algebraMap _ _ q
-- Mathlib/Order/Filter/Basic.lean
theorem tendsto_of_isEmpty [IsEmpty α] {f : α → β} {la : Filter α} {lb : Filter β} :
    Tendsto f la lb
-- Mathlib/Topology/Maps/Basic.lean
theorem of_isEmpty [IsEmpty X] (f : X → Y) : OpenEmbedding f
-- Mathlib/Order/Filter/SmallSets.lean
/-- `g` converges to `f.smallSets` if for all `s ∈ f`, eventually we have `g x ⊆ s`. -/
theorem tendsto_smallSets_iff {f : α → Set β} :
    Tendsto f la lb.smallSets ↔ ∀ t ∈ lb, ∀ᶠ x in la, f x ⊆ t
-- Mathlib/SetTheory/Cardinal/Basic.lean
lemma succ_natCast (n : ℕ) : Order.succ (n : Cardinal) = n + 1
-- Mathlib/NumberTheory/Bertrand.lean
/-- A lemma that tells us that, in the case where Bertrand's postulate does not hold, the prime
factorization of the central binomial coefficent only has factors at most `2 * n / 3 + 1`.
-/
theorem centralBinom_factorization_small (n : ℕ) (n_large : 2 < n)
    (no_prime : ¬∃ p : ℕ, p.Prime ∧ n < p ∧ p ≤ 2 * n) :
    centralBinom n = ∏ p ∈ Finset.range (2 * n / 3 + 1), p ^ (centralBinom n).factorization p
-- Mathlib/Data/Complex/Exponential.lean
theorem tan_mul_cos {x : ℝ} (hx : cos x ≠ 0) : tan x * cos x = sin x
-- Mathlib/MeasureTheory/Measure/Content.lean
@[to_additive]
theorem outerMeasure_pos_of_is_mul_left_invariant [Group G] [TopologicalGroup G]
    (h3 : ∀ (g : G) {K : Compacts G}, μ (K.map _ <| continuous_mul_left g) = μ K) (K : Compacts G)
    (hK : μ K ≠ 0) {U : Set G} (h1U : IsOpen U) (h2U : U.Nonempty) : 0 < μ.outerMeasure U
-- Mathlib/RingTheory/IsAdjoinRoot.lean
@[simp]
theorem aequiv_map (h : IsAdjoinRoot S f) (h' : IsAdjoinRoot T f) (z : R[X]) :
    h.aequiv h' (h.map z) = h'.map z
-- Mathlib/Data/Set/Lattice.lean
theorem iInter₂_subset {s : ∀ i, κ i → Set α} (i : ι) (j : κ i) : ⋂ (i) (j), s i j ⊆ s i j
-- Mathlib/Topology/GDelta.lean
/-- A nowhere dense set `s` is contained in a closed nowhere dense set (namely, its closure). -/
lemma IsNowhereDense.subset_of_closed_isNowhereDense {s : Set X} (hs : IsNowhereDense s) :
    ∃ t : Set X, s ⊆ t ∧ IsNowhereDense t ∧ IsClosed t
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem polarBilin_toQuadraticMap : polarBilin (toQuadraticMap B) = B + flip B
-- Mathlib/Analysis/Normed/Algebra/TrivSqZeroExt.lean
@[simp] theorem nnnorm_inl (r : R) : ‖(inl r : tsze R M)‖₊ = ‖r‖₊
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
@[simp]
lemma Sigma.map'_id {f g : α → C} [HasCoproduct f] [HasCoproduct g] (p : ∀ b, f b ⟶ g b) :
    Sigma.map' id p = Sigma.map p
-- Mathlib/CategoryTheory/Sites/Whiskering.lean
lemma Sheaf.isSeparated [ConcreteCategory A] [J.HasSheafCompose (forget A)]
    (F : Sheaf J A) : Presheaf.IsSeparated J F.val
-- Mathlib/AlgebraicGeometry/Morphisms/UniversallyClosed.lean
theorem universallyClosed_respectsIso : RespectsIso @UniversallyClosed
-- Mathlib/Data/Matrix/Rank.lean
@[simp]
theorem rank_one [StrongRankCondition R] [DecidableEq n] :
    rank (1 : Matrix n n R) = Fintype.card n
-- Mathlib/RingTheory/Polynomial/Chebyshev.lean
theorem T_neg_two : T R (-2) = 2 * X ^ 2 - 1
-- Mathlib/Algebra/Order/Sub/Canonical.lean
theorem tsub_lt_iff_left (hbc : b ≤ a) : a - b < c ↔ a < b + c
-- Mathlib/Data/Nat/Log.lean
theorem le_pow_clog {b : ℕ} (hb : 1 < b) (x : ℕ) : x ≤ b ^ clog b x
-- Mathlib/Data/Nat/Digits.lean
@[simp]
lemma digits_of_two_le_of_pos {b : ℕ} (hb : 2 ≤ b) (hn : 0 < n) :
    Nat.digits b n = n % b :: Nat.digits b (n / b)
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive (attr := simp)]
lemma finEquivPowers_apply (x : G) (hx) {n : Fin (orderOf x)} :
    finEquivPowers x hx n = ⟨x ^ (n : ℕ), n, rfl⟩
-- Mathlib/RingTheory/Ideal/Quotient.lean
theorem zero_ne_one_iff {I : Ideal R} : (0 : R ⧸ I) ≠ 1 ↔ I ≠ ⊤
-- Mathlib/Topology/VectorBundle/Basic.lean
/-- The space `Bundle.TotalSpace F E` (for `E : B → Type*` such that each `E x` is a topological
vector space) has a topological vector space structure with fiber `F` (denoted with
`VectorBundle R F E`) if around every point there is a fiber bundle trivialization which is linear
in the fibers. -/
class VectorBundle : Prop where
  trivialization_linear' : ∀ (e : Trivialization F (π F E)) [MemTrivializationAtlas e], e.IsLinear R
  continuousOn_coordChange' :
    ∀ (e e' : Trivialization F (π F E)) [MemTrivializationAtlas e] [MemTrivializationAtlas e'],
      ContinuousOn (fun b => Trivialization.coordChangeL R e e' b : B → F →L[R] F)
        (e.baseSet ∩ e'.baseSet)
-- Mathlib/Algebra/Field/Defs.lean
theorem smul_def (a : ℚ) (x : K) : a • x = ↑a * x
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem mem_support_toFun (f : Π₀ i, β i) (i) : i ∈ f.support ↔ f i ≠ 0
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem smul_measure (c : ℝ≥0∞) (hc_ne_zero : c ≠ 0) (hT : FinMeasAdditive μ T) :
    FinMeasAdditive (c • μ) T
-- Mathlib/Analysis/Convolution.lean
theorem AEStronglyMeasurable.convolution_integrand_swap_snd' {x : G}
    (hf : AEStronglyMeasurable f <| map (fun t => x - t) μ) (hg : AEStronglyMeasurable g μ) :
    AEStronglyMeasurable (fun t => L (f (x - t)) (g t)) μ
-- Mathlib/Data/Set/Basic.lean
theorem inter_inter_inter_comm (s t u v : Set α) : s ∩ t ∩ (u ∩ v) = s ∩ u ∩ (t ∩ v)
-- Mathlib/Data/ZMod/IntUnitsPower.lean
@[simp] lemma uzpow_zero (s : ℤˣ) : (s ^ (0 : R) : ℤˣ) = (1 : ℤˣ)
-- Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean
@[simp]
theorem dist_center_dist (z w : ℍ) :
    dist (z : ℂ) (w.center (dist z w)) = w.im * Real.sinh (dist z w)
-- Mathlib/Algebra/Category/ModuleCat/Sheaf/Generators.lean
/-- The data of generating sections of the restriction of a sheaf of modules
over a covering of the terminal object. -/
structure LocalGeneratorsData where
  /-- the index type of the covering -/
  I : Type u'
  /-- a family of objects which cover the terminal object -/
  X : I → C
  coversTop : J.CoversTop X
  /-- the data of sections of `M` over `X i` which generate `M.over (X i)` -/
  generators (i : I) : (M.over (X i)).GeneratingSections
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Valid'.node4L_lemma₅ {a b c d : ℕ} (lr₂ : 3 * (b + c + 1 + d) ≤ 16 * a + 9)
    (mr₁ : 2 * d ≤ b + c + 1) (mm₂ : c ≤ 3 * b) : c + d + 1 ≤ 3 * (a + b + 1)
-- Mathlib/CategoryTheory/NatIso.lean
@[simp]
theorem cancel_natIso_inv_right {X : D} {Y : C} (f f' : X ⟶ G.obj Y) :
    f ≫ α.inv.app Y = f' ≫ α.inv.app Y ↔ f = f'
-- Mathlib/Topology/Constructions.lean
theorem Continuous.update [DecidableEq ι] (hf : Continuous f) (i : ι) {g : X → π i}
    (hg : Continuous g) : Continuous fun a => update (f a) i (g a)
-- Mathlib/Order/Part.lean
lemma Antitone.partBind (hf : Antitone f) (hg : Antitone g) :
    Antitone fun x ↦ (f x).bind (g x)
-- Mathlib/FieldTheory/Perfect.lean
@[simp]
theorem rootsExpandEquivRoots_apply (x) : (rootsExpandEquivRoots p f x : R) = x ^ p
-- Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean
@[reassoc (attr := simp)]
theorem Cotrident.app_one (s : Cotrident f) (j : J) : f j ≫ s.ι.app one = s.ι.app zero
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
theorem ne_of_isReal_isComplex {w w' : InfinitePlace K} (h : IsReal w) (h' : IsComplex w') :
    w ≠ w'
-- Mathlib/Probability/Process/Stopping.lean
theorem stoppedProcess_eq_of_ge {u : ι → Ω → β} {τ : Ω → ι} {i : ι} {ω : Ω} (h : τ ω ≤ i) :
    stoppedProcess u τ i ω = u (τ ω) ω
-- Mathlib/LinearAlgebra/AffineSpace/Ordered.lean
theorem lineMap_le_right_iff_le (h : r < 1) : lineMap a b r ≤ b ↔ a ≤ b
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
protected theorem isCompact [ProperSpace 𝕜] (a : A) : IsCompact (σ a)
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean
theorem isComplete_aeStronglyMeasurable' [hp : Fact (1 ≤ p)] [CompleteSpace F] (hm : m ≤ m0) :
    IsComplete {f : Lp F p μ | AEStronglyMeasurable' m f μ}
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem max_eq_right {a b : Nat} (h : a ≤ b) : max a b = b
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem _root_.IsCoprime.codisjoint (h : IsCoprime I J) : Codisjoint I J
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem round_add_nat (x : α) (y : ℕ) : round (x + y) = round x + y
-- Mathlib/Topology/Order/IntermediateValue.lean
theorem Continuous.strictMono_of_inj_boundedOrder' [BoundedOrder α] {f : α → δ}
    (hf_c : Continuous f) (hf_i : Injective f) : StrictMono f ∨ StrictAnti f
-- Mathlib/Analysis/Calculus/UniformLimitsDeriv.lean
/-- A slight variant of `hasDerivAt_of_tendstoLocallyUniformlyOn` with the assumption stated in
terms of `DifferentiableOn` rather than `HasDerivAt`. This makes a few proofs nicer in complex
analysis where holomorphicity is assumed but the derivative is not known a priori. -/
theorem hasDerivAt_of_tendsto_locally_uniformly_on' [NeBot l] {s : Set 𝕜} (hs : IsOpen s)
    (hf' : TendstoLocallyUniformlyOn (deriv ∘ f) g' l s)
    (hf : ∀ᶠ n in l, DifferentiableOn 𝕜 (f n) s)
    (hfg : ∀ x ∈ s, Tendsto (fun n => f n x) l (𝓝 (g x))) (hx : x ∈ s) : HasDerivAt g (g' x) x
-- Mathlib/ModelTheory/ElementarySubstructures.lean
@[simp]
theorem mem_top (x : M) : x ∈ (⊤ : L.ElementarySubstructure M)
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem _root_.MeasureTheory.Memℒp.neg_part {f : α → ℝ} (hf : Memℒp f p μ) :
    Memℒp (fun x => max (-f x) 0) p μ
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma isUnramified_iff_card_stabilizer_eq_one [IsGalois k K] :
    IsUnramified k w ↔ Nat.card (Stab w) = 1
-- Mathlib/MeasureTheory/Function/Jacobian.lean
/-- Let `f` be a function which is sufficiently close (in the Lipschitz sense) to a given linear
map `A`. Then it expands the volume of any set by at most `m` for any `m > det A`. -/
theorem addHaar_image_le_mul_of_det_lt (A : E →L[ℝ] E) {m : ℝ≥0}
    (hm : ENNReal.ofReal |A.det| < m) :
    ∀ᶠ δ in 𝓝[>] (0 : ℝ≥0),
      ∀ (s : Set E) (f : E → E), ApproximatesLinearOn f A s δ → μ (f '' s) ≤ m * μ s
-- Mathlib/Algebra/Group/Hom/Basic.lean
@[simp]
theorem coe_invMonoidHom : (invMonoidHom : α → α) = Inv.inv
-- Mathlib/Algebra/Quaternion.lean
@[norm_cast, simp]
theorem coe_pow (n : ℕ) : (↑(x ^ n) : ℍ[R]) = (x : ℍ[R]) ^ n
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- In the characteristic zero case, the centroid lies in the affine
span if the set is nonempty. -/
theorem centroid_mem_affineSpan_of_nonempty [CharZero k] {s : Finset ι} (p : ι → P)
    (h : s.Nonempty) : s.centroid k p ∈ affineSpan k (range p)
-- Mathlib/MeasureTheory/Constructions/HaarToSphere.lean
@[simp]
theorem toSphere_apply_univ : μ.toSphere univ = dim E * μ (ball 0 1)
-- Mathlib/Data/W/Basic.lean
@[simp]
theorem ofSigma_toSigma : ∀ w : WType β, ofSigma (toSigma w) = w
-- Mathlib/Order/Minimal.lean
theorem IsGreatest.maximals_eq [PartialOrder α] (h : IsGreatest s a) : maximals (· ≤ ·) s = {a}
-- Mathlib/Topology/Basic.lean
/-- If `x` is not an isolated point of a topological space, then the interior of `{x}` is empty. -/
@[simp]
theorem interior_singleton (x : X) [NeBot (𝓝[≠] x)] : interior {x} = (∅ : Set X)
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem ord_isLimit {c} (co : ℵ₀ ≤ c) : (ord c).IsLimit
-- Mathlib/RingTheory/Polynomial/Eisenstein/Basic.lean
theorem pow_natDegree_le_of_aeval_zero_of_monic_mem_map {x : S} (hx : aeval x f = 0)
    (hmo : f.Monic) :
    ∀ i, (f.map (algebraMap R S)).natDegree ≤ i → x ^ i ∈ 𝓟.map (algebraMap R S)
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
theorem filter_of_true {p : Box ι → Prop} (hp : ∀ J ∈ π, p J) : π.filter p = π
-- Mathlib/Algebra/Regular/SMul.lean
theorem of_mul [Mul R] [IsScalarTower R R M] (ab : IsSMulRegular M (a * b)) :
    IsSMulRegular M b
-- Mathlib/Data/Finset/Basic.lean
theorem mem_def {a : α} {s : Finset α} : a ∈ s ↔ a ∈ s.1
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
lemma toSpec_bijective {f : A} {m : ℕ} (f_deg : f ∈ 𝒜 m) (hm : 0 < m) :
    Function.Bijective (toSpec (𝒜 := 𝒜) (f := f))
-- Mathlib/Algebra/Star/StarRingHom.lean
@[simp]
theorem refl_symm : (StarRingEquiv.refl : A ≃⋆+* A).symm = StarRingEquiv.refl
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem sigmaFinite_bot_iff (μ : @Measure α ⊥) : SigmaFinite μ ↔ IsFiniteMeasure μ
-- Mathlib/Algebra/Polynomial/HasseDeriv.lean
theorem natDegree_hasseDeriv_le (p : R[X]) (n : ℕ) :
    natDegree (hasseDeriv n p) ≤ natDegree p - n
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem Memℒp.indicator (hs : MeasurableSet s) (hf : Memℒp f p μ) : Memℒp (s.indicator f) p μ
-- Mathlib/Algebra/Algebra/Equiv.lean
theorem coe_ringEquiv_injective : Function.Injective ((↑) : (A₁ ≃ₐ[R] A₂) → A₁ ≃+* A₂)
-- Mathlib/Data/Finsupp/Defs.lean
theorem embDomain_notin_range (f : α ↪ β) (v : α →₀ M) (a : β) (h : a ∉ Set.range f) :
    embDomain f v a = 0
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
/-- Multiplying each column by a fixed `v j` multiplies the determinant by
the product of the `v`s. -/
theorem det_mul_column (v : n → R) (A : Matrix n n R) :
    det (of fun i j => v i * A i j) = (∏ i, v i) * det A
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem setLIntegral_lt_top_of_isCompact [TopologicalSpace α] {s : Set α}
    (hs : μ s ≠ ∞) (hsc : IsCompact s) {f : α → ℝ≥0} (hf : Continuous f) :
    ∫⁻ x in s, f x ∂μ < ∞
-- Mathlib/SetTheory/Cardinal/ENat.lean
@[simp] lemma ofENat_le_ofNat {m : ℕ∞} {n : ℕ} [n.AtLeastTwo] :
    ofENat m ≤ no_index (OfNat.ofNat n) ↔ m ≤ OfNat.ofNat n
-- Mathlib/CategoryTheory/Monoidal/Mon_.lean
@[simp] theorem forgetMonoidal_ε : (forgetMonoidal C).ε = 𝟙 (𝟙_ C)
-- Mathlib/Algebra/Group/Commute/Units.lean
@[to_additive]
theorem units_inv_left : Commute (↑u) a → Commute (↑u⁻¹) a
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem inter_singleton_nonempty : (s ∩ {a}).Nonempty ↔ a ∈ s
-- Mathlib/Data/Matroid/Basic.lean
/-- Matroids obey the maximality axiom -/
theorem existsMaximalSubsetProperty_indep (M : Matroid α) :
    ∀ X, X ⊆ M.E → ExistsMaximalSubsetProperty M.Indep X
-- Mathlib/Analysis/Convex/Segment.lean
theorem segment_eq_image (x y : E) :
    [x -[𝕜] y] = (fun θ : 𝕜 => (1 - θ) • x + θ • y) '' Icc (0 : 𝕜) 1
-- Mathlib/CategoryTheory/Monoidal/Comon_.lean
theorem tensorObj_X (A B : Comon_ C) : (A ⊗ B).X = A.X ⊗ B.X
-- Mathlib/Topology/Algebra/ContinuousAffineMap.lean
theorem zero_apply (x : P) : (0 : P →ᴬ[R] W) x = 0