ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem map_eval₂Hom [CommSemiring S₂] (f : R →+* S₁) (g : σ → S₁) (φ : S₁ →+* S₂)
    (p : MvPolynomial σ R) : φ (eval₂Hom f g p) = eval₂Hom (φ.comp f) (fun i => φ (g i)) p
-- Mathlib/Algebra/Ring/BooleanRing.lean
/-- Order isomorphism between `α` considered as a Boolean ring considered as a Boolean algebra and
`α`. -/
@[simps!]
def OrderIso.asBoolAlgAsBoolRing (α : Type*) [BooleanAlgebra α] : AsBoolAlg (AsBoolRing α) ≃o α
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem range_algebraMap {R A : Type*} [CommRing R] [CommRing A] [Algebra R A]
    (S : Subalgebra R A) : (algebraMap S A).range = S.toSubring
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem coe_subgroupOf (H K : Subgroup G) : (H.subgroupOf K : Set K) = K.subtype ⁻¹' H
-- Mathlib/GroupTheory/Perm/Closure.lean
theorem closure_isCycle : closure { σ : Perm β | IsCycle σ } = ⊤
-- Mathlib/RepresentationTheory/GroupCohomology/Resolution.lean
theorem diagonalSucc_inv_single_single (g : G) (f : Gⁿ) (a b : k) :
    (diagonalSucc k G n).inv.hom (Finsupp.single g a ⊗ₜ Finsupp.single f b) =
      single (g • partialProd f) (a * b)
-- Mathlib/AlgebraicTopology/DoldKan/PInfty.lean
@[reassoc (attr := simp)]
theorem PInfty_comp_QInfty : (PInfty : K[X] ⟶ _) ≫ QInfty = 0
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
/-- If `α` is an infinite type, then `α ⊕ α` and `α` have the same cardinality. -/
theorem add_eq_self {c : Cardinal} (h : ℵ₀ ≤ c) : c + c = c
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
theorem toAlternatingMap_injective :
    Injective (toAlternatingMap : (M [⋀^ι]→L[R] N) → (M [⋀^ι]→ₗ[R] N))
-- Mathlib/Probability/Independence/Conditional.lean
theorem iCondIndepSet.iCondIndepFun_indicator [Zero β] [One β] {m : MeasurableSpace β}
    {s : ι → Set Ω} (hs : iCondIndepSet m' hm' s μ) :
    iCondIndepFun m' hm' (fun _n => m) (fun n => (s n).indicator fun _ω => 1) μ
-- Mathlib/Algebra/Order/Archimedean.lean
theorem exists_floor (x : α) : ∃ fl : ℤ, ∀ z : ℤ, z ≤ fl ↔ (z : α) ≤ x
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
protected theorem sub {B₁ B₂ : BilinForm R₁ M₁} (hB₁ : B₁.IsSymm) (hB₂ : B₂.IsSymm) :
    (B₁ - B₂).IsSymm
-- Mathlib/Algebra/Field/Basic.lean
theorem inv_sub_inv {a b : K} (ha : a ≠ 0) (hb : b ≠ 0) : a⁻¹ - b⁻¹ = (b - a) / (a * b)
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem eraseIdx_nil : ([] : List α).eraseIdx i = []
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive]
protected theorem div_le_div : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ / g₁ ≤ f₂ / g₂
-- Mathlib/CategoryTheory/Sites/Canonical.lean
/--
To show `P` is a sheaf for the binding of `U` with `B`, it suffices to show that `P` is a sheaf for
`U`, that `P` is a sheaf for each sieve in `B`, and that it is separated for any pullback of any
sieve in `B`.

