ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
/-- The set in the definition of `Order.cof` is nonempty. -/
theorem cof_nonempty (r : α → α → Prop) [IsRefl α r] :
    { c | ∃ S : Set α, (∀ a, ∃ b ∈ S, r a b) ∧ #S = c }.Nonempty
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem sumAssoc_symm_apply_inr_inr {α β γ} (c) : (sumAssoc α β γ).symm (inr (inr c)) = inr c
-- Mathlib/Topology/MetricSpace/Isometry.lean
/-- An isometry from a metric space is a uniform inducing map -/
protected theorem uniformInducing (hf : Isometry f) : UniformInducing f
-- Mathlib/Data/List/Cycle.lean
@[simp]
theorem Chain.nil (r : α → α → Prop) : Cycle.Chain r (@nil α)
-- Mathlib/Data/Set/Basic.lean
theorem not_mem_of_mem_diff {s t : Set α} {x : α} (h : x ∈ s \ t) : x ∉ t
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
protected theorem IsPrefix.subset (hl : l₁ <+: l₂) : l₁ ⊆ l₂
-- Mathlib/Analysis/Convex/EGauge.lean
lemma egauge_lt_iff : egauge 𝕜 s x < r ↔ ∃ c : 𝕜, x ∈ c • s ∧ ‖c‖₊ < r
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_id : cfc (id : R → R) a = a
-- Mathlib/Analysis/Convex/Side.lean
theorem _root_.Function.Injective.wSameSide_map_iff {s : AffineSubspace R P} {x y : P}
    {f : P →ᵃ[R] P'} (hf : Function.Injective f) :
    (s.map f).WSameSide (f x) (f y) ↔ s.WSameSide x y
-- Mathlib/Analysis/Calculus/FDeriv/Comp.lean
@[fun_prop]
protected theorem HasStrictFDerivAt.iterate {f : E → E} {f' : E →L[𝕜] E}
    (hf : HasStrictFDerivAt f f' x) (hx : f x = x) (n : ℕ) :
    HasStrictFDerivAt f^[n] (f' ^ n) x
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean
theorem card_aux₁ (hucard : u.card = m * 4 ^ P.parts.card + a) :
    (4 ^ P.parts.card - a) * m + a * (m + 1) = u.card
-- Mathlib/Data/Matroid/Basic.lean
theorem Basis'.basis_inter_ground (hIX : M.Basis' I X) : M.Basis I (X ∩ M.E)
-- Mathlib/Analysis/Analytic/Composition.lean
@[simp]
theorem compContinuousLinearMap_applyComposition {n : ℕ} (p : FormalMultilinearSeries 𝕜 F G)
    (f : E →L[𝕜] F) (c : Composition n) (v : Fin n → E) :
    (p.compContinuousLinearMap f).applyComposition c v = p.applyComposition c (f ∘ v)
-- Mathlib/MeasureTheory/Measure/OpenPos.lean
/-- A σ-compact measure zero subset is meagre.
(More generally, every Fσ set of measure zero is meagre.) -/
lemma IsMeagre.of_isSigmaCompact_null [T2Space X] (h₁s : IsSigmaCompact s) (h₂s : μ s = 0) :
    IsMeagre s
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc (attr := simp)]
theorem triangle_assoc_comp_right (X Y : C) :
    (α_ X (𝟙_ C) Y).inv ≫ ((ρ_ X).hom ▷ Y) = X ◁ (λ_ Y).hom
-- Mathlib/Data/Finset/NAry.lean
/-- Symmetric statement to `Finset.image₂_image_left_anticomm`. -/
theorem image_image₂_antidistrib_left {g : γ → δ} {f' : β' → α → δ} {g' : β → β'}
    (h_antidistrib : ∀ a b, g (f a b) = f' (g' b) a) :
    (image₂ f s t).image g = image₂ f' (t.image g') s
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem neg_lt_of_neg_lt {a b : Int} (h : -a < b) : -b < a
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
theorem binary_cofan_inl_toCocone (c : BinaryBicone P Q) : BinaryCofan.inl c.toCocone = c.inl
-- Mathlib/Topology/Irreducible.lean
theorem irreducibleComponent_property (x : X) :
    IsPreirreducible (irreducibleComponent x) ∧
      {x} ⊆ irreducibleComponent x ∧
        ∀ u, IsPreirreducible u → irreducibleComponent x ⊆ u → u = irreducibleComponent x
-- Mathlib/Data/Finset/Basic.lean
theorem eq_of_not_mem_of_mem_insert (ha : b ∈ insert a s) (hb : b ∉ s) : b = a
-- Mathlib/Data/Matrix/Basic.lean
theorem map_matrix_mul (M : Matrix m n α) (N : Matrix n o α) (i : m) (j : o) (f : α →+* β) :
    f ((M * N) i j) = (M.map f * N.map f) i j
-- Mathlib/Topology/VectorBundle/Basic.lean
theorem apply_symm_apply_eq_coordChangeL (e e' : Trivialization F (π F E)) [e.IsLinear R]
    [e'.IsLinear R] {b : B} (hb : b ∈ e.baseSet ∩ e'.baseSet) (v : F) :
    e' (e.toPartialHomeomorph.symm (b, v)) = (b, e.coordChangeL R e' b v)
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
/-- Given a morphism of short complexes `φ : S₁ ⟶ S₂` in an abelian category, if `S₁.g = 0`
(e.g when `S₁` is of the form `S₁.X₁ ⟶ S₁.X₂ ⟶ 0`) and both `S₂.f` and `S₂.g` are zero
(e.g when `S₂` is of the form `0 ⟶ S₂.X₂ ⟶ 0`), then `φ` is a quasi-isomorphism iff
the obvious short complex `S₁.X₂ ⟶ S₁.X₂ ⟶ S₂.X₂` is exact and `φ.τ₂` is an epi). -/
lemma quasiIso_iff_of_zeros' {S₁ S₂ : ShortComplex C} (φ : S₁ ⟶ S₂)
    (hg₁ : S₁.g = 0) (hf₂ : S₂.f = 0) (hg₂ : S₂.g = 0) :
    QuasiIso φ ↔
      (ShortComplex.mk S₁.f φ.τ₂ (by rw [← φ.comm₁₂, hf₂, comp_zero])).Exact ∧ Epi φ.τ₂
