ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/ContinuousFunction/CompactlySupported.lean
@[simp]
theorem coe_comp_to_continuous_fun (f : C_c(γ, δ)) (g : β →co γ) : ((f.comp g) : β → δ) = f ∘ g
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
theorem monotone_arcsin : Monotone arcsin
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive (attr := simp)]
theorem mul_div_cancel_right (a b : G) : a * b / b = a
-- Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean
lemma truncatedSup_of_mem (h : a ∈ lowerClosure s) :
    truncatedSup s a = (s.filter fun b ↦ a ≤ b).sup' (sup_aux h) id
-- Mathlib/MeasureTheory/Measure/Haar/Quotient.lean
/-- Given a quotient space `G ⧸ Γ` where `Γ` is `Countable`, and the restriction,
  `μ_𝓕`, of a right-invariant measure `μ` on `G` to a fundamental domain `𝓕`, a set
  in the quotient which has `μ_𝓕`-measure zero, also has measure zero under the
  folding of `μ` under the quotient. Note that, if `Γ` is infinite, then the folded map
  will take the value `∞` on any open set in the quotient! -/
@[to_additive "Given an additive quotient space `G ⧸ Γ` where `Γ` is `Countable`, and the
  restriction, `μ_𝓕`, of a right-invariant measure `μ` on `G` to a fundamental domain `𝓕`, a set
  in the quotient which has `μ_𝓕`-measure zero, also has measure zero under the
  folding of `μ` under the quotient. Note that, if `Γ` is infinite, then the folded map
  will take the value `∞` on any open set in the quotient!"]
lemma _root_.MeasureTheory.IsFundamentalDomain.absolutelyContinuous_map
    [μ.IsMulRightInvariant] :
    map (QuotientGroup.mk : G → G ⧸ Γ) μ ≪ map (QuotientGroup.mk : G → G ⧸ Γ) (μ.restrict 𝓕)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/ComplexDeriv.lean
theorem tendsto_abs_tan_of_cos_eq_zero {x : ℂ} (hx : cos x = 0) :
    Tendsto (fun x => abs (tan x)) (𝓝[≠] x) atTop
-- Mathlib/GroupTheory/CommutingProbability.lean
theorem commProb_def' : commProb G = Nat.card (ConjClasses G) / Nat.card G
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
/-- An isomorphism of short complexes `S₁ ≅ S₂` induces an isomorphism on the `H` fields
of left homology data of `S₁` and `S₂`. -/
@[simps]
def leftHomologyMapIso' (e : S₁ ≅ S₂) (h₁ : S₁.LeftHomologyData)
    (h₂ : S₂.LeftHomologyData) : h₁.H ≅ h₂.H
-- Mathlib/Order/Bounded.lean
theorem unbounded_ge_iff_unbounded_inter_ge [LinearOrder α] (a : α) :
    Unbounded (· ≥ ·) (s ∩ { b | b ≤ a }) ↔ Unbounded (· ≥ ·) s
-- Mathlib/LinearAlgebra/AffineSpace/Slope.lean
@[simp]
theorem slope_sub_smul (f : k → E) {a b : k} (h : a ≠ b) :
    slope (fun x => (x - a) • f x) a b = f b
-- Mathlib/CategoryTheory/LiftingProperties/Basic.lean
theorem iff_unop {A B X Y : Cᵒᵖ} (i : A ⟶ B) (p : X ⟶ Y) :
    HasLiftingProperty i p ↔ HasLiftingProperty p.unop i.unop
-- Mathlib/Order/Filter/CardinalInter.lean
/-- `cardinalGenerate g hc` is the greatest `cardinalInterFilter c` containing `g`. -/
theorem cardinalGenerate_isGreatest (hc : 2 < c) :
    IsGreatest { f : Filter α | CardinalInterFilter f c ∧ g ⊆ f.sets } (cardinalGenerate g hc)
-- Mathlib/Algebra/Order/Field/Power.lean
/-- Bernoulli's inequality reformulated to estimate `(n : α)`. -/
theorem Nat.cast_le_pow_sub_div_sub (H : 1 < a) (n : ℕ) : (n : α) ≤ (a ^ n - 1) / (a - 1)
-- Mathlib/LinearAlgebra/AffineSpace/Slope.lean
theorem slope_def_field (f : k → k) (a b : k) : slope f a b = (f b - f a) / (b - a)
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
theorem IsVonNBounded.of_add_left (hst : IsVonNBounded 𝕜 (s + t)) (ht : t.Nonempty) :
    IsVonNBounded 𝕜 s
-- Mathlib/CategoryTheory/Monoidal/OfHasFiniteProducts.lean
@[reassoc] theorem associator_inv_fst_snd (X Y Z : C) :
    (α_ X Y Z).inv ≫ prod.fst ≫ prod.snd = prod.snd ≫ prod.fst
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive (attr := simp)]
theorem lift_eq (x : M) : f.lift hg (f.toMap x) = g x
-- Mathlib/Data/Set/Lattice.lean
theorem iUnion_comp {f : ι → ι₂} (hf : Surjective f) (g : ι₂ → Set α) : ⋃ x, g (f x) = ⋃ y, g y
-- Mathlib/Analysis/Calculus/LocalExtr/Basic.lean
/-- **Fermat's Theorem**: the derivative of a function at a local maximum equals zero. -/
theorem IsLocalMax.deriv_eq_zero (h : IsLocalMax f a) : deriv f a = 0
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma uIcc_comm (a b : α) : [[a, b]] = [[b, a]]
-- Mathlib/Order/Monotone/Basic.lean
/-- If `α` is a nonempty preorder with no maximal elements, then there exists a strictly monotone
function `ℕ → α`. -/
theorem exists_strictMono [Nonempty α] [NoMaxOrder α] : ∃ f : ℕ → α, StrictMono f
-- Mathlib/SetTheory/Game/PGame.lean
theorem fuzzy_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ‖ y₁ → x₂ ‖ y₂
-- Mathlib/Analysis/Fourier/Inversion.lean
/-- **Fourier inversion formula**: If a function `f` on a finite-dimensional real inner product
space is integrable, and its Fourier transform `𝓕 f` is also integrable, then `𝓕 (𝓕⁻ f) = f` at
continuity points of `f`. -/
theorem MeasureTheory.Integrable.fourier_inversion_inv
    (hf : Integrable f) (h'f : Integrable (𝓕 f)) {v : V}
    (hv : ContinuousAt f v) : 𝓕 (𝓕⁻ f) v = f v
-- Mathlib/Order/WithBot.lean
protected theorem «forall» {p : WithBot α → Prop} : (∀ x, p x) ↔ p ⊥ ∧ ∀ x : α, p x
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
@[simp]
theorem embedding_of_isReal_apply {w : InfinitePlace K} (hw : IsReal w) (x : K) :
    ((embedding_of_isReal hw) x : ℂ) = (embedding w) x
-- Mathlib/MeasureTheory/Function/UnifTight.lean
protected theorem neg (hf : UnifTight f p μ) : UnifTight (-f) p μ
-- Mathlib/Topology/UrysohnsLemma.lean
/-- By assumption, for each `c : CU P` there exists an open set `u`
such that `c.C ⊆ u` and `closure u ⊆ c.U`. `c.right` is the pair `(closure u, c.U)`. -/
@[simps U]
def right (c : CU P) : CU P
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
lemma MeasurableEmbedding.prod_mk_left {β γ : Type*} [MeasurableSingletonClass α]
    {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ}
    (x : α) {f : γ → β} (hf : MeasurableEmbedding f) :
    MeasurableEmbedding (fun y ↦ (x, f y))
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem image_div : m '' (s / t) = m '' s / m '' t
-- Mathlib/NumberTheory/Harmonic/ZetaAsymp.lean
/-- Formula for `ζ 1`. Note that mathematically `ζ 1` is undefined, but our construction ascribes
this particular value to it. -/
lemma _root_.riemannZeta_one : riemannZeta 1 = (γ - Complex.log (4 * ↑π)) / 2
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive (attr := simp)]
theorem mk_eq_monoidOf_mk' : mk = (monoidOf S).mk'
-- Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean
@[simp]
theorem changeForm_ι (m : M) : changeForm h (ι (M := M) Q m) = ι (M := M) Q' m
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
/-- The Lebesgue integral is measurable. This shows that the integrand of (the right-hand-side of)
  the symmetric version of Tonelli's theorem is measurable. -/
