ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/Bounds/Basic.lean
theorem BddBelow.bddAbove_image2_of_bddAbove :
    BddBelow s → BddAbove t → BddAbove (Set.image2 f s t)
-- Mathlib/GroupTheory/Coxeter/Basic.lean
/-- If `p : W → Prop` holds for the identity and it is preserved under multiplying on the left
by a simple reflection, then it holds for all elements of `W`. -/
theorem simple_induction_left {p : W → Prop} (w : W) (one : p 1)
    (mul_simple_left : ∀ (w : W) (i : B), p w → p (s i * w)) : p w
-- Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean
/-- The non-negative norm of the tensor product of a scalar linear map and of an element of a normed
space is the product of the non-negative norms. -/
@[simp]
theorem nnnorm_smulRight_apply (c : E →L[𝕜] 𝕜) (f : Fₗ) : ‖smulRight c f‖₊ = ‖c‖₊ * ‖f‖₊
-- Mathlib/Algebra/Group/Commute/Units.lean
@[to_additive (attr := simp)] lemma isUnit_pow_iff (hn : n ≠ 0) : IsUnit (a ^ n) ↔ IsUnit a
-- Mathlib/RingTheory/Kaehler/Basic.lean
theorem Derivation.tensorProductTo_tmul (D : Derivation R S M) (s t : S) :
    D.tensorProductTo (s ⊗ₜ t) = s • D t
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
@[simp]
theorem one_le {I : FractionalIdeal S P} : 1 ≤ I ↔ (1 : P) ∈ I
-- Mathlib/FieldTheory/RatFunc/Basic.lean
@[simp]
theorem num_eq_zero_iff {x : RatFunc K} : num x = 0 ↔ x = 0
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_sub_eq_right_of_degree_lt (h : degree p < degree q) : degree (p - q) = degree q
-- Mathlib/Topology/Algebra/UniformConvergence.lean
@[simp]
lemma UniformFun.toFun_smul {M : Type*} [SMul M β] (c : M) (f : α →ᵤ β) :
    toFun (c • f) = c • toFun f