-- Mathlib/Combinatorics/SetFamily/Shatter.lean
@[simp] lemma shatters_shatterer : 𝒜.shatterer.Shatters s ↔ 𝒜.Shatters s
-- Mathlib/Data/Part.lean
theorem right_dom_of_mod_dom [Mod α] {a b : Part α} (hab : Dom (a % b)) : b.Dom
-- Mathlib/Topology/AlexandrovDiscrete.lean
/-- A topological space is **Alexandrov-discrete** or **finitely generated** if the intersection of
a family of open sets is open. -/
class AlexandrovDiscrete (α : Type*) [TopologicalSpace α] : Prop where
  /-- The intersection of a family of open sets is an open set. Use `isOpen_sInter` in the root
  namespace instead. -/
  protected isOpen_sInter : ∀ S : Set (Set α), (∀ s ∈ S, IsOpen s) → IsOpen (⋂₀ S)
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
@[simp]
theorem cells_sup (μ ν : YoungDiagram) : (μ ⊔ ν).cells = μ.cells ∪ ν.cells
-- Mathlib/LinearAlgebra/BilinearForm/Hom.lean
@[simp]
theorem congr_refl : congr (LinearEquiv.refl R M) = LinearEquiv.refl R _
-- Mathlib/MeasureTheory/Measure/Dirac.lean
/-- Dirac delta measures at two points are equal if and only if the two points are equal,
assuming the measurable space separates points. -/
lemma dirac_eq_dirac_iff [SeparatesPoints α] {x y : α} :
    Measure.dirac x = Measure.dirac y ↔ x = y
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem split_add_lt {o e n a m} [NF o] (h : split o = (oadd e n a, m)) :
    repr a + m < ω ^ repr e
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem HasStrictDerivAt.hasDerivAt (h : HasStrictDerivAt f f' x) : HasDerivAt f f' x
-- Mathlib/CategoryTheory/Linear/LinearFunctor.lean
@[simp]
theorem map_units_smul {X Y : C} (r : Rˣ) (f : X ⟶ Y) : F.map (r • f) = r • F.map f
-- Mathlib/RepresentationTheory/Rep.lean
@[simp] theorem ofDistribMulAction_ρ_apply_apply (g : G) (a : A) :
    (ofDistribMulAction k G A).ρ g a = g • a
-- Mathlib/Order/Filter/Interval.lean
protected theorem Tendsto.Ico {l₁ l₂ : Filter α} [TendstoIxxClass Ico l₁ l₂] {lb : Filter β}
    {u₁ u₂ : β → α} (h₁ : Tendsto u₁ lb l₁) (h₂ : Tendsto u₂ lb l₁) :
    Tendsto (fun x => Ico (u₁ x) (u₂ x)) lb l₂.smallSets
-- Mathlib/Order/Cover.lean
@[simp]
theorem toDual_wcovBy_toDual_iff : toDual b ⩿ toDual a ↔ a ⩿ b
-- Mathlib/Order/Interval/Basic.lean
@[norm_cast] -- @[simp, norm_cast] -- Porting note: not in simpNF
theorem coe_inj {s t : NonemptyInterval α} : (s : Interval α) = t ↔ s = t
-- Mathlib/Analysis/SpecialFunctions/Log/ENNRealLog.lean
@[simp] lemma zero_le_log_iff {x : ℝ≥0∞} : 0 ≤ log x ↔ 1 ≤ x
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem sub_lt_sub_right {a b : Int} (h : a < b) (c : Int) : a - c < b - c
-- Mathlib/SetTheory/Ordinal/Exponential.lean
theorem div_opow_log_pos (b : Ordinal) {o : Ordinal} (ho : o ≠ 0) : 0 < o / (b ^ log b o)
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
@[to_additive sum_strictMono]
theorem prod_strictMono' : StrictMono fun f : ι → M ↦ ∏ x, f x
-- Mathlib/Order/Lattice.lean
theorem SemilatticeInf.dual_dual (α : Type*) [H : SemilatticeInf α] :
    OrderDual.instSemilatticeInf αᵒᵈ = H
-- Mathlib/SetTheory/Game/PGame.lean
/-- Inserting on the left and right commutes. -/
theorem insertRight_insertLeft {x x' x'' : PGame} :
    insertRight (insertLeft x x') x'' = insertLeft (insertRight x x'') x'
-- Mathlib/CategoryTheory/Functor/Currying.lean
lemma flip_injective {F₁ F₂ : B ⥤ C ⥤ D} (h : F₁.flip = F₂.flip) :
    F₁ = F₂
-- Mathlib/Topology/Compactness/SigmaCompact.lean
/-- Compact sets are σ-compact. -/
lemma IsCompact.isSigmaCompact {s : Set X} (hs : IsCompact s) : IsSigmaCompact s
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
@[simp]
theorem inv_whiskerLeft (f : a ⟶ b) {g h : b ⟶ c} (η : g ⟶ h) [IsIso η] :
    inv (f ◁ η) = f ◁ inv η
-- Mathlib/CategoryTheory/Limits/VanKampen.lean
theorem IsUniversalColimit.whiskerEquivalence {K : Type*} [Category K] (e : J ≌ K)
    {F : K ⥤ C} {c : Cocone F} (hc : IsUniversalColimit c) :
    IsUniversalColimit (c.whisker e.functor)
-- Mathlib/Combinatorics/SimpleGraph/Finite.lean
theorem deleteFar_iff :
    G.DeleteFar p r ↔ ∀ ⦃H : SimpleGraph _⦄ [DecidableRel H.Adj],
      H ≤ G → p H → r ≤ G.edgeFinset.card - H.edgeFinset.card
-- Mathlib/Topology/Basic.lean
theorem compl_frontier_eq_union_interior :
    (frontier s)ᶜ = interior s ∪ interior sᶜ
-- Mathlib/Order/CompleteLattice.lean
@[simp]
theorem iSup_eq_bot : iSup s = ⊥ ↔ ∀ i, s i = ⊥
-- Mathlib/Data/Bool/Set.lean
@[simp]
theorem univ_eq : (univ : Set Bool) = {false, true}
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem mfderivWithin_snd {s : Set (M × M')} {x : M × M'}
    (hxs : UniqueMDiffWithinAt (I.prod I') s x) :
    mfderivWithin (I.prod I') I' Prod.snd s x =
      ContinuousLinearMap.snd 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2)
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
protected theorem coe_eq_zero {x : S} : (x : A) = 0 ↔ x = 0
-- Mathlib/Algebra/Periodic.lean
theorem Antiperiodic.const_smul₀ [AddCommMonoid α] [Neg β] [DivisionSemiring γ] [Module γ α]
    (h : Antiperiodic f c) {a : γ} (ha : a ≠ 0) : Antiperiodic (fun x => f (a • x)) (a⁻¹ • c)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem real_inner_self_eq_norm_mul_norm (x : F) : ⟪x, x⟫_ℝ = ‖x‖ * ‖x‖
-- Mathlib/Data/Set/Basic.lean
lemma disjoint_or_nonempty_inter (s t : Set α) : Disjoint s t ∨ (s ∩ t).Nonempty
-- Mathlib/Order/LiminfLimsup.lean
theorem liminf_eq_sSup_sInf {ι R : Type*} (F : Filter ι) [CompleteLattice R] (a : ι → R) :
    liminf a F = sSup ((fun I => sInf (a '' I)) '' F.sets)
-- Mathlib/Algebra/Order/Ring/Unbundled/Nonneg.lean
@[simp]
theorem mk_natCast (n : ℕ) : (⟨n, n.cast_nonneg'⟩ : { x : α // 0 ≤ x }) = n
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
/-- If the tangent of a complex number is well-defined,
then it is equal to zero iff the number is equal to `k * π` for an integer `k`.

See also `Complex.tan_eq_zero_iff` for a version that takes into account junk values of `θ`. -/
theorem tan_eq_zero_iff' {θ : ℂ} (hθ : cos θ ≠ 0) : tan θ = 0 ↔ ∃ k : ℤ, k * π = θ
-- Mathlib/LinearAlgebra/Reflection.lean
lemma injOn_dualMap_subtype_span_range_range {ι : Type*} [NoZeroSMulDivisors ℤ M]
    {r : ι ↪ M} {c : ι → Dual R M} (hfin : (range r).Finite)
    (h_two : ∀ i, c i (r i) = 2)
    (h_mapsTo : ∀ i, MapsTo (preReflection (r i) (c i)) (range r) (range r)) :
    InjOn (span R (range r)).subtype.dualMap (range c)
-- Mathlib/GroupTheory/GroupAction/DomAct/Basic.lean
theorem smul_monoidHom_apply (c : Mᵈᵐᵃ) (f : A →* B) (a : A) : (c • f) a = f (mk.symm c • a)
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma smul_pos' [SMulPosStrictMono α β] (ha : 0 < a) (hb : 0 < b) : 0 < a • b
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem lTensor_comp_apply (x : M ⊗[R] N) :
    (g.comp f).lTensor M x = (g.lTensor M) ((f.lTensor M) x)
-- Mathlib/Data/Finite/Defs.lean
protected theorem Finite.false [Infinite α] (_ : Finite α) : False
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem Prime.mul_eq_prime_sq_iff {x y p : ℕ} (hp : p.Prime) (hx : x ≠ 1) (hy : y ≠ 1) :
    x * y = p ^ 2 ↔ x = p ∧ y = p
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Ioo_mem_nhds {a b x : α} (ha : a < x) (hb : x < b) : Ioo a b ∈ 𝓝 x
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
/-- `Polynomial.eval₂` as an `AlgHom` for noncommutative algebras.

This is `Polynomial.eval₂RingHom'` for `AlgHom`s. -/
@[simps!]
def eval₂AlgHom' (f : A →ₐ[R] B) (b : B) (hf : ∀ a, Commute (f a) b) : A[X] →ₐ[R] B
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
theorem addHaar_singleton_add_smul_div_singleton_add_smul {r : ℝ} (hr : r ≠ 0) (x y : E)
    (s t : Set E) : μ ({x} + r • s) / μ ({y} + r • t) = μ s / μ t
-- Mathlib/Topology/Homotopy/Path.lean
theorem coeFn_injective : @Function.Injective (Homotopy p₀ p₁) (I × I → X) (⇑)
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem rTensor_id_apply (x : N ⊗[R] M) : (LinearMap.id : N →ₗ[R] N).rTensor M x = x
-- Mathlib/LinearAlgebra/Dual.lean
theorem dualPairing_nondegenerate (W : Subspace K V₁) : W.dualPairing.Nondegenerate
-- Mathlib/GroupTheory/GroupAction/ConjAct.lean
theorem smul_eq_mulAut_conj (g : ConjAct G) (h : G) : g • h = MulAut.conj (ofConjAct g) h
-- Mathlib/Logic/Basic.lean
protected theorem Ne.dite_ne_left_iff (h : ∀ h, a ≠ B h) : dite P (fun _ ↦ a) B ≠ a ↔ ¬P
-- Mathlib/Algebra/Order/GroupWithZero/Canonical.lean
protected lemma le_max_iff : (a : WithZero α) ≤ max (b : WithZero α) c ↔ a ≤ max b c
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem lt_one_iff_zero {a : Ordinal} : a < 1 ↔ a = 0
-- Mathlib/Analysis/Fourier/FourierTransformDeriv.lean
/-- One can bound the `k`-th derivative of the Fourier integral of `f`, multiplied by `(L v w) ^ n`,
in terms of integrals of iterated derivatives of `f` (of order up to `n`) multiplied by `‖v‖ ^ i`
(for `i ≤ k`). -/
lemma pow_mul_norm_iteratedFDeriv_fourierIntegral_le [FiniteDimensional ℝ V]
    {μ : Measure V} [Measure.IsAddHaarMeasure μ] {K N : ℕ∞} (hf : ContDiff ℝ N f)
    (h'f : ∀ (k n : ℕ), k ≤ K → n ≤ N → Integrable (fun v ↦ ‖v‖^k * ‖iteratedFDeriv ℝ n f v‖) μ)
    {k n : ℕ} (hk : k ≤ K) (hn : n ≤ N) (v : V) (w : W) :
    |L v w| ^ n * ‖(iteratedFDeriv ℝ k (fourierIntegral 𝐞 μ L.toLinearMap₂ f)) w‖ ≤
      ‖v‖ ^ n * (2 * π * ‖L‖) ^ k * (2 * k + 2) ^ n *
        ∑ p in Finset.range (k + 1) ×ˢ Finset.range (n + 1),
          ∫ v, ‖v‖ ^ p.1 * ‖iteratedFDeriv ℝ p.2 f v‖ ∂μ
-- Mathlib/Algebra/Order/Interval/Set/Instances.lean
theorem coe_nonneg (x : Icc (0 : α) 1) : 0 ≤ (x : α)
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
theorem normSq_kahler (x y : E) : Complex.normSq (o.kahler x y) = ‖x‖ ^ 2 * ‖y‖ ^ 2
-- Mathlib/Geometry/Manifold/Sheaf/Smooth.lean
@[simp, reassoc, elementwise] lemma smoothSheafCommRing.ι_forgetStalk_inv (x : TopCat.of M) (U) :
    colimit.ι ((OpenNhds.inclusion x).op ⋙ (smoothSheaf IM I M R).presheaf) U ≫
    (smoothSheafCommRing.forgetStalk IM I M R x).inv =
    (forget CommRingCat).map
      (colimit.ι ((OpenNhds.inclusion x).op ⋙ (smoothSheafCommRing IM I M R).presheaf) U)
-- Mathlib/Topology/Algebra/ConstMulAction.lean
/-- Scalar multiplication preserves neighborhoods. -/
theorem set_smul_mem_nhds_smul {c : G₀} {s : Set α} {x : α} (hs : s ∈ 𝓝 x) (hc : c ≠ 0) :
    c • s ∈ 𝓝 (c • x : α)
-- Mathlib/Topology/Bases.lean
lemma IsSeparable.prod {β : Type*} [TopologicalSpace β]
    {s : Set α} {t : Set β} (hs : IsSeparable s) (ht : IsSeparable t) :
    IsSeparable (s ×ˢ t)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- An angle in a right-angled triangle expressed using `arctan`. -/
theorem oangle_add_right_eq_arctan_of_oangle_eq_pi_div_two {x y : V} (h : o.oangle x y = ↑(π / 2)) :
    o.oangle x (x + y) = Real.arctan (‖y‖ / ‖x‖)
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
theorem completeSpace_extension {m : β → α} (hm : UniformInducing m) (dense : DenseRange m)
    (h : ∀ f : Filter β, Cauchy f → ∃ x : α, map m f ≤ 𝓝 x) : CompleteSpace α
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem map_C : ∀ a : R, map f (C a : MvPolynomial σ R) = C (f a)
-- Mathlib/Order/Bounded.lean
theorem unbounded_le_univ [LE α] [NoTopOrder α] : Unbounded (· ≤ ·) (@Set.univ α)
-- Mathlib/Data/ENNReal/Operations.lean
@[simp]
protected theorem add_sub_cancel_left (ha : a ≠ ∞) : a + b - a = b
-- Mathlib/Data/ENNReal/Inv.lean
protected theorem inv_mul_cancel (h0 : a ≠ 0) (ht : a ≠ ∞) : a⁻¹ * a = 1
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
theorem mul_distrib_left (xs ys zs : IntList) : (xs + ys) * zs = xs * zs + ys * zs
-- Mathlib/Data/Real/Pointwise.lean
theorem Real.sSup_smul_of_nonpos (ha : a ≤ 0) (s : Set ℝ) : sSup (a • s) = a • sInf s
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem nonempty_Ici : (Ici a).Nonempty
-- Mathlib/Order/Hom/Basic.lean
theorem symm_injective : Function.Injective (symm : α ≃o β → β ≃o α)
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive]
theorem mul_left_cancel : a * b = a * c → b = c
-- Mathlib/Data/QPF/Univariate/Basic.lean
theorem Wequiv.refl (x : q.P.W) : Wequiv x x
-- Mathlib/Order/Irreducible.lean
theorem supPrime_iff_not_isMin : SupPrime a ↔ ¬IsMin a
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem smul_right {R : Type*} [Semiring R] [DistribMulAction R N] [ContinuousConstSMul R N]
    (r : R) (h : v ⟂ᵥ w) : v ⟂ᵥ r • w
-- Mathlib/Topology/MetricSpace/Thickening.lean
/-- The open thickening `Metric.thickening δ E` is contained in the closed thickening
`Metric.cthickening δ E` with the same radius. -/
theorem thickening_subset_cthickening (δ : ℝ) (E : Set α) : thickening δ E ⊆ cthickening δ E
-- Mathlib/Topology/Constructions.lean
theorem Continuous.subtype_map {f : X → Y} (h : Continuous f) {q : Y → Prop}
    (hpq : ∀ x, p x → q (f x)) : Continuous (Subtype.map f hpq)
-- Mathlib/Data/Analysis/Topology.lean
theorem ext' [T : TopologicalSpace α] {σ : Type*} {F : Ctop α σ}
    (H : ∀ a s, s ∈ 𝓝 a ↔ ∃ b, a ∈ F b ∧ F b ⊆ s) : F.toTopsp = T
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
@[simp]
theorem addHaar_preimage_smul {r : ℝ} (hr : r ≠ 0) (s : Set E) :
    μ ((r • ·) ⁻¹' s) = ENNReal.ofReal (abs (r ^ finrank ℝ E)⁻¹) * μ s
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
theorem integral_one : (∫ _ in a..b, (1 : ℝ)) = b - a
-- Mathlib/Data/TypeVec.lean
theorem const_append1 {β γ} (x : γ) {n} (α : TypeVec n) :
    TypeVec.const x (α ::: β) = appendFun (TypeVec.const x α) fun _ => x
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
theorem exi_rat_seq_conv_cauchy : IsCauSeq (padicNorm p) (limSeq f)
-- Mathlib/GroupTheory/Perm/Basic.lean
theorem swap_mul_swap_mul_swap {x y z : α} (hxy : x ≠ y) (hxz : x ≠ z) :
    swap y z * swap x y * swap y z = swap z x
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem coe_compRingHom_apply (p q : R[X]) : (compRingHom q : R[X] → R[X]) p = comp p q
-- Mathlib/CategoryTheory/MorphismProperty/Basic.lean
theorem arrow_iso_iff (P : MorphismProperty C) [RespectsIso P] {f g : Arrow C}
    (e : f ≅ g) : P f.hom ↔ P g.hom
-- Mathlib/Algebra/DirectSum/Module.lean
@[simp]
theorem IsInternal.ofBijective_coeLinearMap_same (h : IsInternal A)
    {i : ι} (x : A i) :
    (LinearEquiv.ofBijective (coeLinearMap A) h).symm x i = x
-- Mathlib/Topology/Algebra/Module/Basic.lean
theorem isOpenMap_mkQ [TopologicalAddGroup M] : IsOpenMap S.mkQ
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousWithinAt.fst {f : α → β × γ} {s : Set α} {a : α} (h : ContinuousWithinAt f s a) :
    ContinuousWithinAt (fun x => (f x).fst) s a
-- .lake/packages/lean4/src/lean/lake/Lake/Util/Compare.lean
/--
Proof that the equality of a compare function corresponds
to propositional equality and vice versa.
-/
class LawfulCmpEq (α : Type u) (cmp : α → α → Ordering) extends EqOfCmp α cmp where
  cmp_rfl {a : α} : cmp a a = .eq
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
@[simp]
theorem sub_im (z w : ℤ√d) : (z - w).im = z.im - w.im
-- Mathlib/Data/Nat/Prime/Defs.lean
theorem prime_five : Prime 5
-- Mathlib/Order/WithBot.lean
theorem ofDual_map (f : αᵒᵈ → βᵒᵈ) (a : WithBot αᵒᵈ) :
    WithBot.ofDual (WithBot.map f a) = map (ofDual ∘ f ∘ toDual) (WithBot.ofDual a)
-- Mathlib/Algebra/Star/Basic.lean
/-- `StarHomClass F R S` states that `F` is a type of `star`-preserving maps from `R` to `S`. -/
class StarHomClass (F : Type*) (R S : outParam Type*) [Star R] [Star S] [FunLike F R S] : Prop where
  /-- the maps preserve star -/
  map_star : ∀ (f : F) (r : R), f (star r) = star (f r)
-- Mathlib/LinearAlgebra/Basis.lean
theorem reindexFinsetRange_repr_self (i : ι) :
    b.reindexFinsetRange.repr (b i) =
      Finsupp.single ⟨b i, Finset.mem_image_of_mem b (Finset.mem_univ i)⟩ 1
-- Mathlib/Algebra/Order/Floor.lean
theorem pos_of_floor_pos (h : 0 < ⌊a⌋₊) : 0 < a
-- Mathlib/Algebra/Module/Torsion.lean
theorem torsionBySet_le_torsionBySet_of_subset {s t : Set R} (st : s ⊆ t) :
    torsionBySet R M t ≤ torsionBySet R M s
-- Mathlib/Algebra/MvPolynomial/Equiv.lean
lemma optionEquivRight_C (r : R) : optionEquivRight R S₁ (C r) = C (Polynomial.C r)
-- Mathlib/Algebra/Category/Ring/Constructions.lean
@[simp]
theorem pushoutCocone_inr :
    (pushoutCocone R A B).inr = Algebra.TensorProduct.includeRight.toRingHom (A := B)
-- Mathlib/RepresentationTheory/Basic.lean
theorem ofMulAction_single (g : G) (x : H) (r : k) :
    ofMulAction k G H g (Finsupp.single x r) = Finsupp.single (g • x) r
-- Mathlib/Algebra/Category/ModuleCat/Monoidal/Basic.lean
theorem associator_naturality {X₁ X₂ X₃ Y₁ Y₂ Y₃ : ModuleCat R} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂)
    (f₃ : X₃ ⟶ Y₃) :
    tensorHom (tensorHom f₁ f₂) f₃ ≫ (associator Y₁ Y₂ Y₃).hom =
      (associator X₁ X₂ X₃).hom ≫ tensorHom f₁ (tensorHom f₂ f₃)
-- Mathlib/AlgebraicGeometry/Scheme.lean
lemma toOpen_eq (U) :
    (by exact StructureSheaf.toOpen R U) =
    (ΓSpecIso R).inv ≫ (Spec R).presheaf.map (homOfLE le_top).op
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
theorem zeroLocus_sup_homogeneousIdeal (I J : HomogeneousIdeal 𝒜) :
    zeroLocus 𝒜 ((I ⊔ J : HomogeneousIdeal 𝒜) : Set A) = zeroLocus _ I ∩ zeroLocus _ J
-- Mathlib/AlgebraicGeometry/Gluing.lean
theorem fromGlued_injective : Function.Injective 𝒰.fromGlued.1.base
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
@[reassoc (attr := simp)]
lemma homologyι_naturality (φ : S₁ ⟶ S₂) [S₁.HasHomology] [S₂.HasHomology] :
    homologyMap φ ≫ S₂.homologyι = S₁.homologyι ≫ S₁.opcyclesMap φ
-- Mathlib/Topology/Algebra/Order/Field.lean
/-- In a linearly ordered field with the order topology, if `f` tends to `Filter.atBot` and `g`
tends to a negative constant `C` then `f * g` tends to `Filter.atTop`. -/
theorem Filter.Tendsto.atBot_mul_neg {C : 𝕜} (hC : C < 0) (hf : Tendsto f l atBot)
    (hg : Tendsto g l (𝓝 C)) : Tendsto (fun x => f x * g x) l atTop
-- Mathlib/Data/Vector/MapLemmas.lean
@[simp]
theorem map₂_map_right (f₁ : α → γ → ζ) (f₂ : β → γ) :
    map₂ f₁ xs (map f₂ ys) = map₂ (fun x y => f₁ x (f₂ y)) xs ys
-- Mathlib/RingTheory/MvPolynomial/Tower.lean
theorem aeval_algebraMap_eq_zero_iff_of_injective {x : σ → A} {p : MvPolynomial σ R}
    (h : Function.Injective (algebraMap A B)) :
    aeval (algebraMap A B ∘ x) p = 0 ↔ aeval x p = 0
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem comp_familyOfBFamily' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] {o}
    (ho : type r = o) (f : ∀ a < o, α) (g : α → β) :
    g ∘ familyOfBFamily' r ho f = familyOfBFamily' r ho fun i hi => g (f i hi)
-- Mathlib/RingTheory/Ideal/Basic.lean
@[ext]
theorem ext {I J : Ideal α} (h : ∀ x, x ∈ I ↔ x ∈ J) : I = J
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem ContMDiff.of_le (hf : ContMDiff I I' n f) (le : m ≤ n) : ContMDiff I I' m f
-- Mathlib/Topology/Algebra/Algebra.lean
theorem algebraMapCLM_toLinearMap : (algebraMapCLM R A).toLinearMap = Algebra.linearMap R A
-- Mathlib/GroupTheory/Perm/Closure.lean
theorem closure_prime_cycle_swap {σ τ : Perm α} (h0 : (Fintype.card α).Prime) (h1 : IsCycle σ)
    (h2 : σ.support = Finset.univ) (h3 : IsSwap τ) : closure ({σ, τ} : Set (Perm α)) = ⊤
-- Mathlib/Order/Filter/Prod.lean
theorem eventually_prod_principal_iff {p : α × β → Prop} {s : Set β} :
    (∀ᶠ x : α × β in f ×ˢ 𝓟 s, p x) ↔ ∀ᶠ x : α in f, ∀ y : β, y ∈ s → p (x, y)
-- Mathlib/Data/Set/Basic.lean
theorem union_eq_union_iff_left : s ∪ t = s ∪ u ↔ t ⊆ s ∪ u ∧ u ⊆ s ∪ t
-- Mathlib/Topology/MetricSpace/Thickening.lean
@[simp]
theorem mem_cthickening_iff : x ∈ cthickening δ s ↔ infEdist x s ≤ ENNReal.ofReal δ
-- Mathlib/Data/Complex/Basic.lean
theorem normSq_add (z w : ℂ) : normSq (z + w) = normSq z + normSq w + 2 * (z * conj w).re
-- Mathlib/Data/List/Enum.lean
theorem enum_map (l : List α) (f : α → β) : (l.map f).enum = l.enum.map (Prod.map id f)
-- Mathlib/Data/Seq/Computation.lean
@[simp]
theorem tail_think (s : Computation α) : tail (think s) = s