theorem Measurable.lintegral_prod_left' [SFinite μ] {f : α × β → ℝ≥0∞} (hf : Measurable f) :
    Measurable fun y => ∫⁻ x, f (x, y) ∂μ
-- Mathlib/AlgebraicGeometry/Morphisms/Preimmersion.lean
/-- A morphism of schemes `f : X ⟶ Y` is a preimmersion if the underlying map of
topological spaces is an embedding and the induced morphisms of stalks are all surjective. -/
@[mk_iff]
class IsPreimmersion {X Y : Scheme} (f : X ⟶ Y) : Prop where
  base_embedding : Embedding f.1.base
  surj_on_stalks : ∀ x, Function.Surjective (f.stalkMap x)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem leadingCoeff_mul' (h : leadingCoeff p * leadingCoeff q ≠ 0) :
    leadingCoeff (p * q) = leadingCoeff p * leadingCoeff q
-- Mathlib/Order/Filter/Subsingleton.lean
/-- A filter is a subsingleton iff it is equal to `⊥` or to `pure a` for some `a`. -/
theorem subsingleton_iff_bot_or_pure : l.Subsingleton ↔ l = ⊥ ∨ ∃ a, l = pure a
-- Mathlib/Order/UpperLower/Basic.lean
@[simp, norm_cast]
lemma coe_sdiff (s : LowerSet α) (t : Set α) : s.sdiff t = (s : Set α) \ upperClosure t
-- Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean
theorem rpow_eq_nhds_of_neg {p : ℝ × ℝ} (hp_fst : p.fst < 0) :
    (fun x : ℝ × ℝ => x.1 ^ x.2) =ᶠ[𝓝 p] fun x => exp (log x.1 * x.2) * cos (x.2 * π)
