ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, rclike_simps]
theorem norm_ofNat (n : ℕ) [n.AtLeastTwo] : ‖(no_index (OfNat.ofNat n) : K)‖ = OfNat.ofNat n
-- Mathlib/Topology/PartialHomeomorph.lean
@[simp, mfld_simps] theorem symm_symm : e.symm.symm = e
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem contDiff_euclidean {n : ℕ∞} : ContDiff 𝕜 n f ↔ ∀ i, ContDiff 𝕜 n fun x => f x i
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
/-- A continuous monotone function between (conditionally) complete linear ordered spaces sends a
`Filter.limsup` to the `Filter.limsup` of the images (if the filter is bounded from above and
frequently bounded from below). -/
theorem Monotone.map_limsup_of_continuousAt {f : R → S} (f_incr : Monotone f) (a : ι → R)
    (f_cont : ContinuousAt f (F.limsup a))
    (bdd_above : F.IsBoundedUnder (· ≤ ·) a := by isBoundedDefault)
    (cobdd : F.IsCoboundedUnder (· ≤ ·) a := by isBoundedDefault) :
    f (F.limsup a) = F.limsup (f ∘ a)
-- Mathlib/Topology/Order/Basic.lean
theorem pi_Icc_mem_nhds' (ha : ∀ i, a' i < x' i) (hb : ∀ i, x' i < b' i) : Icc a' b' ∈ 𝓝 x'
-- Mathlib/Data/Finset/Prod.lean
@[gcongr]
theorem product_subset_product (hs : s ⊆ s') (ht : t ⊆ t') : s ×ˢ t ⊆ s' ×ˢ t'
-- Mathlib/Data/Fintype/Basic.lean
theorem Nonempty.eq_univ [Subsingleton α] : s.Nonempty → s = univ
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem mk_equiv_eq_arrow_of_eq (eq : #α = #β) : #(α ≃ β) = #(α → β)
-- Mathlib/Data/List/Prime.lean
theorem mem_list_primes_of_dvd_prod {p : M} (hp : Prime p) {L : List M} (hL : ∀ q ∈ L, Prime q)
    (hpL : p ∣ L.prod) : p ∈ L
-- Mathlib/Order/Category/Lat.lean
@[simp]
theorem coe_of (α : Type*) [Lattice α] : ↥(of α) = α
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem pow_lt_pow_iff_right {a n m : Nat} (h : 1 < a) :
    a ^ n < a ^ m ↔ n < m
-- Mathlib/Analysis/Convex/Segment.lean
theorem left_mem_segment (x y : E) : x ∈ [x -[𝕜] y]
-- Mathlib/Algebra/Star/StarAlgHom.lean
/-- The `Pi.prod` of two morphisms is a morphism. -/
@[simps!]
def prod (f : A →⋆ₙₐ[R] B) (g : A →⋆ₙₐ[R] C) : A →⋆ₙₐ[R] B × C
-- Mathlib/Topology/Germ.lean
/-- If the germ of `f` w.r.t. each `𝓝 x` is constant, `f` is locally constant. -/
lemma IsLocallyConstant.of_germ_isConstant (h : ∀ x : X, (f : Germ (𝓝 x) Y).IsConstant) :
    IsLocallyConstant f
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sin_eq_zero_iff_of_lt_of_lt {x : ℝ} (hx₁ : -π < x) (hx₂ : x < π) : sin x = 0 ↔ x = 0
-- Mathlib/Order/Monotone/Basic.lean
theorem Monotone.strictMono_iff_injective (hf : Monotone f) : StrictMono f ↔ Injective f
-- Mathlib/Data/Sigma/Basic.lean
protected theorem ext_iff {x₀ x₁ : Sigma β} : x₀ = x₁ ↔ x₀.1 = x₁.1 ∧ HEq x₀.2 x₁.2
-- Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean
/-- Assuming `G` is strongly regular, `2*(k + 1) - m` in `G` is the number of vertices that are
adjacent to either `v` or `w` when `¬G.Adj v w`. So it's the cardinality of
`G.neighborSet v ∪ G.neighborSet w`. -/
theorem IsSRGWith.card_neighborFinset_union_of_not_adj {v w : V} (h : G.IsSRGWith n k ℓ μ)
    (hne : v ≠ w) (ha : ¬G.Adj v w) :
    (G.neighborFinset v ∪ G.neighborFinset w).card = 2 * k - μ
-- Mathlib/CategoryTheory/Limits/Types.lean
theorem small_quot_of_hasColimit (F : J ⥤ Type u) [HasColimit F] : Small.{u} (Quot F)
-- Mathlib/Algebra/BigOperators/Group/Multiset.lean
@[to_additive (attr := simp)]
theorem prod_erase [DecidableEq α] (h : a ∈ s) : a * (s.erase a).prod = s.prod
-- Mathlib/Data/List/Cycle.lean
theorem chain_ne_nil (r : α → α → Prop) {l : List α} :
    ∀ hl : l ≠ [], Chain r l ↔ List.Chain r (getLast l hl) l
-- Mathlib/Data/Set/Basic.lean
protected theorem symmDiff_def (s t : Set α) : s ∆ t = s \ t ∪ t \ s
-- Mathlib/Algebra/Order/GroupWithZero/Canonical.lean
@[simp]
theorem Units.zero_lt (u : αˣ) : (0 : α) < u
-- Mathlib/Order/Hom/Bounded.lean
@[simp]
theorem comp_assoc (f : BoundedOrderHom γ δ) (g : BoundedOrderHom β γ) (h : BoundedOrderHom α β) :
    (f.comp g).comp h = f.comp (g.comp h)
-- Mathlib/CategoryTheory/Limits/Preserves/Limits.lean
@[reassoc (attr := simp)]
theorem preservesLimitsIso_hom_π (j) :
    (preservesLimitIso G F).hom ≫ limit.π _ j = G.map (limit.π F j)
-- Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean
theorem DifferentiableOn.log (hf : DifferentiableOn ℝ f s) (hx : ∀ x ∈ s, f x ≠ 0) :
    DifferentiableOn ℝ (fun x => log (f x)) s
-- Mathlib/Data/NNReal/Basic.lean
@[simp]
theorem coe_toNNReal' (r : ℝ) : (Real.toNNReal r : ℝ) = max r 0
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem fract_add_ofNat (a : α) (n : ℕ) [n.AtLeastTwo] :
    fract (a + (no_index (OfNat.ofNat n))) = fract a
-- Mathlib/Geometry/Euclidean/Angle/Sphere.lean
/-- Oriented angle version of "angles in same segment are equal" and "opposite angles of a
cyclic quadrilateral add to π", for oriented angles mod π (for which those are the same result),
represented here as equality of twice the angles. -/
theorem two_zsmul_oangle_eq {s : Sphere P} {p₁ p₂ p₃ p₄ : P} (hp₁ : p₁ ∈ s) (hp₂ : p₂ ∈ s)
    (hp₃ : p₃ ∈ s) (hp₄ : p₄ ∈ s) (hp₂p₁ : p₂ ≠ p₁) (hp₂p₄ : p₂ ≠ p₄) (hp₃p₁ : p₃ ≠ p₁)
    (hp₃p₄ : p₃ ≠ p₄) : (2 : ℤ) • ∡ p₁ p₂ p₄ = (2 : ℤ) • ∡ p₁ p₃ p₄
-- Mathlib/Algebra/Order/Kleene.lean
theorem mul_kstar_le_kstar : a * a∗ ≤ a∗
-- Mathlib/LinearAlgebra/Dual.lean
theorem toDual_apply (i j : ι) : b.toDual (b i) (b j) = if i = j then 1 else 0
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
@[simp] theorem mul_get (xs ys : IntList) (i : Nat) : (xs * ys).get i = xs.get i * ys.get i
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp] lemma toFun_eq_coe (f : sSupHom α β) : f.toFun = f
-- Mathlib/Topology/Inseparable.lean
lemma Union_closure_singleton_eq_iff {s : Set X} :
    (⋃ x ∈ s, closure {x}) = s ↔ StableUnderSpecialization s
