ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Adjunction/Limits.lean
/-- Transport a `HasLimitsOfShape` instance across an equivalence. -/
theorem hasLimitsOfShape_of_equivalence (E : D ⥤ C) [E.IsEquivalence] [HasLimitsOfShape J C] :
    HasLimitsOfShape J D
-- Mathlib/CategoryTheory/LiftingProperties/Basic.lean
theorem of_arrow_iso_right {A B X Y X' Y' : C} (i : A ⟶ B) {p : X ⟶ Y} {p' : X' ⟶ Y'}
    (e : Arrow.mk p ≅ Arrow.mk p') [hip : HasLiftingProperty i p] : HasLiftingProperty i p'
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
@[ext] theorem ext {e₁ e₂ : α ≃ᵐ β} (h : (e₁ : α → β) = e₂) : e₁ = e₂
-- Mathlib/Topology/Order/Category/AlexDisc.lean
@[simp] lemma forgetToTop_of (α : Type*) [TopologicalSpace α] [AlexandrovDiscrete α] :
  (forget₂ AlexDisc TopCat).obj (of α) = TopCat.of α
-- Mathlib/Tactic/CategoryTheory/MonoidalComp.lean
@[simps]
instance right' (X Y : C) [MonoidalCoherence X Y] :
    MonoidalCoherence X (Y ⊗ 𝟙_ C)
-- Mathlib/Geometry/Manifold/BumpFunction.lean
/-- The closures of supports of smooth bump functions centered at `c` form a basis of `𝓝 c`.
In other words, each of these closures is a neighborhood of `c` and each neighborhood of `c`
includes `tsupport f` for some `f : SmoothBumpFunction I c`. -/
theorem nhds_basis_tsupport :
    (𝓝 c).HasBasis (fun _ : SmoothBumpFunction I c => True) fun f => tsupport f
-- Mathlib/Data/Set/NAry.lean
theorem image2_inter_subset_right : image2 f s (t ∩ t') ⊆ image2 f s t ∩ image2 f s t'
-- Mathlib/Order/Cover.lean
/-- If `a`, `b`, `c` are consecutive and `a < x < c` then `x = b`. -/
theorem CovBy.eq_of_between {x : α} (hab : a ⋖ b) (hbc : b ⋖ c) (hax : a < x) (hxc : x < c) :
    x = b
-- Mathlib/MeasureTheory/Function/LpOrder.lean
theorem coeFn_abs (f : Lp E p μ) : ⇑|f| =ᵐ[μ] fun x => |f x|
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
/-- Given a function such that `f` and `x ^ (k + l) * f` are bounded for a suitable `l`, then
`x ^ k * f` is integrable. The bounds are not relevant for the integrability conclusion, but they
are relevant for bounding the integral in `integral_pow_mul_le_of_le_of_pow_mul_le`. We formulate
the two lemmas with the same set of assumptions for ease of applications. -/
lemma integrable_of_le_of_pow_mul_le
    {μ : Measure D} [μ.HasTemperateGrowth] {f : D → E} {C₁ C₂ : ℝ} {k : ℕ}
    (hf : ∀ x, ‖f x‖ ≤ C₁) (h'f : ∀ x, ‖x‖ ^ (k + μ.integrablePower) * ‖f x‖ ≤ C₂)
    (h''f : AEStronglyMeasurable f μ) :
    Integrable (fun x ↦ ‖x‖ ^ k * ‖f x‖) μ
-- Mathlib/Topology/Compactification/OnePoint.lean
theorem isOpenMap_coe : IsOpenMap ((↑) : X → OnePoint X)
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
@[simp]
theorem if_false_left [h : Decidable p] :
    ite p False q ↔ ¬p ∧ q
-- Mathlib/RingTheory/PowerSeries/Order.lean
/-- The `0` power series is the unique power series with infinite order. -/
@[simp]
theorem order_eq_top {φ : R⟦X⟧} : φ.order = ⊤ ↔ φ = 0
-- Mathlib/LinearAlgebra/Matrix/PosDef.lean
theorem det_pos [DecidableEq n] {M : Matrix n n 𝕜} (hM : M.PosDef) : 0 < det M
-- Mathlib/GroupTheory/Coxeter/Basic.lean
/-- If two Coxeter systems on the same group `W` have the same Coxeter matrix `M : Matrix B B ℕ`
and the same simple reflection map `B → W`, then they are identical. -/
theorem simple_determines_coxeterSystem :
    Injective (simple : CoxeterSystem M W → B → W)
-- Mathlib/Algebra/Lie/Derivation/AdjointAction.lean
/-- The range of the adjoint action homomorphism from a Lie algebra `L` to the Lie algebra of its
derivations is an ideal of the latter. -/
lemma ad_isIdealMorphism : (ad R L).IsIdealMorphism
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem aecover_Ioi_of_Ici : AECover (μ.restrict (Ioi A)) l fun i ↦ Ici (a i)
-- Mathlib/CategoryTheory/Monoidal/Functor.lean
@[simp]
theorem prod'_μ (X Y : C) : (F.prod' G).μ X Y = (F.μ X Y, G.μ X Y)
-- Mathlib/Algebra/GroupWithZero/Hom.lean
lemma cancel_left {g : β →*₀ γ} {f₁ f₂ : α →*₀ β} (hg : Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂
-- Mathlib/Data/List/Basic.lean
theorem singleton_injective : Injective fun a : α => [a]
-- Mathlib/LinearAlgebra/Dimension/Localization.lean
/-- A domain that is not (left) Ore is of infinite rank.
See [cohn_1995] Proposition 1.3.6 -/
lemma aleph0_le_rank_of_isEmpty_oreSet (hS : IsEmpty (OreLocalization.OreSet R⁰)) :
    ℵ₀ ≤ Module.rank R R
-- Mathlib/Algebra/Algebra/Spectrum.lean
theorem mem_iff {r : R} {a : A} : r ∈ σ a ↔ ¬IsUnit (↑ₐ r - a)
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
theorem factorThruImage_eq {Δ Δ'' : SimplexCategory} {φ : Δ ⟶ Δ''} {e : Δ ⟶ image φ} [Epi e]
    {i : image φ ⟶ Δ''} [Mono i] (fac : e ≫ i = φ) : factorThruImage φ = e
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem toDualTopEquiv_symm_bot [LE α] : WithBot.toDualTopEquiv.symm (⊥ : (WithTop α)ᵒᵈ) = ⊥
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem mem_toAddSubmonoid {s : Subsemiring R} {x : R} : x ∈ s.toAddSubmonoid ↔ x ∈ s
-- Mathlib/Data/Rat/Cast/Order.lean
@[simp] lemma not_cast_lt_zero : ¬(q : K) < 0
-- Mathlib/Order/CompleteSublattice.lean
theorem range_coe : (f.range : Set β) = range f
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
theorem take_reverse {α} {xs : List α} (n : Nat) (h : n ≤ xs.length) :
    xs.reverse.take n = (xs.drop (xs.length - n)).reverse
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
@[measurability, fun_prop]
theorem Measurable.ereal_toReal {f : α → EReal} (hf : Measurable f) :
    Measurable fun x => (f x).toReal
-- Mathlib/Analysis/NormedSpace/OperatorNorm/NNNorm.lean
protected theorem lipschitz : LipschitzWith ‖(e : E →SL[σ₁₂] F)‖₊ e
-- Mathlib/Data/Nat/Lattice.lean
theorem sInf_add' {n : ℕ} {p : ℕ → Prop} (h : 0 < sInf { m | p m }) :
    sInf { m | p m } + n = sInf { m | p (m - n) }
-- Mathlib/LinearAlgebra/LinearIndependent.lean
/-- A set of linearly independent vectors in a module `M` over a semiring `K` is also linearly
independent over a subring `R` of `K`.
The implementation uses minimal assumptions about the relationship between `R`, `K` and `M`.
The version where `K` is an `R`-algebra is `LinearIndependent.restrict_scalars_algebras`.
 -/
theorem LinearIndependent.restrict_scalars [Semiring K] [SMulWithZero R K] [Module K M]
    [IsScalarTower R K M] (hinj : Function.Injective fun r : R => r • (1 : K))
    (li : LinearIndependent K v) : LinearIndependent R v
-- Mathlib/Topology/ContinuousFunction/Ordered.lean
@[simp] lemma inf_apply (f g : C(α, β)) (a : α) : (f ⊓ g) a = f a ⊓ g a
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem piecewise_ae_eq_restrict_compl [DecidablePred (· ∈ s)] (hs : MeasurableSet s) :
    piecewise s f g =ᵐ[μ.restrict sᶜ] g
-- Mathlib/RingTheory/HahnSeries/Addition.lean
@[simp]
lemma addOppositeEquiv_symm_support (x : (HahnSeries Γ R)ᵃᵒᵖ) :
    (addOppositeEquiv.symm x).support = x.unop.support
-- Mathlib/Order/Hom/Basic.lean
theorem comp_prod_comp_same (f₁ f₂ : β →o γ) (g : α →o β) :
    (f₁.comp g).prod (f₂.comp g) = (f₁.prod f₂).comp g
-- Mathlib/CategoryTheory/Sites/Discrete.lean
lemma constantCommuteComposeApp_comp_counit (F : Sheaf J A) :
    ((constantCommuteCompose J U).app _).hom ≫
      (constantSheafAdj J B ht).counit.app ((sheafCompose J U).obj F) =
        (sheafCompose J U).map ((constantSheafAdj J A ht).counit.app F)
-- Mathlib/FieldTheory/IsPerfectClosure.lean
theorem mem_pNilradical {R : Type*} [CommSemiring R] {p : ℕ} {x : R} :
    x ∈ pNilradical R p ↔ ∃ n : ℕ, x ^ p ^ n = 0
-- Mathlib/Topology/Separation.lean
theorem nhds_injective [T0Space X] : Injective (𝓝 : X → Filter X)
-- Mathlib/Data/Multiset/Basic.lean
theorem map_strictMono (f : α → β) : StrictMono (map f)
-- Mathlib/Topology/FiberBundle/Basic.lean
theorem trivializationAt_proj_fst {x : TotalSpace F E} :
    ((trivializationAt F E x.proj) x).1 = x.proj
-- Mathlib/Topology/Instances/Int.lean
@[simp]
theorem cobounded_eq : Bornology.cobounded ℤ = atBot ⊔ atTop
-- Mathlib/FieldTheory/PerfectClosure.lean
@[simp]
theorem mk_add_mk (x y : ℕ × K) :
    mk K p x + mk K p y =
      mk K p (x.1 + y.1, (frobenius K p)^[y.1] x.2 + (frobenius K p)^[x.1] y.2)
-- Mathlib/Order/SuccPred/Limit.lean
theorem IsPredLimit.pred_ne (h : IsPredLimit a) (b : α) : pred b ≠ a
-- Mathlib/Algebra/Category/ModuleCat/Differentials/Presheaf.lean
@[simp]
lemma relativeDifferentials'_obj (X : Dᵒᵖ) :
    (relativeDifferentials' φ').obj X =
      CommRingCat.KaehlerDifferential (φ'.app X)
-- Mathlib/Data/Set/Lattice.lean
theorem iUnion_inter_of_monotone {ι α} [Preorder ι] [IsDirected ι (· ≤ ·)] {s t : ι → Set α}
    (hs : Monotone s) (ht : Monotone t) : ⋃ i, s i ∩ t i = (⋃ i, s i) ∩ ⋃ i, t i
-- Mathlib/CategoryTheory/Comma/Presheaf.lean
/-- The defining property of `OverArrows.val`. -/
lemma app_val {F : Cᵒᵖ ⥤ Type v} {η : F ⟶ A} {X : C} {s : yoneda.obj X ⟶ A}
    (p : OverArrows η s) : η.app (op X) p.val = yonedaEquiv s
-- Mathlib/Tactic/LinearCombination.lean
theorem pf_add_c [Add α] (p : a = b) (c : α) : a + c = b + c
-- Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean
theorem Cotrident.IsColimit.hom_ext [Nonempty J] {s : Cotrident f} (hs : IsColimit s) {W : C}
    {k l : s.pt ⟶ W} (h : s.π ≫ k = s.π ≫ l) : k = l
-- Mathlib/Data/Nat/Defs.lean
lemma succ_le_iff : succ m ≤ n ↔ m < n
-- Mathlib/Data/Real/Hyperreal.lean
theorem not_infinite_add {x y : ℝ*} (hx : ¬Infinite x) (hy : ¬Infinite y) : ¬Infinite (x + y)
-- Mathlib/RingTheory/Localization/Basic.lean
theorem lift_spec_mul_add {g : R →+* P} (hg : ∀ y : M, IsUnit (g y)) (z w w' v) :
    ((toLocalizationWithZeroMap M S).lift g.toMonoidWithZeroHom hg) z * w + w' = v ↔
      g ((toLocalizationMap M S).sec z).1 * w + g ((toLocalizationMap M S).sec z).2 * w' =
        g ((toLocalizationMap M S).sec z).2 * v
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem nhds_basis_uniformity {p : ι → Prop} {s : ι → Set (α × α)} (h : (𝓤 α).HasBasis p s)
    {x : α} : (𝓝 x).HasBasis p fun i => { y | (y, x) ∈ s i }
-- Mathlib/RingTheory/DedekindDomain/SInteger.lean
theorem integer_eq :
    (S.integer K).toSubring =
      ⨅ (v) (_ : v ∉ S), (v : HeightOneSpectrum R).valuation.valuationSubring.toSubring
-- Mathlib/Combinatorics/SetFamily/Compression/UV.lean
/-- An element can be compressed to any other element by removing/adding the differences. -/
@[simp]
theorem compress_sdiff_sdiff (a b : α) : compress (a \ b) (b \ a) b = a
-- Mathlib/Algebra/Order/Field/Basic.lean
/-- For the single implications with fewer assumptions, see `one_div_lt_one_div_of_neg_of_lt` and
  `lt_of_one_div_lt_one_div` -/
theorem one_div_le_one_div_of_neg (ha : a < 0) (hb : b < 0) : 1 / a ≤ 1 / b ↔ b ≤ a
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem lTensorHomToHomLTensor_apply (p : P) (f : M →ₗ[R] Q) (m : M) :
    lTensorHomToHomLTensor R M P Q (p ⊗ₜ f) m = p ⊗ₜ f m
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
@[simp]
lemma preΨ_one : W.preΨ 1 = 1
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem single_mul_apply_aux [Add G] (f : k[G]) (r : k) (x y z : G)
    (H : ∀ a, x + a = y ↔ a = z) : (single x r * f) y = r * f z
-- Mathlib/Combinatorics/Quiver/Cast.lean
theorem eq_nil_of_length_zero {u v : U} (p : Path u v) (hzero : p.length = 0) :
    p.cast (eq_of_length_zero p hzero) rfl = Path.nil
-- Mathlib/Algebra/Star/CentroidHom.lean
@[simp]
lemma starCenterIsoCentroid_symm_apply_coe (T : CentroidHom α) :
    ↑(CentroidHom.starCenterIsoCentroid.symm T) = T 1
-- Mathlib/Algebra/Star/Subalgebra.lean
theorem map_le_iff_le_comap {S : StarSubalgebra R A} {f : A →⋆ₐ[R] B} {U : StarSubalgebra R B} :
    map f S ≤ U ↔ S ≤ comap f U
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem ContDiffOn.clm_comp {g : X → F →L[𝕜] G} {f : X → E →L[𝕜] F} {s : Set X}
    (hg : ContDiffOn 𝕜 n g s) (hf : ContDiffOn 𝕜 n f s) :
    ContDiffOn 𝕜 n (fun x => (g x).comp (f x)) s
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem map_singleton (f : α → β) (a : α) : map f [a] = [f a]
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem coe_le_coe_add_dist {f g : α →ᵇ ℝ} : f x ≤ g x + dist f g
-- Mathlib/Analysis/RCLike/Basic.lean
@[rclike_simps]
theorem zero_re' : re (0 : K) = (0 : ℝ)
-- Mathlib/GroupTheory/PGroup.lean
theorem bot_lt_center [Nontrivial G] [Finite G] : ⊥ < Subgroup.center G
-- Mathlib/Algebra/DirectLimit.lean
theorem of_f {i j} (hij) (x) : of G f j (f i j hij x) = of G f i x
-- Mathlib/Algebra/DirectSum/LinearMap.lean
lemma mapsTo_biSup_of_mapsTo (s : Set ι) {f : Module.End R M} (hf : ∀ i, MapsTo f (N i) (N i)) :
    MapsTo f ↑(⨆ i ∈ s, N i) ↑(⨆ i ∈ s, N i)
-- Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean
lemma IsRatCondKernelCDF.tendsto_atBot_zero (hf : IsRatCondKernelCDF f κ ν) (a : α) :
    ∀ᵐ b ∂(ν a), Tendsto (f (a, b)) atBot (𝓝 0)
-- Mathlib/Data/Matrix/ColumnRowPartitioned.lean
@[simp]
lemma toColumns₁_fromColumns (A₁ : Matrix m n₁ R) (A₂ : Matrix m n₂ R) :
    toColumns₁ (fromColumns A₁ A₂) = A₁
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
@[simp]
theorem map_eq_zero_iff [Nontrivial R] : I.map h = 0 ↔ I = 0
-- Mathlib/CategoryTheory/Functor/KanExtension/Basic.lean
lemma isLeftKanExtension_iff_isIso {F' : D ⥤ H} {F'' : D ⥤ H} (φ : F' ⟶ F'')
    {L : C ⥤ D} {F : C ⥤ H} (α : F ⟶ L ⋙ F') (α' : F ⟶ L ⋙ F'')
    (comm : α ≫ whiskerLeft L φ = α') [F'.IsLeftKanExtension α] :
    F''.IsLeftKanExtension α' ↔ IsIso φ
-- Mathlib/Topology/Order/LeftRightLim.lean
/-- A monotone function is continuous to the left at a point if and only if its left limit
coincides with the value of the function. -/
theorem continuousWithinAt_Iio_iff_leftLim_eq :
    ContinuousWithinAt f (Iio x) x ↔ leftLim f x = f x
-- Mathlib/CategoryTheory/Limits/EpiMono.lean
lemma epi_iff_inl_eq_inr (hc : IsColimit c) : Epi f ↔ c.inl = c.inr
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Cospan.lean
@[simp]
theorem spanExt_app_one : (spanExt iX iY iZ wf wg).app WalkingSpan.zero = iX
-- Mathlib/Data/Opposite.lean
@[simp]
theorem unop_inj_iff (x y : αᵒᵖ) : unop x = unop y ↔ x = y
-- Mathlib/RingTheory/Valuation/Basic.lean
@[simp]
theorem map_zero : v 0 = (⊤ : Γ₀)
-- Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean
@[simp]
theorem coeff_fslope : p.fslope.coeff n = p.coeff (n + 1)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Div.lean
theorem mod_eq_sub_mod {a b : Nat} (h : a ≥ b) : a % b = (a - b) % b
-- Mathlib/Data/Fin/Tuple/Basic.lean
theorem comp_tail {α : Type*} {β : Type*} (g : α → β) (q : Fin n.succ → α) :
    g ∘ tail q = tail (g ∘ q)
-- Mathlib/Data/Finset/Lattice.lean
theorem isLeast_min' : IsLeast (↑s) (s.min' H)
-- Mathlib/Algebra/Category/ModuleCat/Images.lean
theorem image.lift_fac (F' : MonoFactorisation f) : image.lift F' ≫ F'.m = image.ι f
-- Mathlib/Topology/UnitInterval.lean
theorem le_one (x : I) : (x : ℝ) ≤ 1
-- Mathlib/MeasureTheory/Function/LpSpace.lean
@[norm_cast]
theorem coe_posPart (f : Lp ℝ p μ) : (posPart f : α →ₘ[μ] ℝ) = (f : α →ₘ[μ] ℝ).posPart
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[reassoc]
theorem coprod.map_comp_id {X Y Z W : C} (f : X ⟶ Y) (g : Y ⟶ Z) [HasBinaryCoproduct Z W]
    [HasBinaryCoproduct Y W] [HasBinaryCoproduct X W] :
    coprod.map (f ≫ g) (𝟙 W) = coprod.map f (𝟙 W) ≫ coprod.map g (𝟙 W)
-- Mathlib/CategoryTheory/Sites/Coherent/SheafComparison.lean
theorem isSheaf_coherent_iff_regular_and_extensive [Preregular C] [FinitaryPreExtensive C] :
    IsSheaf (coherentTopology C) F ↔
    IsSheaf (extensiveTopology C) F ∧ IsSheaf (regularTopology C) F
-- Mathlib/Combinatorics/Configuration.lean
theorem HasPoints.existsUnique_point [HasPoints P L] (l₁ l₂ : L) (hl : l₁ ≠ l₂) :
    ∃! p, p ∈ l₁ ∧ p ∈ l₂
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
@[simp]
theorem LinearMap.coe_isometryOfInner (f : E →ₗ[𝕜] E') (h) : ⇑(f.isometryOfInner h) = f
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[simp]
theorem closure_submonoid_closure (s : Set R) : closure ↑(Submonoid.closure s) = closure s
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
@[simp]
theorem self_le_sinh_iff : x ≤ sinh x ↔ 0 ≤ x
-- Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean
theorem parallelepiped_eq_sum_segment (v : ι → E) : parallelepiped v = ∑ i, segment ℝ 0 (v i)
-- Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean
@[simp]
theorem map_map (f : R →+* S) (g : S →+* T) (x : ResidueField R) [IsLocalRingHom f]
    [IsLocalRingHom g] : map g (map f x) = map (g.comp f) x
-- Mathlib/Data/Finset/Sups.lean
lemma biUnion_image_sup_left : s.biUnion (fun a ↦ t.image (a ⊔ ·)) = s ⊻ t
-- Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean
lemma isCondKernelCDF_stieltjesOfMeasurableRat {f : α × β → ℚ → ℝ} (hf : IsRatCondKernelCDF f κ ν)
    [IsFiniteKernel κ] :
    IsCondKernelCDF (stieltjesOfMeasurableRat f hf.measurable) κ ν
-- Mathlib/Order/SuccPred/Basic.lean
/-- A `PredOrder` is pred-archimedean if one can go from any two comparable elements by iterating
`pred` -/
class IsPredArchimedean (α : Type*) [Preorder α] [PredOrder α] : Prop where
  /-- If `a ≤ b` then one can get to `b` from `a` by iterating `pred` -/
  exists_pred_iterate_of_le {a b : α} (h : a ≤ b) : ∃ n, pred^[n] b = a
-- Mathlib/MeasureTheory/Integral/DominatedConvergence.lean
theorem tsum_intervalIntegral_eq_of_summable_norm [Countable ι] {f : ι → C(ℝ, E)}
    (hf_sum : Summable fun i : ι => ‖(f i).restrict (⟨uIcc a b, isCompact_uIcc⟩ : Compacts ℝ)‖) :
    ∑' i : ι, ∫ x in a..b, f i x = ∫ x in a..b, ∑' i : ι, f i x
-- Mathlib/SetTheory/Cardinal/Finite.lean
theorem card_eq_two_iff' (x : α) : Nat.card α = 2 ↔ ∃! y, y ≠ x
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp, norm_cast] lemma coe_add (a b : α) : ↑(a + b) = (a + b : WithTop α)
-- Mathlib/Topology/Inseparable.lean
theorem subtype_specializes_iff {p : X → Prop} (x y : Subtype p) : x ⤳ y ↔ (x : X) ⤳ y
-- Mathlib/Algebra/Polynomial/Splits.lean
theorem splits_mul {f g : K[X]} (hf : Splits i f) (hg : Splits i g) : Splits i (f * g)
-- Mathlib/Algebra/Algebra/Hom.lean
@[simp]
theorem toLinearMap_ofLinearMap (f : A →ₗ[R] B) (map_one) (map_mul) :
    toLinearMap (ofLinearMap f map_one map_mul) = f
-- Mathlib/Topology/Order/NhdsSet.lean
theorem Ico_mem_nhdsSet_Ioc (h : a ≤ b) (h' : c < d) : Ico a d ∈ 𝓝ˢ (Ioc b c)
-- Mathlib/Algebra/Module/LocalizedModule.lean
theorem iso_symm_comp : (iso S f).symm.toLinearMap.comp f = LocalizedModule.mkLinearMap S M
-- Mathlib/Analysis/Normed/Field/Basic.lean
/-- A non-unital normed commutative ring is a non-unital commutative ring endowed with a
norm which satisfies the inequality `‖x y‖ ≤ ‖x‖ ‖y‖`. -/
class NonUnitalNormedCommRing (α : Type*) extends NonUnitalNormedRing α where
  /-- Multiplication is commutative. -/
  mul_comm : ∀ x y : α, x * y = y * x
-- Mathlib/Data/Real/Hyperreal.lean
theorem InfinitePos.neg {x : ℝ*} : InfinitePos x → InfiniteNeg (-x)
-- Mathlib/Data/Part.lean
/-- `Part` extensionality -/
theorem ext' : ∀ {o p : Part α}, (o.Dom ↔ p.Dom) → (∀ h₁ h₂, o.get h₁ = p.get h₂) → o = p
-- Mathlib/LinearAlgebra/Matrix/ZPow.lean
theorem zpow_neg {A : M} (h : IsUnit A.det) : ∀ n : ℤ, A ^ (-n) = (A ^ n)⁻¹
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
@[simp] theorem length_zip (l₁ : List α) (l₂ : List β) :
    length (zip l₁ l₂) = min (length l₁) (length l₂)
-- Mathlib/LinearAlgebra/QuadraticForm/Prod.lean
theorem posDef_prod_iff [PartialOrder P] [CovariantClass P P (· + ·) (· ≤ ·)]
    {Q₁ : QuadraticMap R M₁ P} {Q₂ : QuadraticMap R M₂ P} :
    (Q₁.prod Q₂).PosDef ↔ Q₁.PosDef ∧ Q₂.PosDef
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem bot_eq_empty : (⊥ : Finset α) = ∅
-- Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean
@[simp]
theorem ι_range_map_reverse :
    (ι Q).range.map (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q)
      = LinearMap.range (ι Q)
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp]
theorem add_top (a : WithTop α) : a + ⊤ = ⊤
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] protected theorem le_true : ∀ (x : Bool), x ≤ true
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem div_lt_one (hb : 0 < b) : a / b < 1 ↔ a < b
-- Mathlib/LinearAlgebra/TensorProduct/DirectLimit.lean
@[simp] lemma fromDirectLimit_of_tmul {i : ι} (g : G i) (m : M) :
    fromDirectLimit f M (of _ _ _ _ i (g ⊗ₜ m)) = (of _ _ _ f i g) ⊗ₜ m
-- Mathlib/Algebra/Category/HopfAlgebraCat/Basic.lean
@[simp] theorem toHopfAlgEquiv_refl : toHopfAlgEquiv (.refl X) = .refl _ _
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
protected theorem union_null (hs : NullMeasurableSet s μ) (ht : μ t = 0) :
    NullMeasurableSet (s ∪ t) μ
-- Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean
lemma hurwitzEvenFEPair_neg (a : UnitAddCircle) : hurwitzEvenFEPair (-a) = hurwitzEvenFEPair a
-- Mathlib/LinearAlgebra/LinearIndependent.lean
lemma LinearIndependent.eq_of_pair {x y : M} (h : LinearIndependent R ![x, y])
    {s t s' t' : R} (h' : s • x + t • y = s' • x + t' • y) : s = s' ∧ t = t'
-- Mathlib/Algebra/Ring/Prod.lean
/-- Four-way commutativity of `Prod`. The name matches `mul_mul_mul_comm`. -/
@[simps apply]
def prodProdProdComm : (R × R') × S × S' ≃+* (R × S) × R' × S'
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem equiv_toFun_eq_eval : (equiv_range C).toFun = Set.rangeFactorization (eval C)
-- Mathlib/Data/Fin/Basic.lean
@[simp]
theorem castSucc_castPred (i : Fin (n + 1)) (h : i ≠ last n) :
    castSucc (i.castPred h) = i
-- Mathlib/LinearAlgebra/Dual.lean
@[simp]
theorem coeffs_apply [DecidableEq ι] (h : DualBases e ε) (m : M) (i : ι) : h.coeffs m i = ε i m
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
@[simp]
lemma image_preimage (e : α ≃ᵐ β) (s : Set β) : e '' (e ⁻¹' s) = s
-- Mathlib/Algebra/Order/Hom/Monoid.lean
@[simp]
theorem comp_apply (f : β →*₀o γ) (g : α →*₀o β) (a : α) : (f.comp g) a = f (g a)
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem uIcc_subset_uIcc (h₁ : a₁ ∈ [[a₂, b₂]]) (h₂ : b₁ ∈ [[a₂, b₂]]) :
    [[a₁, b₁]] ⊆ [[a₂, b₂]]
-- Mathlib/Analysis/SpecificLimits/Normed.lean
theorem isLittleO_pow_pow_of_lt_left {r₁ r₂ : ℝ} (h₁ : 0 ≤ r₁) (h₂ : r₁ < r₂) :
    (fun n : ℕ ↦ r₁ ^ n) =o[atTop] fun n ↦ r₂ ^ n
-- Mathlib/Analysis/Analytic/Basic.lean
theorem changeOriginSeries_summable_aux₁ {r r' : ℝ≥0} (hr : (r + r' : ℝ≥0∞) < p.radius) :
    Summable fun s : Σk l : ℕ, { s : Finset (Fin (k + l)) // s.card = l } =>
      ‖p (s.1 + s.2.1)‖₊ * r ^ s.2.1 * r' ^ s.1
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean
lemma mk_surjective : Function.Surjective (mk (𝒜 := 𝒜) (x := x))
-- Mathlib/SetTheory/Ordinal/Principal.lean
theorem principal_add_of_le_one {o : Ordinal} (ho : o ≤ 1) : Principal (· + ·) o
-- Mathlib/RingTheory/Perfection.lean
theorem hom_ext {R : Type u₁} [CommSemiring R] [CharP R p] [PerfectRing R p] {S : Type u₂}
    [CommSemiring S] [CharP S p] {f g : R →+* Ring.Perfection S p}
    (hfg : ∀ x, coeff S p 0 (f x) = coeff S p 0 (g x)) : f = g
-- Mathlib/Data/Finset/Fold.lean
theorem fold_op_distrib {f g : α → β} {b₁ b₂ : β} :
    (s.fold op (b₁ * b₂) fun x => f x * g x) = s.fold op b₁ f * s.fold op b₂ g
-- Mathlib/Control/Basic.lean
@[functor_norm]
theorem fish_assoc {α β γ φ} (f : α → m β) (g : β → m γ) (h : γ → m φ) :
    (f >=> g) >=> h = f >=> g >=> h
-- Mathlib/Order/SuccPred/Basic.lean
@[simp]
theorem le_pred_iff : a ≤ pred b ↔ a < b
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
theorem measurableSet_eq_fun_of_countable {m : MeasurableSpace α} {E} [MeasurableSpace E]
    [MeasurableSingletonClass E] [Countable E] {f g : α → E} (hf : Measurable f)
    (hg : Measurable g) : MeasurableSet { x | f x = g x }
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem forall_congr' (h : ∀ a, p a ↔ q a) : (∀ a, p a) ↔ ∀ a, q a
-- Mathlib/Data/Set/Basic.lean
theorem disjoint_right : Disjoint s t ↔ ∀ ⦃a⦄, a ∈ t → a ∉ s
-- Mathlib/Analysis/Normed/Group/Hom.lean
theorem comp_assoc {V₄ : Type*} [SeminormedAddCommGroup V₄] (h : NormedAddGroupHom V₃ V₄)
    (g : NormedAddGroupHom V₂ V₃) (f : NormedAddGroupHom V₁ V₂) :
    (h.comp g).comp f = h.comp (g.comp f)
-- Mathlib/Data/Nat/Factorization/Defs.lean
/-- We can write both `n.factorization p` and `n.factors.count p` to represent the power
of `p` in the factorization of `n`: we declare the former to be the simp-normal form. -/
@[simp]
theorem primeFactorsList_count_eq {n p : ℕ} : n.primeFactorsList.count p = n.factorization p
-- Mathlib/Combinatorics/Colex.lean
/-- Initial segments are nested in some way. In particular, if they're the same size they're equal.
-/
lemma IsInitSeg.total (h₁ : IsInitSeg 𝒜₁ r) (h₂ : IsInitSeg 𝒜₂ r) : 𝒜₁ ⊆ 𝒜₂ ∨ 𝒜₂ ⊆ 𝒜₁