-- Mathlib/Analysis/Convex/Jensen.lean
/-- If a function `f` is concave on `s`, then the value it takes at some center of mass of points of
`s` is greater than the value it takes on one of those points. -/
theorem ConcaveOn.exists_le_of_centerMass (h : ConcaveOn 𝕜 s f) (hw₀ : ∀ i ∈ t, 0 ≤ w i)
    (hw₁ : 0 < ∑ i ∈ t, w i) (hp : ∀ i ∈ t, p i ∈ s) : ∃ i ∈ t, f (p i) ≤ f (t.centerMass w p)
-- Mathlib/Algebra/GeomSum.lean
/-- Value of a geometric sum over the naturals. Note: see `geom_sum_mul_add` for a formulation
that avoids division and subtraction. -/
lemma Nat.geomSum_eq (hm : 2 ≤ m) (n : ℕ) :
    ∑ k ∈ range n, m ^ k = (m ^ n - 1) / (m - 1)
-- Mathlib/Data/Nat/ModEq.lean
/-- Cancel left multiplication on both sides of the `≡` and in the modulus.

For cancelling left multiplication in the modulus, see `Nat.ModEq.of_mul_left`. -/
protected theorem mul_left_cancel' {a b c m : ℕ} (hc : c ≠ 0) :
    c * a ≡ c * b [MOD c * m] → a ≡ b [MOD m]
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma add_smul_of_equiv {P Q : Fin 3 → R} (h : P ≈ Q) {u v : R} (hu : IsUnit u) (hv : IsUnit v) :
    W'.add (u • P) (v • Q) = u ^ 4 • W'.add P Q
-- Mathlib/Analysis/Convex/Topology.lean
theorem Convex.openSegment_interior_self_subset_interior {s : Set E} (hs : Convex 𝕜 s) {x y : E}
    (hx : x ∈ interior s) (hy : y ∈ s) : openSegment 𝕜 x y ⊆ interior s