-- Mathlib/Order/OmegaCompletePartialOrder.lean
theorem bot_continuous : Continuous (⊥ : α →o β)
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
@[simp]
theorem closure_empty : closure (∅ : Set R) = ⊥
-- Mathlib/Algebra/Star/Pointwise.lean
theorem Finite.star [InvolutiveStar α] {s : Set α} (hs : s.Finite) : s⋆.Finite
-- Mathlib/Data/Set/Lattice.lean
theorem biUnion_range_preimage_singleton (f : α → β) : ⋃ y ∈ range f, f ⁻¹' {y} = univ
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem getElem?_nil {n : Nat} : ([] : List α)[n]? = none
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem HasFDerivWithinAt.sinh (hf : HasFDerivWithinAt f f' s x) :
    HasFDerivWithinAt (fun x => Real.sinh (f x)) (Real.cosh (f x) • f') s x
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem ker_isNormal : (ker φ).IsNormal
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem deriv_id_of_nfp_id {f : Ordinal → Ordinal} (h : nfp f = id) : deriv f = id
-- Mathlib/CategoryTheory/GradedObject.lean
@[simp]
theorem eqToHom_proj {I : Type*} {x x' : GradedObject I C} (h : x = x') (i : I) :
    (eqToHom h : x ⟶ x') i = eqToHom (Function.funext_iff.mp h i)
-- Mathlib/Topology/Connected/Basic.lean
/-- A connected space is a nonempty one where there is no non-trivial open partition. -/
class ConnectedSpace (α : Type u) [TopologicalSpace α] extends PreconnectedSpace α : Prop where
  /-- A connected space is nonempty. -/
  toNonempty : Nonempty α
-- Mathlib/CategoryTheory/Functor/EpiMono.lean
/-- A functor preserves monomorphisms if it maps monomorphisms to monomorphisms. -/
class PreservesMonomorphisms (F : C ⥤ D) : Prop where
  /-- A functor preserves monomorphisms if it maps monomorphisms to monomorphisms. -/
  preserves : ∀ {X Y : C} (f : X ⟶ Y) [Mono f], Mono (F.map f)
-- Mathlib/NumberTheory/Pell.lean
@[simp]
theorem y_mk (x y : ℤ) (prop : x ^ 2 - d * y ^ 2 = 1) : (mk x y prop).y = y
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sin_int_mul_pi_sub (x : ℝ) (n : ℤ) : sin (n * π - x) = -((-1) ^ n * sin x)
-- Mathlib/Computability/Reduce.lean
@[simp]
protected theorem add_le {d₁ d₂ d₃ : ManyOneDegree} : d₁ + d₂ ≤ d₃ ↔ d₁ ≤ d₃ ∧ d₂ ≤ d₃
-- Mathlib/Algebra/Polynomial/Splits.lean
theorem splits_of_map_degree_eq_one {f : K[X]} (hf : degree (f.map i) = 1) : Splits i f
-- Mathlib/Order/Synonym.lean
@[simp]
theorem toDual_lt_toDual [LT α] {a b : α} : toDual a < toDual b ↔ b < a
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem realize_alls {φ : L.BoundedFormula α n} {v : α → M} :
    φ.alls.Realize v ↔ ∀ xs : Fin n → M, φ.Realize v xs
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
@[simp]
theorem norm_constOfIsEmpty [IsEmpty ι] (x : G) : ‖constOfIsEmpty 𝕜 E x‖ = ‖x‖
-- Mathlib/CategoryTheory/Opposites.lean
@[simp]
theorem unop_inv {X Y : Cᵒᵖ} (f : X ⟶ Y) [IsIso f] : (inv f).unop = inv f.unop
-- Mathlib/Data/Nat/PartENat.lean
@[simp]
theorem zero_lt_top : (0 : PartENat) < ⊤
-- Mathlib/Order/Partition/Equipartition.lean
/-- Given a finset equipartitioned into `k` parts, its elements can be enumerated such that
elements in the same part have congruent indices modulo `k`. -/
theorem IsEquipartition.exists_partPreservingEquiv (hP : P.IsEquipartition) : ∃ f : s ≃ Fin s.card,
    ∀ a b : s, P.part a = P.part b ↔ f a % P.parts.card = f b % P.parts.card
-- Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean
theorem bot_eq_top_iff_finrank_eq_one [Nontrivial E] [Module.Free F E] :
    (⊥ : Subalgebra F E) = ⊤ ↔ finrank F E = 1
-- Mathlib/Data/List/Sort.lean
theorem perm_orderedInsert (a) : ∀ l : List α, orderedInsert r a l ~ a :: l
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
theorem fderivWithin_add_const (hxs : UniqueDiffWithinAt 𝕜 s x) (c : F) :
    fderivWithin 𝕜 (fun y => f y + c) s x = fderivWithin 𝕜 f s x
-- Mathlib/Order/CompleteBooleanAlgebra.lean
theorem inf_iSup_eq (a : α) (f : ι → α) : (a ⊓ ⨆ i, f i) = ⨆ i, a ⊓ f i
-- Mathlib/Data/List/Indexes.lean
theorem mapIdxGo_append : ∀ (f : ℕ → α → β) (l₁ l₂ : List α) (arr : Array β),
    mapIdx.go f (l₁ ++ l₂) arr = mapIdx.go f l₂ (List.toArray (mapIdx.go f l₁ arr))
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
theorem and_comm : ∀ (x y : Bool), (x && y) = (y && x)
-- Mathlib/Data/Finsupp/ToDFinsupp.lean
@[simp]
theorem toFinsupp_sub [AddGroup M] [∀ m : M, Decidable (m ≠ 0)] (f g : Π₀ _ : ι, M) :
    (toFinsupp (f - g) : ι →₀ M) = toFinsupp f - toFinsupp g
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem mod_eq_zero_of_dvd {a b : Ordinal} (H : b ∣ a) : a % b = 0
-- Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean
@[simp]
theorem coeff_iterate_fslope (k n : ℕ) : (fslope^[k] p).coeff n = p.coeff (n + k)
-- Mathlib/GroupTheory/GroupAction/SubMulAction.lean
/-- Orbits in a `SubMulAction` coincide with orbits in the ambient space. -/
theorem val_image_orbit {p : SubMulAction R M} (m : p) :
    Subtype.val '' MulAction.orbit R m = MulAction.orbit R (m : M)
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
/-- If the second of three points is strictly between the other two, the angle at the first point
is zero. -/
theorem _root_.Sbtw.angle₂₁₃_eq_zero {p₁ p₂ p₃ : P} (h : Sbtw ℝ p₁ p₂ p₃) : ∠ p₂ p₁ p₃ = 0
-- Mathlib/Topology/Category/Profinite/Limits.lean
/-- The explicit pullback cone is a limit cone. -/
@[simps! lift]
def pullback.isLimit : Limits.IsLimit (pullback.cone f g)
-- Mathlib/Order/Monotone/Basic.lean
lemma monotone_iff_apply₂ : Monotone f ↔ ∀ i, Monotone (f · i)
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem Subsingleton.einfsep (hs : s.Subsingleton) : s.einfsep = ∞
-- Mathlib/CategoryTheory/Limits/VanKampen.lean
theorem mapPair_equifibered {F F' : Discrete WalkingPair ⥤ C} (α : F ⟶ F') :
    NatTrans.Equifibered α
-- Mathlib/Data/Set/Card.lean
theorem encard_diff_add_encard_of_subset (h : s ⊆ t) : (t \ s).encard + s.encard = t.encard
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem length_toList (s : Multiset α) : s.toList.length = card s
-- Mathlib/Data/Set/NAry.lean
theorem image_image2_antidistrib {g : γ → δ} {f' : β' → α' → δ} {g₁ : β → β'} {g₂ : α → α'}
    (h_antidistrib : ∀ a b, g (f a b) = f' (g₁ b) (g₂ a)) :
    (image2 f s t).image g = image2 f' (t.image g₁) (s.image g₂)
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem LinearIndependent.repr_eq_single (i) (x : span R (range v)) (hx : ↑x = v i) :
    hv.repr x = Finsupp.single i 1
-- Mathlib/Algebra/Lie/Weights/RootSystem.lean
lemma chainTopCoeff_le_chainLength : chainTopCoeff α β ≤ chainLength α β
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] protected theorem add_zero (x : BitVec n) : x + 0#n = x
-- Mathlib/Topology/Compactness/Compact.lean
/-- **Tychonoff's theorem** formulated in terms of filters: `Filter.cocompact` on an indexed product
type `Π d, X d` the `Filter.coprodᵢ` of filters `Filter.cocompact` on `X d`. -/
theorem Filter.coprodᵢ_cocompact {X : ι → Type*} [∀ d, TopologicalSpace (X d)] :
    (Filter.coprodᵢ fun d => Filter.cocompact (X d)) = Filter.cocompact (∀ d, X d)
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem map_lt_add {x y : R} {g : Γ₀} (hx : g < v x) (hy : g < v y) : g < v (x + y)
-- Mathlib/Algebra/RingQuot.lean
theorem add_quot {a b} : (⟨Quot.mk _ a⟩ + ⟨Quot.mk _ b⟩ : RingQuot r) = ⟨Quot.mk _ (a + b)⟩
-- Mathlib/Algebra/Order/Group/Int.lean
theorem sign_mul_abs (a : ℤ) : sign a * |a| = a
-- Mathlib/NumberTheory/Divisors.lean
theorem snd_mem_divisors_of_mem_antidiagonal {x : ℕ × ℕ} (h : x ∈ divisorsAntidiagonal n) :
    x.snd ∈ divisors n
-- Mathlib/AlgebraicTopology/DoldKan/PInfty.lean
/-- Given an object `Y : Karoubi (SimplicialObject C)`, this lemma
computes `PInfty` for the associated object in `SimplicialObject (Karoubi C)`
in terms of `PInfty` for `Y.X : SimplicialObject C` and `Y.p`. -/
theorem karoubi_PInfty_f {Y : Karoubi (SimplicialObject C)} (n : ℕ) :
    ((PInfty : K[(karoubiFunctorCategoryEmbedding _ _).obj Y] ⟶ _).f n).f =
      Y.p.app (op [n]) ≫ (PInfty : K[Y.X] ⟶ _).f n
-- Mathlib/Order/SuccPred/Basic.lean
theorem pred_iterate_le (k : ℕ) (x : α) : pred^[k] x ≤ x
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[simp]
theorem sum.map_one : sum (1 : FreeGroup α) = 0
-- Mathlib/GroupTheory/SpecificGroups/Alternating.lean
theorem alternatingGroup_eq_sign_ker : alternatingGroup α = sign.ker
-- Mathlib/Algebra/Order/GroupWithZero/Canonical.lean
theorem zero_lt_iff : 0 < a ↔ a ≠ 0
-- Mathlib/Order/Cover.lean
theorem Set.OrdConnected.apply_wcovBy_apply_iff (f : α ↪o β) (h : (range f).OrdConnected) :
    f a ⩿ f b ↔ a ⩿ b
-- Mathlib/MeasureTheory/PiSystem.lean
theorem isPiSystem_Ioc (f : ι → α) (g : ι' → α) :
    @IsPiSystem α { S | ∃ i j, f i < g j ∧ Ioc (f i) (g j) = S }
-- Mathlib/LinearAlgebra/Isomorphisms.lean
theorem quotientInfEquivSupQuotient_symm_apply_eq_zero_iff {p p' : Submodule R M} {x : ↥(p ⊔ p')} :
    (quotientInfEquivSupQuotient p p').symm (Submodule.Quotient.mk x) = 0 ↔ (x : M) ∈ p'
-- Mathlib/Data/Multiset/Basic.lean
theorem countP_eq_zero {s} : countP p s = 0 ↔ ∀ a ∈ s, ¬p a
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@[simp]
theorem coe_inclusion {S T : NonUnitalSubalgebra R A} (h : S ≤ T) (s : S) :
    (inclusion h s : A) = s
-- Mathlib/CategoryTheory/FiberedCategory/HomLift.lean
lemma domain_eq (f : R ⟶ S) (φ : a ⟶ b) [p.IsHomLift f φ] : p.obj a = R
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
/-- Alias of `Nat.cast_eq_zero`, specialized to `Ordinal` --/
theorem natCast_ne_zero {n : ℕ} : (n : Ordinal) ≠ 0 ↔ n ≠ 0
-- Mathlib/Algebra/Order/Kleene.lean
theorem kstar_def (a : α × β) : a∗ = (a.1∗, a.2∗)
-- Mathlib/Topology/Category/TopCat/Basic.lean
@[simp] theorem coe_comp {X Y Z : TopCat.{u}} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g : X → Z) = g ∘ f
-- Mathlib/Data/ENNReal/Operations.lean
@[gcongr] protected theorem mul_lt_mul_left' (h0 : a ≠ 0) (hinf : a ≠ ⊤) (bc : b < c) :
    a * b < a * c
-- Mathlib/Topology/Bases.lean
theorem empty_nmem_countableBasis [SecondCountableTopology α] : ∅ ∉ countableBasis α
-- Mathlib/Geometry/Euclidean/MongePoint.lean
/-- The Monge point of an (n+2)-simplex, minus the centroid of an
n-dimensional face, in terms of `pointsWithCircumcenter`. -/
theorem mongePoint_vsub_face_centroid_eq_weightedVSub_of_pointsWithCircumcenter {n : ℕ}
    (s : Simplex ℝ P (n + 2)) {i₁ i₂ : Fin (n + 3)} (h : i₁ ≠ i₂) :
    s.mongePoint -ᵥ ({i₁, i₂}ᶜ : Finset (Fin (n + 3))).centroid ℝ s.points =
      (univ : Finset (PointsWithCircumcenterIndex (n + 2))).weightedVSub s.pointsWithCircumcenter
        (mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂)
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- If `E` is an algebraic closure of `F`, then `F` is separably closed if and only if `E / F` is
purely inseparable. -/
theorem isSepClosed_iff_isPurelyInseparable_algebraicClosure [IsAlgClosure F E] :
    IsSepClosed F ↔ IsPurelyInseparable F E
-- Mathlib/Deprecated/Subfield.lean
/-- `IsSubfield (S : Set F)` is the predicate saying that a given subset of a field is
the set underlying a subfield. This structure is deprecated; use the bundled variant
`Subfield F` to model subfields of a field. -/
structure IsSubfield extends IsSubring S : Prop where
  inv_mem : ∀ {x : F}, x ∈ S → x⁻¹ ∈ S
-- Mathlib/Analysis/CstarAlgebra/Multiplier.lean
theorem sub_fst (a b : 𝓜(𝕜, A)) : (a - b).fst = a.fst - b.fst
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
theorem eq_some_of_isSome : ∀ {o : Option α} (h : o.isSome), o = some (o.get h)
-- Mathlib/Topology/Maps/Basic.lean
protected theorem id : QuotientMap (@id X)
-- Mathlib/Data/Real/EReal.lean
theorem coe_ennreal_nonneg (x : ℝ≥0∞) : (0 : EReal) ≤ x
-- Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean
/-- If a measurable space admits a countable separating family of measurable sets,
there is a countably generated coarser space which still separates points. -/
theorem exists_countablyGenerated_le_of_countablySeparated [m : MeasurableSpace α]
    [h : CountablySeparated α] :
    ∃ m' : MeasurableSpace α, @CountablyGenerated _ m' ∧ @SeparatesPoints _ m' ∧ m' ≤ m
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
theorem DifferentiableWithinAt.const_add (hf : DifferentiableWithinAt 𝕜 f s x) (c : F) :
    DifferentiableWithinAt 𝕜 (fun y => c + f y) s x
-- Mathlib/LinearAlgebra/Finsupp.lean
@[simp]
theorem total_mapDomain (f : α → α') (l : α →₀ R) :
    (Finsupp.total α' M' R v') (mapDomain f l) = (Finsupp.total α M' R (v' ∘ f)) l
-- Mathlib/RingTheory/WittVector/Truncated.lean
@[simp]
theorem truncate_lift (s : S) : WittVector.truncate n (lift _ f_compat s) = f n s
-- Mathlib/RingTheory/Polynomial/Basic.lean
@[simp]
theorem toSubring_one :
    toSubring (1 : R[X]) T
        (Set.Subset.trans coeffs_one <| Finset.singleton_subset_set_iff.2 T.one_mem) =
      1
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions/Fractions.lean
/-- This structure contains the data of three left fractions for
`W : MorphismProperty C` that have the same "denominator". -/
structure LeftFraction₃ (X Y : C) where
  /-- the auxiliary object of left fractions -/
  {Y' : C}
  /-- the numerator of the first left fraction -/
  f : X ⟶ Y'
  /-- the numerator of the second left fraction -/
  f' : X ⟶ Y'
  /-- the numerator of the third left fraction -/
  f'' : X ⟶ Y'
  /-- the denominator of the left fractions -/
  s : Y ⟶ Y'
  /-- the condition that the denominator belongs to the given morphism property -/
  hs : W s
-- Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean
theorem hasInitial_of_hasTerminal_op [HasTerminal Cᵒᵖ] : HasInitial C
-- Mathlib/RingTheory/OreLocalization/Basic.lean
@[to_additive (attr := simp)]
theorem liftExpand_of {C : Sort*} {P : X → S → C}
    {hP : ∀ (r : X) (t : R) (s : S) (ht : t * s ∈ S), P r s = P (t • r) ⟨t * s, ht⟩} (r : X)
    (s : S) : liftExpand P hP (r /ₒ s) = P r s
-- Mathlib/Analysis/Calculus/IteratedDeriv/Lemmas.lean
theorem iteratedDerivWithin_const_neg (hn : 0 < n) (c : F) :
    iteratedDerivWithin n (fun z => c - f z) s x = iteratedDerivWithin n (fun z => -f z) s x
-- Mathlib/Topology/Category/Profinite/Limits.lean
@[reassoc (attr := simp)]
lemma pullback.lift_fst {Z : Profinite.{u}} (a : Z ⟶ X) (b : Z ⟶ Y) (w : a ≫ f = b ≫ g) :
    pullback.lift f g a b w ≫ pullback.fst f g = a
-- Mathlib/Order/WellFoundedSet.lean
theorem IsWF.min_le (hs : s.IsWF) (hn : s.Nonempty) (ha : a ∈ s) : hs.min hn ≤ a
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
theorem isHomogeneous_X (i : σ) : IsHomogeneous (X i : MvPolynomial σ R) 1
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToL1_lipschitz (hT : DominatedFinMeasAdditive μ T C) :
    LipschitzWith (Real.toNNReal C) (setToL1 hT)
-- Mathlib/Algebra/Order/Pi.lean
@[to_additive (attr := simp)]
theorem const_le_one : const β a ≤ 1 ↔ a ≤ 1
-- Mathlib/Data/Finset/Prod.lean
theorem product_eq_biUnion_right [DecidableEq (α × β)] (s : Finset α) (t : Finset β) :
    s ×ˢ t = t.biUnion fun b => s.image fun a => (a, b)
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
theorem biprod.braiding'_eq_braiding {P Q : C} : biprod.braiding' P Q = biprod.braiding P Q
-- Mathlib/LinearAlgebra/FreeModule/Finite/Basic.lean
/-- A free module with a basis indexed by a `Fintype` is finite. -/
theorem _root_.Module.Finite.of_basis {R M ι : Type*} [Semiring R] [AddCommMonoid M] [Module R M]
    [_root_.Finite ι] (b : Basis ι R M) : Module.Finite R M
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem succ_inj' : succ a = succ b ↔ a = b
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
/-- A finitely strongly measurable function is strongly measurable. -/
@[aesop 5% apply (rule_sets := [Measurable])]
protected theorem stronglyMeasurable [Zero β] [TopologicalSpace β]
    (hf : FinStronglyMeasurable f μ) : StronglyMeasurable f
-- Mathlib/Topology/Algebra/Monoid.lean
/-- Left-multiplication by a left-invertible element of a topological monoid is proper, i.e.,
inverse images of compact sets are compact. -/
theorem Filter.tendsto_cocompact_mul_left {a b : M} (ha : b * a = 1) :
    Filter.Tendsto (fun x : M => a * x) (Filter.cocompact M) (Filter.cocompact M)
-- Mathlib/Analysis/Convex/Integral.lean
/-- If `μ` is a non-zero finite measure on `α`, `s` is a convex closed set in `E`, and `f` is an
integrable function sending `μ`-a.e. points to `s`, then the average value of `f` belongs to `s`:
`⨍ x, f x ∂μ ∈ s`. See also `Convex.centerMass_mem` for a finite sum version of this lemma. -/
theorem Convex.set_average_mem (hs : Convex ℝ s) (hsc : IsClosed s) (h0 : μ t ≠ 0) (ht : μ t ≠ ∞)
    (hfs : ∀ᵐ x ∂μ.restrict t, f x ∈ s) (hfi : IntegrableOn f t μ) : (⨍ x in t, f x ∂μ) ∈ s
-- Mathlib/Topology/MetricSpace/Dilation.lean
/-- A dilation from a metric space is a uniform embedding -/
protected theorem uniformEmbedding [PseudoEMetricSpace β] [DilationClass F α β] (f : F) :
    UniformEmbedding f
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
lemma integrable_preCDF (ρ : Measure (α × ℝ)) [IsFiniteMeasure ρ] (x : ℚ) :
    Integrable (fun a ↦ (preCDF ρ x a).toReal) ρ.fst
-- Mathlib/Probability/ProbabilityMassFunction/Monad.lean
theorem bindOnSupport_pure (p : PMF α) : (p.bindOnSupport fun a _ => pure a) = p
-- Mathlib/Order/Interval/Set/SurjOn.lean
theorem surjOn_Iic_of_monotone_surjective (h_mono : Monotone f) (h_surj : Function.Surjective f)
    (a : α) : SurjOn f (Iic a) (Iic (f a))
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem zero_mem : (0 : K) ∈ A
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[simp, norm_cast]
theorem coe_intCast (n : ℤ) : ((n : s) : R) = n
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem HasFDerivWithinAt.rpow (hf : HasFDerivWithinAt f f' s x) (hg : HasFDerivWithinAt g g' s x)
    (h : 0 < f x) : HasFDerivWithinAt (fun x => f x ^ g x)
      ((g x * f x ^ (g x - 1)) • f' + (f x ^ g x * Real.log (f x)) • g') s x
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
lemma ofLowerSet_le_iff {a b : WithLowerSet α} : ofLowerSet a ≤ ofLowerSet b ↔ a ≤ b
-- Mathlib/CategoryTheory/Functor/FullyFaithful.lean
@[simp]
theorem fullyFaithfulCancelRight_inv_app {F G : C ⥤ D} {H : D ⥤ E} [Full H] [H.Faithful]
    (comp_iso : F ⋙ H ≅ G ⋙ H) (X : C) :
    (fullyFaithfulCancelRight H comp_iso).inv.app X = H.preimage (comp_iso.inv.app X)
-- Mathlib/Data/Set/Prod.lean
theorem offDiag_union (h : Disjoint s t) :
    (s ∪ t).offDiag = s.offDiag ∪ t.offDiag ∪ s ×ˢ t ∪ t ×ˢ s
-- Mathlib/Analysis/Complex/ReImTopology.lean
theorem isOpenMap_im : IsOpenMap im
-- Mathlib/Algebra/Category/ModuleCat/Monoidal/Basic.lean
private theorem associator_naturality_aux {X₁ X₂ X₃ : Type*} [AddCommMonoid X₁] [AddCommMonoid X₂]
    [AddCommMonoid X₃] [Module R X₁] [Module R X₂] [Module R X₃] {Y₁ Y₂ Y₃ : Type*}
    [AddCommMonoid Y₁] [AddCommMonoid Y₂] [AddCommMonoid Y₃] [Module R Y₁] [Module R Y₂]
    [Module R Y₃] (f₁ : X₁ →ₗ[R] Y₁) (f₂ : X₂ →ₗ[R] Y₂) (f₃ : X₃ →ₗ[R] Y₃) :
    ↑(assoc R Y₁ Y₂ Y₃) ∘ₗ map (map f₁ f₂) f₃ = map f₁ (map f₂ f₃) ∘ₗ ↑(assoc R X₁ X₂ X₃)
-- Mathlib/Algebra/AddConstMap/Equiv.lean
@[simp]
lemma symm_trans_self (e : G ≃+c[a, b] H) : e.symm.trans e = .refl b
-- Mathlib/Order/Filter/Bases.lean
theorem _root_.Disjoint.exists_mem_filter_basis (h : Disjoint l l') (hl : l.HasBasis p s)
    (hl' : l'.HasBasis p' s') : ∃ i, p i ∧ ∃ i', p' i' ∧ Disjoint (s i) (s' i')
-- Mathlib/Probability/IdentDistrib.lean
theorem memℒp_snd [NormedAddCommGroup γ] [BorelSpace γ] {p : ℝ≥0∞} (h : IdentDistrib f g μ ν)
    (hf : Memℒp f p μ) : Memℒp g p ν
-- Mathlib/Data/Nat/ModEq.lean
theorem of_div (h : a / c ≡ b / c [MOD m / c]) (ha : c ∣ a) (ha : c ∣ b) (ha : c ∣ m) :
    a ≡ b [MOD m]
-- Mathlib/Algebra/Order/Sub/Defs.lean
@[simp]
theorem add_tsub_cancel_left (a b : α) : a + b - a = b
-- Mathlib/Data/List/Intervals.lean
theorem pairwise_lt (n m : ℕ) : Pairwise (· < ·) (Ico n m)
-- Mathlib/Data/Finsupp/Basic.lean
theorem comapDomain_add (v₁ v₂ : β →₀ M) (hv₁ : Set.InjOn f (f ⁻¹' ↑v₁.support))
    (hv₂ : Set.InjOn f (f ⁻¹' ↑v₂.support)) (hv₁₂ : Set.InjOn f (f ⁻¹' ↑(v₁ + v₂).support)) :
    comapDomain f (v₁ + v₂) hv₁₂ = comapDomain f v₁ hv₁ + comapDomain f v₂ hv₂
-- Mathlib/Data/Seq/Seq.lean
theorem destruct_eq_nil {s : Seq α} : destruct s = none → s = nil
-- Mathlib/NumberTheory/FLT/Three.lean
/-- Given `(S : Solution)`, we have that `λ ∣ (S.a + η * S.b)`. -/
lemma lambda_dvd_a_add_eta_mul_b : λ ∣ (S.a + η * S.b)
-- Mathlib/Algebra/MvPolynomial/Monad.lean
theorem map_bind₁ (f : R →+* S) (g : σ → MvPolynomial τ R) (φ : MvPolynomial σ R) :
    map f (bind₁ g φ) = bind₁ (fun i : σ => (map f) (g i)) (map f φ)
-- Mathlib/Data/Finset/Basic.lean
theorem erase_sdiff_comm (s t : Finset α) (a : α) : s.erase a \ t = (s \ t).erase a
-- Mathlib/Data/Stream/Init.lean
@[simp] theorem drop_tail' {i : ℕ} {s : Stream' α} : drop i (tail s) = s.drop (i+1)
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem ite_left (s t : Set α) : s.ite s t = s ∪ t
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
@[simp]
theorem AddMonoidHom.coe_toIntLinearMap [AddCommGroup M] [AddCommGroup M₂] (f : M →+ M₂) :
    ⇑f.toIntLinearMap = f
-- Mathlib/Data/Seq/Computation.lean
@[trans]
theorem Equiv.trans {s t u : Computation α} : s ~ t → t ~ u → s ~ u
-- Mathlib/ModelTheory/Substructures.lean
theorem range_comp_le_range (f : M →[L] N) (g : N →[L] P) : range (g.comp f : M →[L] P) ≤ range g
-- Mathlib/Algebra/Order/Group/Basic.lean
@[to_additive zsmul_strictMono_right]
lemma zpow_strictMono_left (hn : 0 < n) : StrictMono ((· ^ n) : α → α)
-- Mathlib/Order/Filter/Cofinite.lean
theorem le_cofinite_iff_eventually_ne : l ≤ cofinite ↔ ∀ x, ∀ᶠ y in l, y ≠ x
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
theorem norm_nonneg (f : PadicSeq p) : 0 ≤ f.norm
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[simp]
theorem sum_mk : sum (mk L) = List.sum (L.map fun x => cond x.2 x.1 (-x.1))
-- Mathlib/Topology/ContinuousFunction/Compact.lean
theorem dist_lt_of_dist_lt_modulus (f : C(α, β)) (ε : ℝ) (h : 0 < ε) {a b : α}
    (w : dist a b < f.modulus ε h) : dist (f a) (f b) < ε
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
@[simp]
theorem smul_apply (f : ContinuousMultilinearMap A M₁ M₂) (c : R') (m : ∀ i, M₁ i) :
    (c • f) m = c • f m
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Iic_subset_Iio_union_Icc : Iic b ⊆ Iio a ∪ Icc a b
-- Mathlib/Order/WithBot.lean
@[simp, deprecated not_top_lt "Don't mix Option and WithTop" (since := "2024-05-27")]
theorem not_none_lt (a : WithTop α) : ¬@LT.lt (WithTop α) _ none a
-- Mathlib/LinearAlgebra/FiniteDimensional.lean
@[simp]
theorem coe_finsetBasisOfLinearIndependentOfCardEqFinrank {s : Finset V} (hs : s.Nonempty)
    (lin_ind : LinearIndependent K ((↑) : s → V)) (card_eq : s.card = finrank K V) :
    ⇑(finsetBasisOfLinearIndependentOfCardEqFinrank hs lin_ind card_eq) = ((↑) : s → V)