This is mostly an auxiliary lemma to show `isSheafFor_trans`.
Adapted from [Elephant], Lemma C2.1.7(i) with suggestions as mentioned in
https://math.stackexchange.com/a/358709/
-/
theorem isSheafFor_bind (P : Cᵒᵖ ⥤ Type v) (U : Sieve X) (B : ∀ ⦃Y⦄ ⦃f : Y ⟶ X⦄, U f → Sieve Y)
    (hU : Presieve.IsSheafFor P (U : Presieve X))
    (hB : ∀ ⦃Y⦄ ⦃f : Y ⟶ X⦄ (hf : U f), Presieve.IsSheafFor P (B hf : Presieve Y))
    (hB' : ∀ ⦃Y⦄ ⦃f : Y ⟶ X⦄ (h : U f) ⦃Z⦄ (g : Z ⟶ Y),
      Presieve.IsSeparatedFor P (((B h).pullback g) : Presieve Z)) :
    Presieve.IsSheafFor P (Sieve.bind (U : Presieve X) B : Presieve X)
-- Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean
@[ext]
lemma ext' {F G : LaxBraidedFunctor C D} {α β : F ⟶ G} (w : ∀ X : C, α.app X = β.app X) : α = β
-- Mathlib/Data/ENNReal/Inv.lean
protected theorem mul_div_mul_left (a b : ℝ≥0∞) (hc : c ≠ 0) (hc' : c ≠ ⊤) :
    c * a / (c * b) = a / b
-- Mathlib/Geometry/Manifold/LocalDiffeomorph.lean
/-- A partial diffeomorphism on `s` is a function `f : M → N` such that `f` restricts to a
diffeomorphism `s → t` between open subsets of `M` and `N`, respectively.
This is an auxiliary definition and should not be used outside of this file. -/
structure PartialDiffeomorph extends PartialEquiv M N where
  open_source : IsOpen source
  open_target : IsOpen target
  contMDiffOn_toFun : ContMDiffOn I J n toFun source
  contMDiffOn_invFun : ContMDiffOn J I n invFun target
-- Mathlib/Data/QPF/Multivariate/Constructions/Fix.lean
theorem wrepr_equiv {α : TypeVec n} (x : q.P.W α) : WEquiv (wrepr x) x
-- .lake/packages/lean4/src/lean/Init/Data/Option/Basic.lean
@[simp] theorem min_none_some [Min α] {b : α} : min none (some b) = some b
-- Mathlib/Algebra/Category/ModuleCat/Sheaf.lean
/-- The obvious free sheaf of modules of rank `1`. -/
@[simps]
def unit : SheafOfModules R
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
theorem map_none : f <$> none = none
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
/-- If `s` is closed, being locally integrable on `s` wrt `μ` is equivalent to being locally
integrable with respect to `μ.restrict s`. For the one-way implication without assuming `s` closed,
see `locallyIntegrableOn_of_locallyIntegrable_restrict`. -/
theorem locallyIntegrableOn_iff_locallyIntegrable_restrict [OpensMeasurableSpace X]
    (hs : IsClosed s) : LocallyIntegrableOn f s μ ↔ LocallyIntegrable f (μ.restrict s)
-- Mathlib/Topology/Order/Basic.lean
theorem nhds_bot_basis_Iic [TopologicalSpace α] [LinearOrder α] [OrderBot α] [OrderTopology α]
    [Nontrivial α] [DenselyOrdered α] : (𝓝 ⊥).HasBasis (fun a : α => ⊥ < a) Iic
-- Mathlib/RingTheory/Localization/Integral.lean
theorem coeffIntegerNormalization_of_not_mem_support (p : S[X]) (i : ℕ) (h : coeff p i = 0) :
    coeffIntegerNormalization M p i = 0
-- Mathlib/Data/Set/Defs.lean
@[simp] theorem mem_range {x : α} : x ∈ range f ↔ ∃ y, f y = x
-- Mathlib/Order/WithBot.lean
theorem le_toDual_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
    a ≤ WithTop.toDual b ↔ b ≤ WithBot.ofDual a
-- Mathlib/Algebra/Associated/Basic.lean
theorem DvdNotUnit.isUnit_of_irreducible_right [CommMonoidWithZero α] {p q : α}
    (h : DvdNotUnit p q) (hq : Irreducible q) : IsUnit p
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean
lemma IsEquipartition.card_interedges_sparsePairs_le' (hP : P.IsEquipartition)
    (hε : 0 ≤ ε) :
    ((P.sparsePairs G ε).biUnion fun (U, V) ↦ G.interedges U V).card ≤
      ε * (A.card + P.parts.card) ^ 2
-- Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean
theorem Gamma_is_cong_sub (N : ℕ+) : IsCongruenceSubgroup (Gamma N)
-- Mathlib/Algebra/Order/Monovary.lean
lemma MonovaryOn.div_right₀ (hg₁ : ∀ i ∈ s, 0 ≤ g₁ i) (hg₂ : ∀ i ∈ s, 0 < g₂ i)
    (h₁ : MonovaryOn f g₁ s) (h₂ : AntivaryOn f g₂ s) : MonovaryOn f (g₁ / g₂) s
-- Mathlib/Data/Finsupp/Defs.lean
/-- Given `Finite α`, `equivFunOnFinite` is the `Equiv` between `α →₀ β` and `α → β`.
  (All functions on a finite type are finitely supported.) -/
@[simps]
def equivFunOnFinite [Finite α] : (α →₀ M) ≃ (α → M)
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Assoc.lean
theorem hasPullback_assoc_symm [HasPullback f₁ (g₃ ≫ f₂)] : HasPullback (g₂ ≫ f₃) f₄
-- Mathlib/MeasureTheory/Function/Jacobian.lean
/-- Integrability in the change of variable formula for differentiable functions: if a
function `f` is injective and differentiable on a measurable set `s`, then a function
`g : E → F` is integrable on `f '' s` if and only if `|(f' x).det| • g ∘ f` is
integrable on `s`. -/
theorem integrableOn_image_iff_integrableOn_abs_det_fderiv_smul (hs : MeasurableSet s)
    (hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) (hf : InjOn f s) (g : E → F) :
    IntegrableOn g (f '' s) μ ↔ IntegrableOn (fun x => |(f' x).det| • g (f x)) s μ
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The difference between two points (reversed) lies in their `vectorSpan`. -/
theorem vsub_rev_mem_vectorSpan_pair (p₁ p₂ : P) : p₂ -ᵥ p₁ ∈ vectorSpan k ({p₁, p₂} : Set P)
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
lemma isOpenMap_div_right (a : G) : IsOpenMap (· / a)
-- Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean
/-- The function `expNegInvGlue` is smooth. -/
protected theorem contDiff {n} : ContDiff ℝ n expNegInvGlue
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
protected theorem isometry : Isometry f
-- Mathlib/FieldTheory/Minpoly/IsIntegrallyClosed.lean
/-- For integrally closed domains, the minimal polynomial over the ring is the same as the minimal
polynomial over the fraction field. See `minpoly.isIntegrallyClosed_eq_field_fractions'` if
`S` is already a `K`-algebra. -/
theorem isIntegrallyClosed_eq_field_fractions [IsDomain S] {s : S} (hs : IsIntegral R s) :
    minpoly K (algebraMap S L s) = (minpoly R s).map (algebraMap R K)
-- Mathlib/Data/Real/Hyperreal.lean
theorem infiniteNeg_mul_infinitePos {x y : ℝ*} :
    InfiniteNeg x → InfinitePos y → InfiniteNeg (x * y)
-- Mathlib/Topology/Algebra/Ring/Basic.lean
/-- In a topological semiring, the right-multiplication `AddMonoidHom` is continuous. -/
theorem mulRight_continuous (x : α) : Continuous (AddMonoidHom.mulRight x)
-- Mathlib/Data/Num/Lemmas.lean
theorem zero_add (n : Num) : 0 + n = n
-- Mathlib/Data/Option/Basic.lean
@[simp]
theorem seq_some {α β} {a : α} {f : α → β} : some f <*> some a = some (f a)
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
theorem fderivWithin_const_sub (hxs : UniqueDiffWithinAt 𝕜 s x) (c : F) :
    fderivWithin 𝕜 (fun y => c - f y) s x = -fderivWithin 𝕜 f s x
-- Mathlib/Data/Multiset/Nodup.lean
@[simp]
theorem nodup_singleton : ∀ a : α, Nodup ({a} : Multiset α)
-- Mathlib/Algebra/Homology/ComplexShapeSigns.lean
lemma ε_add (p q : I) : c.ε (p + q) = c.ε p * c.ε q
-- Mathlib/Data/Rat/Cast/Order.lean
@[simp, norm_cast] lemma cast_le : (p : K) ≤ q ↔ p ≤ q
-- Mathlib/Data/Matrix/ColumnRowPartitioned.lean
@[simp]
lemma fromRows_mulVec (A₁ : Matrix m₁ n R) (A₂ : Matrix m₂ n R) (v : n → R) :
    fromRows A₁ A₂ *ᵥ v = Sum.elim (A₁ *ᵥ v) (A₂ *ᵥ v)
-- Mathlib/Order/Filter/Germ/Basic.lean
@[simp]
theorem intCast_def [IntCast M] (n : ℤ) : ((fun _ ↦ n : α → M) : Germ l M) = n
-- Mathlib/Analysis/Normed/Lp/WithLp.lean
@[simp]
theorem equiv_add : WithLp.equiv p V (x + y) = WithLp.equiv p V x + WithLp.equiv p V y
-- Mathlib/CategoryTheory/Localization/Bousfield.lean
lemma W_adj_unit_app (X : D) : W (· ∈ Set.range F.obj) (adj.unit.app X)
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
lemma cases (α : W.RightFraction X Y) :
    ∃ (X' : C) (s : X' ⟶ X) (hs : W s) (f : X' ⟶ Y) , α = RightFraction.mk s hs f
-- Mathlib/Data/Rel.lean
@[simp]
theorem image_id (s : Set α) : image (@Eq α) s = s
-- Mathlib/Analysis/NormedSpace/ContinuousAffineMap.lean
theorem norm_comp_le (g : W₂ →ᴬ[𝕜] V) : ‖f.comp g‖ ≤ ‖f‖ * ‖g‖ + ‖f 0‖
-- Mathlib/NumberTheory/Primorial.lean
theorem primorial_add_le {m n : ℕ} (h : n ≤ m) : (m + n)# ≤ m# * choose (m + n) m
-- Mathlib/Data/Seq/WSeq.lean
@[simp]
theorem liftRel_nil (R : α → β → Prop) : LiftRel R nil nil
-- Mathlib/Order/UpperLower/Basic.lean
lemma IsLowerSet.lowerBounds_subset (hs : IsLowerSet s) : s.Nonempty → lowerBounds s ⊆ s
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
protected theorem IsPath.of_map {f : G →g G'} (hp : (p.map f).IsPath) : p.IsPath
-- Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean
@[simp 1100]
theorem wideEqualizer.trident_π_app_zero :
    (wideEqualizer.trident f).π.app zero = wideEqualizer.ι f
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive]
theorem reduce.not {p : Prop} :
    ∀ {L₁ L₂ L₃ : List (α × Bool)} {x b}, reduce L₁ = L₂ ++ (x, b) :: (x, !b) :: L₃ → p
-- Mathlib/Algebra/Homology/HomotopyCofiber.lean
/-- The right inclusion `G ⟶ homotopyCofiber φ`. -/
@[simps!]
noncomputable def inr : G ⟶ homotopyCofiber φ
-- Mathlib/Topology/Order/LowerUpperTopology.lean
/-- Every set open in the upper topology is a upper set. -/
theorem isUpperSet_of_isOpen (h : IsOpen s) : IsUpperSet s
-- Mathlib/Algebra/Order/Interval/Set/Instances.lean
/-- like `coe_le_one`, but with the inequality in `Ioc (0:α) 1`. -/
theorem le_one {t : Ioc (0 : α) 1} : t ≤ 1
-- Mathlib/Data/Complex/Exponential.lean
@[simp]
theorem exp_eq_one_iff : exp x = 1 ↔ x = 0
-- Mathlib/Data/Multiset/Nodup.lean
theorem Nodup.not_mem (h : Nodup (a ::ₘ s)) : a ∉ s
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem lsub_lt_ord_lift_of_isRegular {ι} {f : ι → Ordinal} {c} (hc : IsRegular c)
    (hι : Cardinal.lift.{v, u} #ι < c) : (∀ i, f i < c.ord) → Ordinal.lsub.{u, v} f < c.ord
-- Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean
@[to_additive]
theorem le_mul_of_le_right : a ≤ c → a ≤ b * c
-- Mathlib/CategoryTheory/Monoidal/Functor.lean
@[reassoc (attr := simp)]
theorem OplaxMonoidalFunctor.δ_natural (F : OplaxMonoidalFunctor C D) {X Y X' Y' : C}
    (f : X ⟶ Y) (g : X' ⟶ Y') :
      F.δ X X' ≫ (F.map f ⊗ F.map g) = F.map (f ⊗ g) ≫ F.δ Y Y'
-- Mathlib/Algebra/Associated/Basic.lean
@[simp]
theorem quot_out [Monoid α] (a : Associates α) : Associates.mk (Quot.out a) = a
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
theorem map_fst_darts {u v : V} (p : G.Walk u v) : p.darts.map (·.fst) = p.support.dropLast
-- Mathlib/CategoryTheory/Generator.lean
theorem isDetecting_op_iff (𝒢 : Set C) : IsDetecting 𝒢.op ↔ IsCodetecting 𝒢
-- Mathlib/Analysis/Normed/Module/FiniteDimension.lean
/-- A locally compact normed vector space is proper. -/
lemma ProperSpace.of_locallyCompactSpace (𝕜 : Type*) [NontriviallyNormedField 𝕜]
    {E : Type*} [SeminormedAddCommGroup E] [NormedSpace 𝕜 E] [LocallyCompactSpace E] :
    ProperSpace E
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
protected theorem Balanced.setBlack : t.Balanced c n → ∃ n', (setBlack t).Balanced black n'
-- Mathlib/Order/Basic.lean
@[to_additive]
lemma ite_lt_one [LT α] (ha : a < 1) (hb : b < 1) : ite p a b < 1
-- Mathlib/CategoryTheory/Bicategory/NaturalTransformation/Oplax.lean
/-- Construct a modification isomorphism between oplax natural transformations
by giving object level isomorphisms, and checking naturality only in the forward direction.
-/
@[simps]
def ModificationIso.ofComponents (app : ∀ a, η.app a ≅ θ.app a)
    (naturality :
      ∀ {a b} (f : a ⟶ b),
        F.map f ◁ (app b).hom ≫ θ.naturality f = η.naturality f ≫ (app a).hom ▷ G.map f) :
    η ≅ θ
-- Mathlib/Data/Sum/Order.lean
@[simp]
theorem not_inl_lt_inr [LT α] [LT β] {a : α} {b : β} : ¬inl b < inr a
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem map_of_not_aemeasurable {f : α → β} {μ : Measure α} (hf : ¬AEMeasurable f μ) :
    μ.map f = 0
-- Mathlib/Geometry/Euclidean/PerpBisector.lean
@[simp] theorem perpBisector_self (p : P) : perpBisector p p = ⊤
-- Mathlib/Algebra/Order/Field/Power.lean
@[gcongr]
theorem zpow_le_of_le (ha : 1 ≤ a) (h : m ≤ n) : a ^ m ≤ a ^ n
-- Mathlib/LinearAlgebra/Span.lean
theorem comap_map_eq_self {f : F} {p : Submodule R M} (h : LinearMap.ker f ≤ p) :
    comap f (map f p) = p
-- Mathlib/Algebra/Polynomial/Div.lean
theorem degree_modByMonic_le (p : R[X]) {q : R[X]} (hq : Monic q) : degree (p %ₘ q) ≤ degree q
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
theorem hasLineDerivWithinAt_zero : HasLineDerivWithinAt 𝕜 f 0 s x 0
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive]
theorem le_iff_forall_one_lt_lt_mul : a ≤ b ↔ ∀ ε, 1 < ε → a < b * ε
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem image_const_sub_Ici : (fun x => a - x) '' Ici b = Iic (a - b)
-- Mathlib/NumberTheory/ModularForms/SlashInvariantForms.lean
@[simp, norm_cast]
theorem coe_natCast (n : ℕ) : ⇑(n : SlashInvariantForm Γ 0) = n
-- Mathlib/Data/Finset/Slice.lean
theorem sized_iUnion₂ {f : ∀ i, κ i → Set (Finset α)} :
    (⋃ (i) (j), f i j).Sized r ↔ ∀ i j, (f i j).Sized r
-- Mathlib/Data/Sum/Interval.lean
theorem Icc_inr_inr : Icc (inr b₁ : α ⊕ β) (inr b₂) = (Icc b₁ b₂).map Embedding.inr
-- Mathlib/LinearAlgebra/FreeModule/PID.lean
/-- If `S` a finite-dimensional ring extension of a PID `R` which is free as an `R`-module,
then any nonzero `S`-ideal `I` is free as an `R`-submodule of `S`, and we can
find a basis for `S` and `I` such that the inclusion map is a square diagonal
matrix.
-/
@[simp]
theorem Ideal.selfBasis_def (b : Basis ι R S) (I : Ideal S) (hI : I ≠ ⊥) :
    ∀ i, (Ideal.selfBasis b I hI i : S) = Ideal.smithCoeffs b I hI i • Ideal.ringBasis b I hI i
-- Mathlib/Probability/Kernel/CondDistrib.lean
theorem _root_.MeasureTheory.AEStronglyMeasurable.ae_integrable_condDistrib_map_iff
    (hY : AEMeasurable Y μ) (hf : AEStronglyMeasurable f (μ.map fun a => (X a, Y a))) :
    (∀ᵐ a ∂μ.map X, Integrable (fun ω => f (a, ω)) (condDistrib Y X μ a)) ∧
      Integrable (fun a => ∫ ω, ‖f (a, ω)‖ ∂condDistrib Y X μ a) (μ.map X) ↔
    Integrable f (μ.map fun a => (X a, Y a))
-- Mathlib/Topology/UniformSpace/Completion.lean
@[elab_as_elim]
theorem induction_on₃ {p : Completion α → Completion β → Completion γ → Prop} (a : Completion α)
    (b : Completion β) (c : Completion γ)
    (hp : IsClosed { x : Completion α × Completion β × Completion γ | p x.1 x.2.1 x.2.2 })
    (ih : ∀ (a : α) (b : β) (c : γ), p a b c) : p a b c
-- Mathlib/Topology/GDelta.lean
/-- The union of finitely many Gδ sets is a Gδ set, bounded indexed union version. -/
theorem IsGδ.iUnion [Finite ι'] {f : ι' → Set X} (h : ∀ i, IsGδ (f i)) : IsGδ (⋃ i, f i)
-- Mathlib/Topology/Basic.lean
@[simp]
theorem Finset.interior_iInter {ι : Type*} (s : Finset ι) (f : ι → Set X) :
    interior (⋂ i ∈ s, f i) = ⋂ i ∈ s, interior (f i)
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem filter_mono_ae (h : f ⊓ (ae μ) ≤ g) (hg : μ.FiniteAtFilter g) : μ.FiniteAtFilter f
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem sub_lt_left_of_lt_add {n k m : Nat} (H : n ≤ k) (h : k < n + m) : k - n < m
-- Mathlib/Order/ModularLattice.lean
theorem inf_lt_inf_of_lt_of_sup_le_sup (hxy : x < y) (hinf : y ⊔ z ≤ x ⊔ z) : x ⊓ z < y ⊓ z
-- Mathlib/Analysis/Calculus/Darboux.lean
/-- **Darboux's theorem**: if `a ≤ b` and `f' a ≤ m ≤ f' b`, then `f' c = m` for some
`c ∈ [a, b]`. -/
theorem exists_hasDerivWithinAt_eq_of_ge_of_le (hab : a ≤ b)
    (hf : ∀ x ∈ Icc a b, HasDerivWithinAt f (f' x) (Icc a b) x) {m : ℝ} (hma : f' a ≤ m)
    (hmb : m ≤ f' b) : m ∈ f' '' Icc a b
-- Mathlib/RingTheory/NormTrace.lean
lemma Algebra.norm_one_add_smul {A B} [CommRing A] [CommRing B] [Algebra A B]
    [Module.Free A B] [Module.Finite A B] (a : A) (x : B) :
    ∃ r : A, Algebra.norm A (1 + a • x) = 1 + Algebra.trace A B x * a + r * a ^ 2
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- The associator isomorphism can be passed through a map by swapping the order. -/
@[reassoc]
theorem biprod.associator_inv_natural {U V W X Y Z : C} (f : U ⟶ X) (g : V ⟶ Y) (h : W ⟶ Z) :
    biprod.map f (biprod.map g h) ≫ (biprod.associator _ _ _).inv
      = (biprod.associator _ _ _).inv ≫ biprod.map (biprod.map f g) h
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma mono_f (s : S.Splitting) : Mono S.f
-- Mathlib/RingTheory/IntegralDomain.lean
theorem div_eq_quo_add_rem_div (f : R[X]) {g : R[X]} (hg : g.Monic) :
    ∃ q r : R[X], r.degree < g.degree ∧
      (algebraMap R[X] K f) / (algebraMap R[X] K g) =
        algebraMap R[X] K q + (algebraMap R[X] K r) / (algebraMap R[X] K g)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigO.const_smul_self (c' : R) : (fun x => c' • f' x) =O[l] f'
-- Mathlib/Order/Interval/Set/OrderIso.lean
@[simp]
theorem preimage_Iio (e : α ≃o β) (b : β) : e ⁻¹' Iio b = Iio (e.symm b)
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem rTensor_smul_action (r : R) :
    (DistribMulAction.toLinearMap R N r).rTensor M =
      DistribMulAction.toLinearMap R (N ⊗[R] M) r
-- Mathlib/Algebra/ContinuedFractions/Translations.lean
theorem nth_cont_eq_succ_nth_contAux : g.conts n = g.contsAux (n + 1)
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
@[simp]
theorem coe_aeval_eq_eval (r : R) : (aeval r : R[X] → R) = eval r
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
theorem Memℒp.eLpNorm_indicator_norm_ge_le (hf : Memℒp f p μ) (hmeas : StronglyMeasurable f) {ε : ℝ}
    (hε : 0 < ε) : ∃ M : ℝ, eLpNorm ({ x | M ≤ ‖f x‖₊ }.indicator f) p μ ≤ ENNReal.ofReal ε
-- Mathlib/Order/Interval/Set/ProjIcc.lean
@[simp]
theorem IccExtend_right (f : Icc a b → β) : IccExtend h f b = f ⟨b, right_mem_Icc.2 h⟩
-- Mathlib/Algebra/Lie/Abelian.lean
/-- A Lie (ring) module is trivial iff all brackets vanish. -/
class LieModule.IsTrivial (L : Type v) (M : Type w) [Bracket L M] [Zero M] : Prop where
  trivial : ∀ (x : L) (m : M), ⁅x, m⁆ = 0
-- Mathlib/Topology/Algebra/InfiniteSum/Order.lean
@[to_additive]
theorem le_tprod' (hf : Multipliable f) (i : ι) : f i ≤ ∏' i, f i
-- Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean
protected lemma norm (hf : GrowsPolynomially f) : GrowsPolynomially (fun x => ‖f x‖)
-- Mathlib/FieldTheory/IsPerfectClosure.lean
theorem lift_apply (x : L) (n : ℕ) (y : K) (h : i y = x ^ p ^ n) :
    lift i j p x = (iterateFrobeniusEquiv M p n).symm (j y)
-- Mathlib/Data/Finset/Card.lean
theorem card_sdiff (h : s ⊆ t) : card (t \ s) = t.card - s.card
-- Mathlib/Topology/Order/DenselyOrdered.lean
theorem comap_coe_Iio_nhdsWithin_Iio (a : α) : comap ((↑) : Iio a → α) (𝓝[<] a) = atTop
-- Mathlib/GroupTheory/Nilpotent.lean
theorem lowerCentralSeries_map_subtype_le (H : Subgroup G) (n : ℕ) :
    (lowerCentralSeries H n).map H.subtype ≤ lowerCentralSeries G n
-- .lake/packages/batteries/Batteries/Classes/Order.lean
theorem cmp_congr_left' (xy : cmp x y = .eq) : cmp x = cmp y
-- Mathlib/GroupTheory/GroupAction/Group.lean
/-- Each element of the group defines an additive monoid isomorphism.

This is a stronger version of `MulAction.toPerm`. -/
@[simps (config := { simpRhs := true })]
def DistribMulAction.toAddEquiv (x : α) : β ≃+ β
-- Mathlib/Order/WellFoundedSet.lean
protected theorem induction (hs : s.WellFoundedOn r) (hx : x ∈ s) {P : α → Prop}
    (hP : ∀ y ∈ s, (∀ z ∈ s, r z y → P z) → P y) : P x
-- Mathlib/Analysis/Calculus/InverseFunctionTheorem/ApproximatesLinearOn.lean
protected theorem continuous (hf : ApproximatesLinearOn f f' s c) : Continuous (s.restrict f)
-- Mathlib/LinearAlgebra/LinearPMap.lean
theorem exists_of_le {T S : E →ₗ.[R] F} (h : T ≤ S) (x : T.domain) :
    ∃ y : S.domain, (x : E) = y ∧ T x = S y
-- Mathlib/Computability/Primrec.lean
theorem vector_get {n} : Primrec₂ (@Vector.get α n)
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem contDiffOn_of_continuousOn_differentiableOn
    (Hcont : ∀ m : ℕ, (m : ℕ∞) ≤ n → ContinuousOn (fun x => iteratedFDerivWithin 𝕜 m f s x) s)
    (Hdiff : ∀ m : ℕ, (m : ℕ∞) < n →
      DifferentiableOn 𝕜 (fun x => iteratedFDerivWithin 𝕜 m f s x) s) :
    ContDiffOn 𝕜 n f s
-- Mathlib/Data/NNReal/Basic.lean
@[simp]
lemma toNNReal_eq_ofNat {r : ℝ} {n : ℕ} [n.AtLeastTwo] :
    r.toNNReal = no_index (OfNat.ofNat n) ↔ r = OfNat.ofNat n
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem leftInverse_splittingOfFunOnFintypeSurjective [Finite α] (f : M →ₗ[R] α → R)
    (s : Surjective f) : LeftInverse f (splittingOfFunOnFintypeSurjective f s)
-- Mathlib/Order/IsWellOrderLimitElement.lean
lemma IsWellOrderLimitElement.neq_bot [OrderBot α] : a ≠ ⊥
-- Mathlib/Algebra/Polynomial/Bivariate.lean
/-- If the evaluation (`evalEval`) of a bivariate polynomial `p : R[X][Y]` at a point (x,y)
is zero, then `Polynomial.evalEval x y` factors through `AdjoinRoot.evalEval`, a ring homomorphism
from `AdjoinRoot p` to `R`. -/
@[simps!] def evalEval : AdjoinRoot p →+* R
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
@[simp]
lemma mapDomainAlgHom_id (k A) [CommSemiring k] [Semiring A] [Algebra k A] :
    mapDomainAlgHom k A (MonoidHom.id G) = AlgHom.id k (MonoidAlgebra A G)
-- Mathlib/FieldTheory/ChevalleyWarning.lean
/-- The **Chevalley–Warning theorem**, finitary version.
Let `(f i)` be a finite family of multivariate polynomials
in finitely many variables (`X s`, `s : σ`) over a finite field of characteristic `p`.
Assume that the sum of the total degrees of the `f i` is less than the cardinality of `σ`.
Then the number of common solutions of the `f i` is divisible by `p`. -/
theorem char_dvd_card_solutions_of_sum_lt {s : Finset ι} {f : ι → MvPolynomial σ K}
    (h : (∑ i ∈ s, (f i).totalDegree) < Fintype.card σ) :
    p ∣ Fintype.card { x : σ → K // ∀ i ∈ s, eval x (f i) = 0 }
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem exists_iff_exists_finsupp (P : R[X] → Prop) :
    (∃ p, P p) ↔ ∃ q : R[ℕ], P ⟨q⟩
-- Mathlib/Data/Set/Finite.lean
@[simp]
theorem List.finite_toSet (l : List α) : { x | x ∈ l }.Finite