-- Mathlib/Topology/UniformSpace/Separation.lean
theorem map_mk {f : α → β} (h : UniformContinuous f) (a : α) : map f (mk a) = mk (f a)
-- Mathlib/Order/CompleteLattice.lean
theorem le_iInf (h : ∀ i, a ≤ f i) : a ≤ iInf f
-- Mathlib/RingTheory/Polynomial/IntegralNormalization.lean
theorem integralNormalization_coeff_ne_natDegree {f : R[X]} {i : ℕ} (hi : i ≠ natDegree f) :
    coeff (integralNormalization f) i = coeff f i * f.leadingCoeff ^ (f.natDegree - 1 - i)
-- Mathlib/CategoryTheory/Limits/VanKampen.lean
theorem NatTrans.equifibered_of_isIso {F G : J ⥤ C} (α : F ⟶ G) [IsIso α] : Equifibered α
-- Mathlib/CategoryTheory/IsConnected.lean
theorem Zigzag.of_inv_hom {j₁ j₂ j₃ : J} (f₂₁ : j₂ ⟶ j₁) (f₂₃ : j₂ ⟶ j₃) : Zigzag j₁ j₃
-- Mathlib/Analysis/Calculus/InverseFunctionTheorem/ApproximatesLinearOn.lean
protected theorem lipschitz (hf : ApproximatesLinearOn f f' s c) :
    LipschitzWith (‖f'‖₊ + c) (s.restrict f)
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive sub_le_sub_iff]
theorem div_le_div_iff' : a / b ≤ c / d ↔ a * d ≤ c * b
-- Mathlib/Data/Num/Lemmas.lean
@[norm_cast]
theorem le_to_nat {m n : Num} : (m : ℕ) ≤ n ↔ m ≤ n
-- Mathlib/Analysis/Fourier/AddCircle.lean
/-- Express Fourier coefficients of `f` on an interval in terms of those of its derivative. -/
theorem fourierCoeffOn_of_hasDerivAt_Ioo {a b : ℝ} (hab : a < b) {f f' : ℝ → ℂ}
    {n : ℤ} (hn : n ≠ 0)
    (hf : ContinuousOn f [[a, b]])
    (hff' : ∀ x, x ∈ Ioo (min a b) (max a b) → HasDerivAt f (f' x) x)
    (hf' : IntervalIntegrable f' volume a b) :
    fourierCoeffOn hab f n = 1 / (-2 * π * I * n) *
      (fourier (-n) (a : AddCircle (b - a)) * (f b - f a) - (b - a) * fourierCoeffOn hab f' n)
-- Mathlib/Deprecated/Subgroup.lean
@[to_additive]
theorem injective_iff_trivial_ker {f : G → H} (hf : IsGroupHom f) :
    Function.Injective f ↔ ker f = trivial G
-- Mathlib/Order/Bounded.lean
theorem bounded_gt_Ico [Preorder α] [NoMinOrder α] (a b : α) : Bounded (· > ·) (Ico a b)
-- Mathlib/CategoryTheory/GradedObject/Unitor.lean
lemma mapBifunctorLeftUnitor_inv_apply (j : J) :
    (mapBifunctorLeftUnitor F X e p hp Y).inv j =
      e.inv.app (Y j) ≫ (F.map (singleObjApplyIso (0 : I) X).inv).app (Y j) ≫
      ιMapBifunctorMapObj F p ((single₀ I).obj X) Y 0 j j (hp j)
-- Mathlib/Algebra/Star/Unitary.lean
/-- The group homomorphism between unitary subgroups of star monoids induced by a star
homomorphism -/
@[simps]
def map : unitary R →* unitary S
-- Mathlib/Analysis/Asymptotics/Theta.lean
theorem IsTheta.isBigO_congr_left (h : f' =Θ[l] g') : f' =O[l] k ↔ g' =O[l] k
-- Mathlib/RingTheory/Kaehler/Basic.lean
/-- `Ω[S⁄R]` is isomorphic to `S` copies of `S` with kernel `KaehlerDifferential.kerTotal`. -/
@[simps!]
noncomputable def KaehlerDifferential.quotKerTotalEquiv :
    ((S →₀ S) ⧸ KaehlerDifferential.kerTotal R S) ≃ₗ[S] Ω[S⁄R]
-- Mathlib/Data/Multiset/Powerset.lean
@[simp]
theorem powerset_cons (a : α) (s) : powerset (a ::ₘ s) = powerset s + map (cons a) (powerset s)
-- Mathlib/Algebra/Periodic.lean
theorem Antiperiodic.div [Add α] [DivisionMonoid β] [HasDistribNeg β] (hf : Antiperiodic f c)
    (hg : Antiperiodic g c) : Periodic (f / g) c
-- Mathlib/Algebra/CharZero/Quotient.lean
theorem zmultiples_nsmul_eq_nsmul_iff {ψ θ : R ⧸ AddSubgroup.zmultiples p} {n : ℕ} (hz : n ≠ 0) :
    n • ψ = n • θ ↔ ∃ k : Fin n, ψ = θ + (k : ℕ) • (p / n : R)
-- Mathlib/CategoryTheory/Sites/Equivalence.lean
/-- The counit iso in the equivalence of sheaf categories. -/
@[simps!]
def sheafCongr.counitIso : inverse J K e A ⋙ functor J K e A ≅ 𝟭 (Sheaf _ A)
-- Mathlib/Data/Quot.lean
protected theorem eq (a b : Trunc α) : a = b
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive]
theorem embedProduct_injective (α : Type*) [Monoid α] : Function.Injective (embedProduct α)
-- Mathlib/Topology/FiberBundle/Trivialization.lean
/-- In the domain of a bundle trivialization, the projection is continuous-/
theorem continuousAt_proj (ex : x ∈ e.source) : ContinuousAt proj x
-- Mathlib/Topology/ContinuousFunction/Basic.lean
@[simp]
theorem comp_assoc (f : C(γ, δ)) (g : C(β, γ)) (h : C(α, β)) :
    (f.comp g).comp h = f.comp (g.comp h)
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem coe_ofStrictMono {α β} [LinearOrder α] [Preorder β] {f : α → β} (h : StrictMono f) :
    ⇑(ofStrictMono f h) = f
-- Mathlib/Order/UpperLower/Basic.lean
theorem prod_le_prod_iff : s₁ ×ˢ t₁ ≤ s₂ ×ˢ t₂ ↔ s₁ ≤ s₂ ∧ t₁ ≤ t₂ ∨ s₁ = ⊥ ∨ t₁ = ⊥
-- Mathlib/GroupTheory/Solvable.lean
theorem solvable_of_surjective (hf : Function.Surjective f) [IsSolvable G] : IsSolvable G'
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- `affineCombination` gives equal results for two families of weights and two families of
points that are equal on `s`. -/
theorem affineCombination_congr {w₁ w₂ : ι → k} (hw : ∀ i ∈ s, w₁ i = w₂ i) {p₁ p₂ : ι → P}
    (hp : ∀ i ∈ s, p₁ i = p₂ i) : s.affineCombination k p₁ w₁ = s.affineCombination k p₂ w₂
-- Mathlib/Algebra/Ring/BooleanRing.lean
theorem sup_assoc (a b c : α) : a ⊔ b ⊔ c = a ⊔ (b ⊔ c)
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
lemma map_incl_le {N' : LieSubmodule R L N} :
    N'.map N.incl ≤ N
-- Mathlib/Algebra/BigOperators/Ring/Multiset.lean
theorem multiset_sum_right (a : α) (h : ∀ b ∈ s, Commute a b) : Commute a s.sum
-- Mathlib/Topology/Connected/PathConnected.lean
@[simp]
theorem extend_extends' {a b : X} (γ : Path a b) (t : (Icc 0 1 : Set ℝ)) : γ.extend t = γ t
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[aesop safe apply (rule_sets := [SetLike])]
theorem natCast_mem [AddSubmonoidWithOneClass S R] (n : ℕ) : (n : R) ∈ s
-- Mathlib/Data/Rat/Floor.lean
@[simp, norm_cast]
theorem ceil_cast (x : ℚ) : ⌈(x : α)⌉ = ⌈x⌉
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[continuity]
protected theorem continuous : Continuous f
-- Mathlib/Topology/Order.lean
theorem generateFrom_surjective : Surjective (generateFrom : Set (Set α) → TopologicalSpace α)
-- Mathlib/CategoryTheory/Monad/Limits.lean
/-- If `C` has colimits of shape `J` then any coreflective subcategory has colimits of shape `J`. -/
theorem hasColimitsOfShape_of_coreflective [HasColimitsOfShape J C] (R : D ⥤ C) [Coreflective R] :
    HasColimitsOfShape J D
-- Mathlib/Analysis/SpecialFunctions/Stirling.lean
/-- The sequence `log_stirlingSeq` is bounded below for `n ≥ 1`. -/
theorem log_stirlingSeq_bounded_by_constant : ∃ c, ∀ n : ℕ, c ≤ log (stirlingSeq (n + 1))
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
lemma mul_div_cancel_of_imp' (h : b = 0 → a = 0) : b * (a / b) = a
-- Mathlib/CategoryTheory/Preadditive/Injective.lean
/-- An equivalence of categories transfers enough injectives. -/
lemma EnoughInjectives.of_equivalence {C : Type u₁} {D : Type u₂}
    [Category.{v₁} C] [Category.{v₂} D]
    (e : C ⥤ D) [e.IsEquivalence] [EnoughInjectives D] : EnoughInjectives C
-- Mathlib/FieldTheory/PurelyInseparable.lean
theorem separableClosure_inf_perfectClosure : separableClosure F E ⊓ perfectClosure F E = ⊥
-- Mathlib/Algebra/Homology/SingleHomology.lean
@[reassoc (attr := simp)]
lemma singleObjHomologySelfIso_hom_naturality :
    homologyMap ((single C c j).map f) j ≫ (singleObjHomologySelfIso c j B).hom =
      (singleObjHomologySelfIso c j A).hom ≫ f
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Div.lean
theorem div_mul_le_self : ∀ (m n : Nat), m / n * n ≤ m
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
theorem mem_oneCocycles_iff (f : G → A) :
    f ∈ oneCocycles A ↔ ∀ g h : G, f (g * h) = A.ρ g (f h) + f g
-- Mathlib/RingTheory/TensorProduct/Basic.lean
theorem productMap_eq_comp_map : productMap f g = (lmul' R).comp (TensorProduct.map f g)
-- Mathlib/Topology/Basic.lean
theorem IsClosed.interior_union_left (_ : IsClosed s) :
    interior (s ∪ t) ⊆ s ∪ interior t
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atBot_atBot [Nonempty α] [SemilatticeInf α] [Preorder β] {f : α → β} :
    Tendsto f atBot atBot ↔ ∀ b : β, ∃ i : α, ∀ a : α, a ≤ i → f a ≤ b
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem subset_univ (s : Set α) : s ⊆ univ
-- Mathlib/Analysis/Normed/Group/Hom.lean
theorem mem_ker (v : V₁) : v ∈ f.ker ↔ f v = 0
-- Mathlib/Topology/Constructions.lean
theorem isOpen_pi_iff' [Finite ι] {s : Set (∀ a, π a)} :
    IsOpen s ↔
      ∀ f, f ∈ s → ∃ u : ∀ a, Set (π a), (∀ a, IsOpen (u a) ∧ f a ∈ u a) ∧ univ.pi u ⊆ s
-- Mathlib/CategoryTheory/Monad/Kleisli.lean
/-- The left adjoint of the adjunction which induces the monad `(T, η_ T, μ_ T)`. -/
@[simps]
def toKleisli : C ⥤ Kleisli T
-- Mathlib/Data/List/MinMax.lean
theorem not_lt_maximum_of_mem' (ha : a ∈ l) : ¬maximum l < (a : WithBot α)
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
@[simp]
lemma coeff_preΨ' (n : ℕ) : (W.preΨ' n).coeff ((n ^ 2 - if Even n then 4 else 1) / 2) =
    if Even n then n / 2 else n
-- Mathlib/Order/JordanHolder.lean
theorem lt_last_of_mem_eraseLast {s : CompositionSeries X} {x : X} (h : 0 < s.length)
    (hx : x ∈ s.eraseLast) : x < s.last
-- Mathlib/Topology/Algebra/Group/Basic.lean
lemma Filter.tendsto_sub_const_iff {G : Type*}
    [AddCommGroup G] [TopologicalSpace G] [ContinuousSub G]
    (b : G) {c : G} {f : α → G} {l : Filter α} :
    Tendsto (f · - b) l (𝓝 (c - b)) ↔ Tendsto f l (𝓝 c)
-- Mathlib/CategoryTheory/Limits/ConeCategory.lean
/-- Interpreting the legs of a cone as a structured arrow and then forgetting the arrow again does
    nothing. -/
@[simps!]
def Cone.toStructuredArrowCompProj {F : J ⥤ C} (c : Cone F) :
    c.toStructuredArrow ⋙ StructuredArrow.proj _ _ ≅ 𝟭 J
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem natAbs_eq_iff {a : Int} {n : Nat} : a.natAbs = n ↔ a = n ∨ a = -↑n
-- Mathlib/Data/List/Indexes.lean
theorem findIdx_eq_length {p : α → Bool} {xs : List α} :
    xs.findIdx p = xs.length ↔ ∀ x ∈ xs, ¬p x
-- Mathlib/Topology/UniformSpace/AbstractCompletion.lean
theorem map_unique {f : α → β} {g : hatα → hatβ} (hg : UniformContinuous g)
    (h : ∀ a, ι' (f a) = g (ι a)) : map f = g
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem mem_nonunits_iff {x : K} : x ∈ A.nonunits ↔ A.valuation x < 1
-- Mathlib/LinearAlgebra/RootSystem/Defs.lean
@[simp]
lemma root_reflection_perm (j : ι) :
    P.root (P.reflection_perm i j) = (P.reflection i) (P.root j)
-- Mathlib/Order/Cover.lean
lemma _root_.CovBy.exists_set_insert (h : s ⋖ t) : ∃ a ∉ s, insert a s = t
-- Mathlib/Algebra/Order/Group/Synonym.lean
@[to_additive (attr := simp)]
theorem ofDual_one [One α] : (ofDual 1 : α) = 1
-- Mathlib/FieldTheory/SplittingField/IsSplittingField.lean
theorem splits_iff (f : K[X]) [IsSplittingField K L f] :
    Splits (RingHom.id K) f ↔ (⊤ : Subalgebra K L) = ⊥
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem toRelIsoLT_apply (e : α ≃o β) (x : α) : e.toRelIsoLT x = e x
-- Mathlib/Data/Num/Lemmas.lean
theorem one_add (n : PosNum) : 1 + n = succ n
-- Mathlib/Data/Finset/Basic.lean
theorem erase_union_distrib (s t : Finset α) (a : α) : (s ∪ t).erase a = s.erase a ∪ t.erase a
-- Mathlib/FieldTheory/Separable.lean
theorem not_separable_zero [Nontrivial R] : ¬Separable (0 : R[X])
-- Mathlib/LinearAlgebra/Ray.lean
theorem sameRay_neg_swap : SameRay R (-x) y ↔ SameRay R x (-y)
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[to_additive (attr := fun_prop, measurability)]
theorem AEMeasurable.inv (hf : AEMeasurable f μ) : AEMeasurable (fun x => (f x)⁻¹) μ
-- Mathlib/Data/Multiset/Lattice.lean
@[simp]
theorem sup_ndinsert (a : α) (s : Multiset α) : (ndinsert a s).sup = a ⊔ s.sup
-- Mathlib/Computability/TuringMachine.lean
@[simp]
theorem PointedMap.headI_map {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ')
    (l : List Γ) : (l.map f).headI = f l.headI
-- Mathlib/SetTheory/Surreal/Basic.lean
lemma isOption {x' x} (h : IsOption x' x) (hx : Numeric x) : Numeric x'
-- Mathlib/Order/Monotone/Basic.lean
theorem Monotone.reflect_lt (hf : Monotone f) {a b : α} (h : f a < f b) : a < b
-- Mathlib/Data/Nat/Choose/Central.lean
theorem centralBinom_pos (n : ℕ) : 0 < centralBinom n
-- Mathlib/Computability/Language.lean
@[simp]
theorem not_mem_zero (x : List α) : x ∉ (0 : Language α)
-- Mathlib/Combinatorics/SimpleGraph/Maps.lean
theorem toEmbedding_completeGraph {α β : Type*} (f : α ≃ β) :
    (Iso.completeGraph f).toEmbedding = Embedding.completeGraph f.toEmbedding
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem continuousInv_sInf {ts : Set (TopologicalSpace G)}
    (h : ∀ t ∈ ts, @ContinuousInv G t _) : @ContinuousInv G (sInf ts) _
-- Mathlib/Algebra/Group/Submonoid/Basic.lean
@[to_additive]
theorem IsUnit.mem_submonoid_iff {M : Type*} [Monoid M] (a : M) :
    a ∈ IsUnit.submonoid M ↔ IsUnit a
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
theorem mul_le_mul_left {M N P : AddSubmonoid R} (h : M ≤ N) : M * P ≤ N * P
-- Mathlib/RingTheory/Bialgebra/Hom.lean
@[simp]
theorem coe_id : ⇑(BialgHom.id R A) = id
-- Mathlib/Algebra/Order/AbsoluteValue.lean
theorem abv_one' : abv 1 = 1
-- Mathlib/Data/SetLike/Basic.lean
theorem ext_iff : p = q ↔ ∀ x, x ∈ p ↔ x ∈ q
-- Mathlib/Topology/MetricSpace/IsometricSMul.lean
@[to_additive]
theorem isometry_mul_right [Mul M] [PseudoEMetricSpace M] [IsometricSMul Mᵐᵒᵖ M] (a : M) :
    Isometry fun x => x * a
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem secondCountable_of_almost_dense_set
    (hs : ∀ ε > 0, ∃ t : Set α, t.Countable ∧ ⋃ x ∈ t, closedBall x ε = univ) :
    SecondCountableTopology α
-- Mathlib/Topology/Algebra/Module/StrongTopology.lean
theorem uniformEmbedding_coeFn [UniformSpace F] [UniformAddGroup F] (𝔖 : Set (Set E)) :
    UniformEmbedding (α := UniformConvergenceCLM σ F 𝔖) (β := E →ᵤ[𝔖] F) DFunLike.coe
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem preimage_Iic {a : α} (ha : 0 ≤ a) : (Nat.cast : ℕ → α) ⁻¹' Set.Iic a = Set.Iic ⌊a⌋₊
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem sum_C_mul_X_pow_eq (p : R[X]) : (p.sum fun n a => C a * X ^ n) = p
-- Mathlib/Analysis/Analytic/CPolynomial.lean
theorem HasFiniteFPowerSeriesOnBall.neg (hf : HasFiniteFPowerSeriesOnBall f pf x n r) :
    HasFiniteFPowerSeriesOnBall (-f) (-pf) x n r
-- Mathlib/Analysis/InnerProductSpace/EuclideanDist.lean
theorem nhds_basis_closedBall {x : E} : (𝓝 x).HasBasis (fun r : ℝ => 0 < r) (closedBall x)
-- Mathlib/NumberTheory/ClassNumber/AdmissibleAbsoluteValue.lean
/-- Any large enough family of vectors in `R^ι` has a pair of elements
whose remainders are close together, pointwise. -/
theorem exists_approx {ι : Type*} [Fintype ι] {ε : ℝ} (hε : 0 < ε) {b : R} (hb : b ≠ 0)
    (h : abv.IsAdmissible) (A : Fin (h.card ε ^ Fintype.card ι).succ → ι → R) :
    ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ k, (abv (A i₁ k % b - A i₀ k % b) : ℝ) < abv b • ε
-- Mathlib/Data/Nat/Defs.lean
protected lemma div_div_self (h : n ∣ m) (hm : m ≠ 0) : m / (m / n) = n
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp] lemma top_ne_natCast (n : ℕ) : (⊤ : WithTop α) ≠ n