-- Mathlib/Data/Matrix/Basic.lean
theorem diagonal_ofNat [Zero α] [NatCast α] (m : ℕ) [m.AtLeastTwo] :
    diagonal (fun _ : n => no_index (OfNat.ofNat m : α)) = OfNat.ofNat m
-- Mathlib/MeasureTheory/Group/Measure.lean
@[to_additive]
theorem map_div_right_ae (μ : Measure G) [IsMulRightInvariant μ] (x : G) :
    Filter.map (fun t => t / x) (ae μ) = ae μ
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem OuterMeasure.toMeasure_zero [MeasurableSpace α] :
    (0 : OuterMeasure α).toMeasure (le_top.trans OuterMeasure.zero_caratheodory.symm.le) = 0
-- Mathlib/Data/Rat/Cast/Order.lean
@[simp]
theorem preimage_cast_Icc (p q : ℚ≥0) : (↑) ⁻¹' Icc (p : K) q = Icc p q
-- Mathlib/Algebra/EuclideanDomain/Basic.lean
theorem xgcdAux_P (a b : R) {r r' : R} {s t s' t'} (p : P a b (r, s, t))
    (p' : P a b (r', s', t')) : P a b (xgcdAux r s t r' s' t')
-- Mathlib/Combinatorics/SimpleGraph/Finite.lean
theorem IsRegularOfDegree.compl [Fintype V] [DecidableEq V] {G : SimpleGraph V} [DecidableRel G.Adj]
    {k : ℕ} (h : G.IsRegularOfDegree k) : Gᶜ.IsRegularOfDegree (Fintype.card V - 1 - k)
-- Mathlib/Data/List/DropRight.lean
theorem rdropWhile_prefix : l.rdropWhile p <+: l
-- Mathlib/Analysis/Normed/Group/Hom.lean
theorem SurjectiveOnWith.mono {f : NormedAddGroupHom V₁ V₂} {K : AddSubgroup V₂} {C C' : ℝ}
    (h : f.SurjectiveOnWith K C) (H : C ≤ C') : f.SurjectiveOnWith K C'
-- Mathlib/Geometry/Manifold/LocalDiffeomorph.lean
/-- A local diffeomorphism is an open map. -/
lemma IsLocalDiffeomorph.isOpenMap (hf : IsLocalDiffeomorph I J n f) : IsOpenMap f
-- Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean
theorem cosh_dist (z w : ℍ) : cosh (dist z w) = 1 + dist (z : ℂ) w ^ 2 / (2 * z.im * w.im)
-- Mathlib/FieldTheory/Normal.lean
theorem AlgHom.restrictNormal_comp [Normal F E] :
    (ψ.restrictNormal E).comp (ϕ.restrictNormal E) = (ψ.comp ϕ).restrictNormal E
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
@[reassoc]
theorem coequalizer.condition : f ≫ coequalizer.π f g = g ≫ coequalizer.π f g
-- Mathlib/Topology/Category/CompHaus/Limits.lean
theorem pullback_snd_eq :
    CompHaus.pullback.snd f g = (pullbackIsoPullback f g).hom ≫ Limits.pullback.snd f g
-- Mathlib/RingTheory/Localization/Submodule.lean
theorem coeSubmodule_fg (hS : Function.Injective (algebraMap R S)) (I : Ideal R) :
    Submodule.FG (coeSubmodule S I) ↔ Submodule.FG I
-- Mathlib/Order/Interval/Finset/Fin.lean
theorem Ici_eq_finset_subtype : Ici a = (Icc (a : ℕ) n).fin n
-- Mathlib/Topology/ContinuousOn.lean
theorem eventually_nhdsWithin_iff {a : α} {s : Set α} {p : α → Prop} :
    (∀ᶠ x in 𝓝[s] a, p x) ↔ ∀ᶠ x in 𝓝 a, x ∈ s → p x
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[simp]
theorem coe_rangeRestrict (f : R →+* S) (x : R) : (f.rangeRestrict x : S) = f x
-- Mathlib/Data/Nat/PartENat.lean
@[simp]
theorem get_ofNat' (x : ℕ) [x.AtLeastTwo] (h : (no_index (OfNat.ofNat x : PartENat)).Dom) :
    Part.get (no_index (OfNat.ofNat x : PartENat)) h = (no_index (OfNat.ofNat x))
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem le_mul_left {a b : Cardinal} (h : b ≠ 0) : a ≤ b * a
-- Mathlib/Data/PNat/Basic.lean
@[mono]
theorem succPNat_strictMono : StrictMono succPNat
-- Mathlib/Logic/Equiv/Defs.lean
@[simp] theorem cast_apply {α β} (h : α = β) (x : α) : Equiv.cast h x = cast h x
-- Mathlib/FieldTheory/Perfect.lean
@[simp]
theorem iterateFrobeniusEquiv_one : iterateFrobeniusEquiv R p 1 = frobeniusEquiv R p
-- .lake/packages/lean4/src/lean/Init/Data/String/Extra.lean
@[simp] theorem size_toUTF8 (s : String) : s.toUTF8.size = s.utf8ByteSize
-- Mathlib/CategoryTheory/Functor/KanExtension/Pointwise.lean
/-- The cone for `StructuredArrow.proj Y L ⋙ F` attached to `E : RightExtension L F`.
The point of this cone is `E.left.obj Y` -/
@[simps]
def coneAt (Y : D) : Cone (StructuredArrow.proj Y L ⋙ F)
-- Mathlib/Order/Filter/Ultrafilter.lean
@[simp]
theorem empty_not_mem : ∅ ∉ f
-- Mathlib/Analysis/Normed/Module/WeakDual.lean
/-- While the coercion `↑ : WeakDual 𝕜 E → (E → 𝕜)` is not a closed map, it sends *bounded*
closed sets to closed sets. -/
theorem isClosed_image_coe_of_bounded_of_closed {s : Set (WeakDual 𝕜 E)}
    (hb : IsBounded (Dual.toWeakDual ⁻¹' s)) (hc : IsClosed s) :
    IsClosed (((↑) : WeakDual 𝕜 E → E → 𝕜) '' s)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem _root_.Subgroup.ker_inclusion {H K : Subgroup G} (h : H ≤ K) : (inclusion h).ker = ⊥
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
/-- A measure on a product space equals the product measure if they are equal on rectangles
  with as sides sets that generate the corresponding σ-algebras. -/
theorem prod_eq_generateFrom {μ : Measure α} {ν : Measure β} {C : Set (Set α)} {D : Set (Set β)}
    (hC : generateFrom C = ‹_›) (hD : generateFrom D = ‹_›) (h2C : IsPiSystem C)
    (h2D : IsPiSystem D) (h3C : μ.FiniteSpanningSetsIn C) (h3D : ν.FiniteSpanningSetsIn D)
    {μν : Measure (α × β)} (h₁ : ∀ s ∈ C, ∀ t ∈ D, μν (s ×ˢ t) = μ s * ν t) : μ.prod ν = μν
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem map_nil {f : α → β} : map f [] = []
-- Mathlib/Data/ENNReal/Inv.lean
protected lemma div_ne_zero : a / b ≠ 0 ↔ a ≠ 0 ∧ b ≠ ⊤
-- Mathlib/Topology/LocallyConstant/Basic.lean
theorem iff_is_const [PreconnectedSpace X] {f : X → Y} : IsLocallyConstant f ↔ ∀ x y, f x = f y
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
/-- A family `𝓕 : ι → β → α` is uniformly equicontinuous on `S` iff the function
`swap 𝓕 : β → ι → α` is uniformly continuous on `S`
*when `ι → α` is equipped with the uniform structure of uniform convergence*. This is very useful
for developping the equicontinuity API, but it should not be used directly for other purposes. -/
theorem uniformEquicontinuousOn_iff_uniformContinuousOn {F : ι → β → α} {S : Set β} :
    UniformEquicontinuousOn F S ↔ UniformContinuousOn (ofFun ∘ Function.swap F : β → ι →ᵤ α) S
-- Mathlib/RingTheory/Bialgebra/Hom.lean
@[simp]
theorem coe_copy (f : A →ₗc[R] B) (f' : A → B) (h : f' = ⇑f) : ⇑(f.copy f' h) = f'
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem natDegree_zero : natDegree (0 : R[X]) = 0
-- Mathlib/Algebra/Module/LocalizedModule.lean
/-- Formula for `IsLocalizedModule.map` when each localized module is a `LocalizedModule`.-/
lemma map_LocalizedModules (g : M₀ →ₗ[R] M₁) (m : M₀) (s : S) :
    ((map S (mkLinearMap S M₀) (mkLinearMap S M₁)) g)
    (LocalizedModule.mk m s) = LocalizedModule.mk (g m) s
-- Mathlib/Data/Finset/Lattice.lean
/-- Infimum of `s i`, `i : ι`, is equal to the infimum over `t : Finset ι` of infima
`⨅ i ∈ t, s i`. This version assumes `ι` is a `Type*`. See `iInf_eq_iInf_finset'` for a version
that works for `ι : Sort*`. -/
theorem iInf_eq_iInf_finset (s : ι → α) : ⨅ i, s i = ⨅ (t : Finset ι) (i ∈ t), s i
-- Mathlib/Order/Compare.lean
theorem eq_iff_eq_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x = y ↔ x' = y'
-- Mathlib/Algebra/Order/Sub/Defs.lean
theorem tsub_add_eq_tsub_tsub (a b c : α) : a - (b + c) = a - b - c
-- Mathlib/Data/ENNReal/Inv.lean
protected theorem div_eq_inv_mul : a / b = b⁻¹ * a
-- Mathlib/Topology/Algebra/WithZeroTopology.lean
/-- The neighbourhood filter of a nonzero element consists of all sets containing that
element. -/
@[simp]
theorem nhds_of_ne_zero {γ : Γ₀} (h₀ : γ ≠ 0) : 𝓝 γ = pure γ
-- .lake/packages/lean4/src/lean/Init/Data/List/Impl.lean
@[csimp] theorem intercalate_eq_intercalateTR : @intercalate = @intercalateTR
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem Integrable.aestronglyMeasurable {f : α → β} (hf : Integrable f μ) :
    AEStronglyMeasurable f μ
-- Mathlib/Order/UpperLower/Basic.lean
protected theorem IsLowerSet.lowerClosure (hs : IsLowerSet s) : ↑(lowerClosure s) = s
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem IsCoprime.isRelPrime {a b : R} (h : IsCoprime a b) : IsRelPrime a b
-- Mathlib/Topology/MetricSpace/Thickening.lean
theorem ball_subset_thickening {x : X} {E : Set X} (hx : x ∈ E) (δ : ℝ) :
    ball x δ ⊆ thickening δ E
-- Mathlib/Algebra/Group/Action/Units.lean
/-- Note that this lemma exists more generally as the global `smul_inv` -/
@[to_additive (attr := simp)]
lemma smul_inv [Group G] [Monoid M] [MulAction G M] [SMulCommClass G M M] [IsScalarTower G M M]
    (g : G) (m : Mˣ) : (g • m)⁻¹ = g⁻¹ • m⁻¹
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem getLsb_allOnes : (allOnes v).getLsb i = decide (i < v)
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem mul_self_lt_mul_self [PosMulStrictMono α] [MulPosMono α]
    (h1 : 0 ≤ a) (h2 : a < b) : a * a < b * b
-- Mathlib/Algebra/Lie/Weights/RootSystem.lean
@[simp]
lemma chainLength_zero [Nontrivial L] : chainLength 0 β = 0
-- Mathlib/Dynamics/OmegaLimit.lean
/-- An element `y` is in the ω-limit set of `s` w.r.t. `f` if the
    forward images of `s` frequently (w.r.t. `f`) intersect arbitrary
    neighbourhoods of `y`. -/
theorem mem_omegaLimit_iff_frequently₂ (y : β) :
    y ∈ ω f ϕ s ↔ ∀ n ∈ 𝓝 y, ∃ᶠ t in f, (ϕ t '' s ∩ n).Nonempty
-- Mathlib/Deprecated/Submonoid.lean
/-- The submonoid generated by a set is contained in any submonoid that contains the set. -/
@[to_additive
      "The `AddSubmonoid` generated by a set is contained in any `AddSubmonoid` that
      contains the set."]
theorem closure_subset {s t : Set M} (ht : IsSubmonoid t) (h : s ⊆ t) : Closure s ⊆ t
-- Mathlib/Analysis/Normed/Lp/WithLp.lean
@[simp]
theorem equiv_neg : WithLp.equiv p V (-x) = -WithLp.equiv p V x
-- Mathlib/Topology/Order/Hom/Basic.lean
/-- `ContinuousOrderHomClass F α β` states that `F` is a type of continuous monotone maps.

You should extend this class when you extend `ContinuousOrderHom`. -/
class ContinuousOrderHomClass (F : Type*) (α β : outParam Type*) [Preorder α] [Preorder β]
    [TopologicalSpace α] [TopologicalSpace β] [FunLike F α β] extends
    ContinuousMapClass F α β : Prop where
  map_monotone (f : F) : Monotone f
-- Mathlib/AlgebraicGeometry/Spec.lean
@[reassoc]
theorem toPushforwardStalk_comp :
    f ≫ StructureSheaf.toPushforwardStalk f p =
      StructureSheaf.toStalk R p ≫
        (TopCat.Presheaf.stalkFunctor _ _).map (Spec.sheafedSpaceMap f).c
-- Mathlib/Analysis/Convex/Function.lean
theorem ConvexOn.le_right_of_left_le'' (hf : ConvexOn 𝕜 s f) (hx : x ∈ s) (hz : z ∈ s) (hxy : x < y)
    (hyz : y ≤ z) (h : f x ≤ f y) : f y ≤ f z
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
lemma measurable_down : Measurable (ULift.down : ULift α → α)
-- Mathlib/MeasureTheory/Measure/LevyProkhorovMetric.lean
lemma meas_le_of_le_of_forall_le_meas_thickening_add {ε₁ ε₂ : ℝ≥0∞} (μ ν : Measure Ω)
    (h_le : ε₁ ≤ ε₂) {B : Set Ω} (hε₁ : μ B ≤ ν (thickening ε₁.toReal B) + ε₁) :
    μ B ≤ ν (thickening ε₂.toReal B) + ε₂
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
@[simp] lemma map_dblU : dblU (W'.map f) (f ∘ P) = f (W'.dblU P)
-- Mathlib/Analysis/Fourier/FourierTransform.lean
theorem fourierIntegral_continuousMultilinearMap_apply'
    {f : V → ContinuousMultilinearMap ℝ M E} {m : (i : ι) → M i} {w : W} (hf : Integrable f μ) :
    VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ f w m =
      VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ (fun x ↦ f x m) w
-- Mathlib/Data/NNRat/Defs.lean
lemma mk_divInt (n d : ℕ) :
    ⟨.divInt n d, Rat.divInt_nonneg n.cast_nonneg d.cast_nonneg⟩ = divNat n d
-- Mathlib/Data/List/MinMax.lean
@[simp]
theorem argmin_eq_none : l.argmin f = none ↔ l = []
-- Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean
theorem gramSchmidt_of_orthogonal {f : ι → E} (hf : Pairwise fun i j => ⟪f i, f j⟫ = 0) :
    gramSchmidt 𝕜 f = f
-- Mathlib/Analysis/Convex/Function.lean
theorem ConcaveOn.right_le_of_le_left'' (hf : ConcaveOn 𝕜 s f) (hx : x ∈ s) (hz : z ∈ s)
    (hxy : x < y) (hyz : y ≤ z) (h : f y ≤ f x) : f z ≤ f y
-- Mathlib/Algebra/Module/Equiv/Basic.lean
@[simp]
protected theorem smul_def (f : M ≃ₗ[R] M) (a : M) : f • a = f a
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem valuation_le_iff (x y : K) : A.valuation x ≤ A.valuation y ↔ ∃ a : A, (a : K) * y = x
-- Mathlib/RingTheory/Bialgebra/Hom.lean
@[simp]
theorem counitBialgHom_apply (x : A) :
    counitBialgHom R A x = Coalgebra.counit x
-- Mathlib/Data/Part.lean
theorem map_map (g : β → γ) (f : α → β) (o : Part α) : map g (map f o) = map (g ∘ f) o
-- Mathlib/Analysis/SpecialFunctions/Gamma/Beta.lean
/-- Euler's limit formula for the real Gamma function. -/
theorem GammaSeq_tendsto_Gamma (s : ℝ) : Tendsto (GammaSeq s) atTop (𝓝 <| Gamma s)
-- Mathlib/Combinatorics/HalesJewett.lean
@[simp]
theorem map_apply {α α' ι} (f : α → α') (l : Line α ι) (x : α) : l.map f (f x) = f ∘ l x
-- Mathlib/CategoryTheory/Category/Factorisation.lean
/-- The unique morphism out of `Factorisation.initial f`. -/
@[simps]
protected def initialHom (d : Factorisation f) :
    Factorisation.Hom (Factorisation.initial : Factorisation f) d
-- Mathlib/Order/Filter/AtTopBot.lean
theorem Tendsto.nsmul_atBot (hf : Tendsto f l atBot) {n : ℕ} (hn : 0 < n) :
    Tendsto (fun x => n • f x) l atBot
-- Mathlib/NumberTheory/FLT/Three.lean
private lemma Z_u₃_spec : S.Z ^ 3 * S.u₃ = S.z
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem dual_id : InfTopHom.dual (InfTopHom.id α) = SupBotHom.id _
-- Mathlib/MeasureTheory/Measure/LevyProkhorovMetric.lean
/-- A version of the layer cake formula for bounded continuous functions which have finite integral:
∫ f dμ = ∫ t in (0, ‖f‖], μ {x | f(x) ≥ t} dt. -/
lemma BoundedContinuousFunction.integral_eq_integral_meas_le_of_hasFiniteIntegral
    {α : Type*} [MeasurableSpace α] [TopologicalSpace α] [OpensMeasurableSpace α]
    (f : α →ᵇ ℝ) (μ : Measure α) (f_nn : 0 ≤ᵐ[μ] f) (hf : HasFiniteIntegral f μ) :
    ∫ ω, f ω ∂μ = ∫ t in Ioc 0 ‖f‖, ENNReal.toReal (μ {a : α | t ≤ f a})
-- Mathlib/CategoryTheory/Generator.lean
theorem isCoseparating_iff_mono (𝒢 : Set C)
    [∀ A : C, HasProduct fun f : ΣG : 𝒢, A ⟶ (G : C) => (f.1 : C)] :
    IsCoseparating 𝒢 ↔ ∀ A : C, Mono (Pi.lift (@Sigma.snd 𝒢 fun G => A ⟶ (G : C)))
-- Mathlib/RingTheory/FiniteType.lean
/-- If `MonoidAlgebra R M` is of finite type, then there is a `G : Finset M` such that its image
generates, as algebra, `MonoidAlgebra R M`. -/
theorem exists_finset_adjoin_eq_top [h : FiniteType R (MonoidAlgebra R M)] :
    ∃ G : Finset M, Algebra.adjoin R (of R M '' G) = ⊤
-- Mathlib/Order/Basic.lean
@[simp]
theorem le_Prop_eq : ((· ≤ ·) : Prop → Prop → Prop) = (· → ·)
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem length_eq_zero_iff {u : V} {p : G.Walk u u} : p.length = 0 ↔ p = nil
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem isCoprime_iff_exists : IsCoprime I J ↔ ∃ i ∈ I, ∃ j ∈ J, i + j = 1
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
theorem adj_incidenceSet_inter {v : V} {e : Sym2 V} (he : e ∈ G.edgeSet) (h : v ∈ e) :
    G.incidenceSet v ∩ G.incidenceSet (Sym2.Mem.other h) = {e}
-- Mathlib/ModelTheory/LanguageMap.lean
/-- A language map defined on two factors of a sum. -/
@[simps]
protected def sumElim : L.sum L'' →ᴸ L'
-- Mathlib/Topology/Order/Basic.lean
/-- Let `α` be a densely ordered linear order with order topology. If `α` is a separable space, then
it has second countable topology. Note that the "densely ordered" assumption cannot be dropped, see
[double arrow space](https://topology.pi-base.org/spaces/S000093) for a counterexample. -/
theorem SecondCountableTopology.of_separableSpace_orderTopology [OrderTopology α] [DenselyOrdered α]
    [SeparableSpace α] : SecondCountableTopology α
-- Mathlib/Logic/Lemmas.lean
lemma Prop.forall {f : Prop → Prop} : (∀ p, f p) ↔ f True ∧ f False
-- Mathlib/Data/ENNReal/Inv.lean
theorem exists_nat_pos_mul_gt (ha : a ≠ 0) (hb : b ≠ ∞) : ∃ n > 0, b < (n : ℕ) * a
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
theorem eq_true_of_ne_false : {b : Bool} → Not (Eq b false) → Eq b true
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
lemma adjoin_eq_span (s : Set A) : (adjoin R s).toSubmodule = span R (Subsemigroup.closure s)
-- Mathlib/Topology/PartialHomeomorph.lean
/-- The inverse of a partial homeomorphism `e` is an open map on `e.target`. -/
lemma isOpen_image_symm_of_subset_target {t : Set Y} (ht : IsOpen t) (hte : t ⊆ e.target) :
    IsOpen (e.symm '' t)
-- Mathlib/Computability/EpsilonNFA.lean
@[simp]
theorem εClosure_univ : M.εClosure univ = univ
-- Mathlib/Combinatorics/SimpleGraph/Metric.lean
theorem edist_le (p : G.Walk u v) :
    G.edist u v ≤ p.length
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem ContDiff.sum {ι : Type*} {f : ι → E → F} {s : Finset ι}
    (h : ∀ i ∈ s, ContDiff 𝕜 n fun x => f i x) : ContDiff 𝕜 n fun x => ∑ i ∈ s, f i x
-- Mathlib/Computability/Primrec.lean
theorem ulower_down : Primrec (ULower.down : α → ULower α)
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
@[reassoc (attr := simp)]
lemma opcyclesMap_comp_descOpcycles (φ : S₁ ⟶ S) [S₁.HasRightHomology] :
    opcyclesMap φ ≫ S.descOpcycles k hk =
      S₁.descOpcycles (φ.τ₂ ≫ k) (by rw [← φ.comm₁₂_assoc, hk, comp_zero])
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
theorem subset_vanishingIdeal_zeroLocus (s : Set A) : s ⊆ vanishingIdeal (zeroLocus 𝒜 s)
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
theorem stronglyMeasurable_const {α β} {_ : MeasurableSpace α} [TopologicalSpace β] {b : β} :
    StronglyMeasurable fun _ : α => b
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
/-- Left component of the associator as a natural isomorphism. -/
@[simps!]
def associatorNatIsoLeft (a : B) (g : b ⟶ c) (h : c ⟶ d) :
    (postcomposing a ..).obj g ⋙ (postcomposing ..).obj h ≅ (postcomposing ..).obj (g ≫ h)
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem map_dfinsupp_sumAddHom [AddCommMonoid R] [AddCommMonoid S] [∀ i, AddZeroClass (β i)]
    (h : R →+ S) (f : Π₀ i, β i) (g : ∀ i, β i →+ R) :
    h (sumAddHom g f) = sumAddHom (fun i => h.comp (g i)) f
-- Mathlib/Order/Filter/Basic.lean
theorem iInf_sets_eq_finite' (f : ι → Filter α) :
    (⨅ i, f i).sets = ⋃ t : Finset (PLift ι), (⨅ i ∈ t, f (PLift.down i)).sets
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
theorem hom_inv_id : hom P Q L ≫ inv P Q L = 𝟙 _
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/PullbackCone.lean
@[reassoc (attr := simp)]
lemma IsLimit.lift_fst {t : PullbackCone f g} (ht : IsLimit t) {W : C} (h : W ⟶ X) (k : W ⟶ Y)
    (w : h ≫ f = k ≫ g) : IsLimit.lift ht h k w ≫ fst t = h
-- Mathlib/Data/Multiset/Basic.lean
theorem cons_union_distrib (a : α) (s t : Multiset α) : a ::ₘ (s ∪ t) = a ::ₘ s ∪ a ::ₘ t
-- Mathlib/CategoryTheory/GradedObject.lean
@[reassoc (attr := simp)]
lemma map_hom_inv_id_eval_app (e : X ≅ Y) (F : C ⥤ D ⥤ E) (j : J) (Y : D) :
    (F.map (e.hom j)).app Y ≫ (F.map (e.inv j)).app Y = 𝟙 _