ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
@[simp]
theorem translationNumber_zpow (f : CircleDeg1Liftˣ) : ∀ n : ℤ, τ (f ^ n : Units _) = n * τ f
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem measure_sUnion {S : Set (Set α)} (hs : S.Countable) (hd : S.Pairwise Disjoint)
    (h : ∀ s ∈ S, MeasurableSet s) : μ (⋃₀ S) = ∑' s : S, μ s
-- Mathlib/Data/Finset/Sups.lean
theorem infs_subset_right : s₁ ⊆ s₂ → s₁ ⊼ t ⊆ s₂ ⊼ t
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem ae_eq_of_ae_subset_of_measure_ge (h₁ : s ≤ᵐ[μ] t) (h₂ : μ t ≤ μ s) (hsm : MeasurableSet s)
    (ht : μ t ≠ ∞) : s =ᵐ[μ] t
-- Mathlib/Order/SuccPred/Basic.lean
lemma succ_lt_succ_of_not_isMax (h : a < b) (hb : ¬ IsMax b) : succ a < succ b
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem norm_setToL1_le' (hT : DominatedFinMeasAdditive μ T C) : ‖setToL1 hT‖ ≤ max C 0
-- Mathlib/Data/List/Basic.lean
theorem monotone_filter_right (l : List α) ⦃p q : α → Bool⦄
    (h : ∀ a, p a → q a) : l.filter p <+ l.filter q
-- Mathlib/MeasureTheory/Integral/Average.lean
theorem ofReal_average {f : α → ℝ} (hf : Integrable f μ) (hf₀ : 0 ≤ᵐ[μ] f) :
    ENNReal.ofReal (⨍ x, f x ∂μ) = (∫⁻ x, ENNReal.ofReal (f x) ∂μ) / μ univ
-- Mathlib/Algebra/Associated/Basic.lean
protected theorem Associated.prime [CommMonoidWithZero α] {p q : α} (h : p ~ᵤ q) (hp : Prime p) :
    Prime q
-- Mathlib/Algebra/GradedMulAction.lean
theorem SetLike.Homogeneous.graded_smul [VAdd ιA ιB] [SMul R M] {A : ιA → S} {B : ιB → N}
    [SetLike.GradedSMul A B] {a : R} {b : M} :
    SetLike.Homogeneous A a → SetLike.Homogeneous B b → SetLike.Homogeneous B (a • b)
-- Mathlib/Algebra/Free.lean
@[to_additive (attr := simp)]
theorem mul_bind (f : α → FreeMagma β) (x y : FreeMagma α) : x * y >>= f = (x >>= f) * (y >>= f)
-- Mathlib/Algebra/Category/Grp/ForgetCorepresentable.lean
/-- The equivalence `(ℤ →+ α) ≃ α` for any additive group `α`. -/
@[simps]
def fromIntEquiv (α : Type u) [AddGroup α] : (ℤ →+ α) ≃ α
-- Mathlib/Analysis/InnerProductSpace/Symmetric.lean
/-- A linear operator on a complex inner product space is symmetric precisely when
`⟪T v, v⟫_ℂ` is real for all v. -/
theorem isSymmetric_iff_inner_map_self_real (T : V →ₗ[ℂ] V) :
    IsSymmetric T ↔ ∀ v : V, conj ⟪T v, v⟫_ℂ = ⟪T v, v⟫_ℂ
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
protected theorem inv_eq_of_mul_eq_one_left {a : α} (h : a * u = 1) : ↑u⁻¹ = a
-- Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
/-- If `b` is odd, then `J(-1 | b)` is given by `χ₄ b`. -/
theorem at_neg_one {b : ℕ} (hb : Odd b) : J(-1 | b) = χ₄ b
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem toL1_neg (f : α → β) (hf : Integrable f μ) : toL1 (-f) (Integrable.neg hf) = -toL1 f hf
-- Mathlib/Algebra/Group/Indicator.lean
/-- If a multiplicative indicator function is not equal to `1` at a point, then that point is in the
set. -/
@[to_additive
      "If an additive indicator function is not equal to `0` at a point, then that point is
      in the set."]
theorem mem_of_mulIndicator_ne_one (h : mulIndicator s f a ≠ 1) : a ∈ s
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
theorem tendsto_exp_nhds_zero_iff {α : Type*} {l : Filter α} {f : α → ℂ} :
    Tendsto (fun x => exp (f x)) l (𝓝 0) ↔ Tendsto (fun x => re (f x)) l atBot
-- .lake/packages/lean4/src/lean/Init/Control/Lawful/Instances.lean
@[simp] theorem run_monadLift [MonadLiftT n m] (x : n α) (ctx : ρ)
    : (monadLift x : ReaderT ρ m α).run ctx = (monadLift x : m α)
-- Mathlib/Algebra/Order/Group/Unbundled/Abs.lean
@[to_additive] lemma inv_lt_of_mabs_lt (h : |a|ₘ < b) : b⁻¹ < a
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem cond_eq_true_distrib : ∀(c t f : Bool),
    (cond c t f = true) = ite (c = true) (t = true) (f = true)
-- Mathlib/Topology/Defs/Sequences.lean
/-- A topological space is said to be a *sequential space* if any sequentially closed set in this
space is closed. This condition is weaker than being a Fréchet-Urysohn space. -/
class SequentialSpace : Prop where
  isClosed_of_seq : ∀ s : Set X, IsSeqClosed s → IsClosed s
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
theorem deriv_finset_prod (hf : ∀ i ∈ u, DifferentiableAt 𝕜 (f i) x) :
    deriv (∏ i ∈ u, f i ·) x = ∑ i ∈ u, (∏ j ∈ u.erase i, f j x) • deriv (f i) x
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
/-- An `n`-clique in a graph is a set of `n` vertices which are pairwise connected. -/
structure IsNClique (n : ℕ) (s : Finset α) : Prop where
  clique : G.IsClique s
  card_eq : s.card = n
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
/-- Version of `tprod_eq_mul_tprod_ite` for `CommMonoid` rather than `CommGroup`.
Requires a different convergence assumption involving `Function.update`. -/
@[to_additive "Version of `tsum_eq_add_tsum_ite` for `AddCommMonoid` rather than `AddCommGroup`.
Requires a different convergence assumption involving `Function.update`."]
theorem tprod_eq_mul_tprod_ite' [DecidableEq β] {f : β → α} (b : β)
    (hf : Multipliable (update f b 1)) :
    ∏' x, f x = f b * ∏' x, ite (x = b) 1 (f x)
-- Mathlib/Data/Finset/Fold.lean
theorem fold_disjUnion {s₁ s₂ : Finset α} {b₁ b₂ : β} (h) :
    (s₁.disjUnion s₂ h).fold op (b₁ * b₂) f = s₁.fold op b₁ f * s₂.fold op b₂ f
-- Mathlib/Analysis/Normed/Order/UpperLower.lean
lemma closure_lowerClosure_comm_pi (hs : BddAbove s) :
    closure (lowerClosure s : Set (ι → ℝ)) = lowerClosure (closure s)
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
theorem prod_norm_sq_eq_of_L2 (x : WithLp 2 (α × β)) : ‖x‖ ^ 2 = ‖x.fst‖ ^ 2 + ‖x.snd‖ ^ 2
-- Mathlib/GroupTheory/SpecificGroups/Cyclic.lean
@[to_additive]
theorem card_orderOf_eq_totient_aux₂ {d : ℕ} (hd : d ∣ Fintype.card α) :
    (univ.filter fun a : α => orderOf a = d).card = φ d
-- Mathlib/Topology/Order/Bornology.lean
protected lemma Bornology.IsBounded.bddBelow (hs : IsBounded s) : BddBelow s
-- Mathlib/Analysis/Calculus/FDeriv/Measurable.lean
theorem A_mono (L : E →L[𝕜] F) (r : ℝ) {ε δ : ℝ} (h : ε ≤ δ) : A f L r ε ⊆ A f L r δ
-- .lake/packages/batteries/Batteries/Logic.lean
theorem Function.funext_iff {β : α → Sort u} {f₁ f₂ : ∀ x : α, β x} : f₁ = f₂ ↔ ∀ a, f₁ a = f₂ a
-- Mathlib/LinearAlgebra/AffineSpace/Ordered.lean
/-- Given `c = lineMap a b r`, `a < c`, the point `(c, f c)` is strictly below the
segment `[(a, f a), (b, f b)]` if and only if `slope f a c < slope f a b`. -/
theorem map_lt_lineMap_iff_slope_lt_slope_left (h : 0 < r * (b - a)) :
    f c < lineMap (f a) (f b) r ↔ slope f a c < slope f a b
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- The orthogonal group of `F` is generated by reflections; specifically each element `φ` of the
orthogonal group is a product of at most as many reflections as the dimension of `F`.

Special case of the **Cartan–Dieudonné theorem**. -/
theorem LinearIsometryEquiv.reflections_generate_dim [FiniteDimensional ℝ F] (φ : F ≃ₗᵢ[ℝ] F) :
    ∃ l : List F, l.length ≤ finrank ℝ F ∧ φ = (l.map fun v => reflection (ℝ ∙ v)ᗮ).prod
-- Mathlib/Algebra/Ring/CentroidHom.lean
@[simp, norm_cast]
theorem coe_comp_addMonoidHom (g f : CentroidHom α) : (g.comp f : α →+ α) = (g : α →+ α).comp f
-- Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean
@[to_additive] lemma le_prod_of_mem (ha : a ∈ m) : a ≤ m.prod
-- Mathlib/Algebra/CubicDiscriminant.lean
@[simp]
theorem leadingCoeff_of_c_ne_zero' (hc : c ≠ 0) : (toPoly ⟨0, 0, c, d⟩).leadingCoeff = c
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
protected theorem IsCycle.cycleOf [DecidableEq α] (hf : IsCycle f) :
    cycleOf f x = if f x = x then 1 else f
-- Mathlib/NumberTheory/ArithmeticFunction.lean
/-- Möbius inversion for functions to a `Ring`. -/
theorem sum_eq_iff_sum_mul_moebius_eq [Ring R] {f g : ℕ → R} :
    (∀ n > 0, ∑ i ∈ n.divisors, f i = g n) ↔
      ∀ n > 0, ∑ x ∈ n.divisorsAntidiagonal, (μ x.fst : R) * g x.snd = f n
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem card_functions_sum (i : ℕ) :
    #((L.sum L').Functions i)
      = (Cardinal.lift.{u'} #(L.Functions i) + Cardinal.lift.{u} #(L'.Functions i) : Cardinal)
-- Mathlib/FieldTheory/Minpoly/Field.lean
theorem add_algebraMap {B : Type*} [CommRing B] [Algebra A B] {x : B} (hx : IsIntegral A x)
    (a : A) : minpoly A (x + algebraMap A B a) = (minpoly A x).comp (X - C a)
-- Mathlib/LinearAlgebra/Prod.lean
/-- `N` as a submodule of `M × N` is isomorphic to `N`. -/
@[simps]
def sndEquiv : Submodule.snd R M M₂ ≃ₗ[R] M₂
-- Mathlib/Topology/Order.lean
lemma tendsto_nhds_generateFrom_iff {β : Type*} {m : α → β} {f : Filter α} {g : Set (Set β)}
    {b : β} : Tendsto m f (@nhds β (generateFrom g) b) ↔ ∀ s ∈ g, b ∈ s → m ⁻¹' s ∈ f
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
private lemma toAffine_slope_of_eq {P Q : Fin 3 → F} (hP : W.Equation P) (hQ : W.Equation Q)
    (hPz : P z ≠ 0) (hQz : Q z ≠ 0) (hx : P x * Q z ^ 2 = Q x * P z ^ 2)
    (hy : P y * Q z ^ 3 ≠ W.negY Q * P z ^ 3) :
    W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3) =
      -W.dblU P / W.dblZ P
-- Mathlib/Topology/ContinuousFunction/ZeroAtInfty.lean
theorem copy_eq (f : C₀(α, β)) (f' : α → β) (h : f' = f) : f.copy f' h = f
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive (attr := simp, nolint simpNF)]
theorem mulEquivOfMulEquiv_eq {k : LocalizationMap T Q} {j : M ≃* P} (H : S.map j.toMonoidHom = T)
    (x) :
    f.mulEquivOfMulEquiv k H (f.toMap x) = k.toMap (j x)
-- Mathlib/Analysis/Convex/Join.lean
theorem convexJoin_segment_singleton (a b c : E) :
    convexJoin 𝕜 (segment 𝕜 a b) {c} = convexHull 𝕜 {a, b, c}
-- Mathlib/CategoryTheory/Opposites.lean
/-- An equivalence between categories gives an equivalence between the opposite categories.
-/
@[simps]
def op (e : C ≌ D) : Cᵒᵖ ≌ Dᵒᵖ
-- Mathlib/Algebra/Module/Equiv/Defs.lean
@[simp]
theorem coe_symm_mk [Module R M] [Module R M₂]
    {to_fun inv_fun map_add map_smul left_inv right_inv} :
    ⇑(⟨⟨⟨to_fun, map_add⟩, map_smul⟩, inv_fun, left_inv, right_inv⟩ : M ≃ₗ[R] M₂).symm = inv_fun
-- Mathlib/Data/Stream/Init.lean
theorem map_cons (a : α) (s : Stream' α) : map f (a::s) = f a::map f s
-- Mathlib/Data/Fin/Basic.lean
theorem rev_le_iff {i j : Fin n} : rev i ≤ j ↔ rev j ≤ i
-- Mathlib/Order/ULift.lean
@[simp] theorem down_sup [Sup α] (a b : ULift α) : down (a ⊔ b) = down a ⊔ down b
-- Mathlib/Analysis/Convex/Combination.lean
theorem mk_mem_convexHull_prod {t : Set F} {x : E} {y : F} (hx : x ∈ convexHull R s)
    (hy : y ∈ convexHull R t) : (x, y) ∈ convexHull R (s ×ˢ t)
-- Mathlib/Topology/Category/TopCat/Limits/Products.lean
theorem limit_topology (F : J ⥤ TopCat.{max v u}) :
    (limit F).str = ⨅ j, (F.obj j).str.induced (limit.π F j)
-- Mathlib/Data/Complex/Abs.lean
theorem re_le_abs (z : ℂ) : z.re ≤ Complex.abs z
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem integrable_average [IsFiniteMeasure μ] {f : α → β} :
    Integrable f ((μ univ)⁻¹ • μ) ↔ Integrable f μ
-- Mathlib/Data/Fin/Basic.lean
protected theorem zero_mul' [NeZero n] (k : Fin n) : (0 : Fin n) * k = 0
-- Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean
theorem dist_eq (z w : ℍ) : dist z w = 2 * arsinh (dist (z : ℂ) w / (2 * √(z.im * w.im)))
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
@[simp]
theorem factors_zero : factors (0 : α) = 0
-- Mathlib/CategoryTheory/Preadditive/Mat.lean
theorem comp_def {M N K : Mat R} (f : M ⟶ N) (g : N ⟶ K) :
    f ≫ g = fun i k => ∑ j : N, f i j * g j k
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
@[simp]
theorem bot_adj (v w : V) : (⊥ : SimpleGraph V).Adj v w ↔ False
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[deprecated getElem_eq_iff (since := "2024-06-12")]
theorem get_eq_iff : List.get l n = x ↔ l.get? n.1 = some x
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- Given three nonzero vectors, adding the angles between them in cyclic order results in 0. -/
@[simp]
theorem oangle_add_cyc3 {x y z : V} (hx : x ≠ 0) (hy : y ≠ 0) (hz : z ≠ 0) :
    o.oangle x y + o.oangle y z + o.oangle z x = 0
-- Mathlib/Data/Matrix/Basis.lean
@[simp]
theorem trace_eq : trace (stdBasisMatrix i i c) = c
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIcoMod_toIocMod (a₁ a₂ b : α) : toIcoMod hp a₁ (toIocMod hp a₂ b) = toIcoMod hp a₁ b
-- Mathlib/LinearAlgebra/TensorProduct/Graded/Internal.lean
@[simp]
theorem of_symm_one : (of R 𝒜 ℬ).symm 1 = 1
-- Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean
protected theorem mdifferentiableWithinAt {s x} : MDifferentiableWithinAt I 𝓘(𝕜, E) I s x
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nadd_eq_add (a b : Ordinal) : a ♯ b = toOrdinal (toNatOrdinal a + toNatOrdinal b)
-- Mathlib/Topology/Separation.lean
theorem TopologicalSpace.IsTopologicalBasis.inseparable_iff {b : Set (Set X)}
    (hb : IsTopologicalBasis b) {x y : X} : Inseparable x y ↔ ∀ s ∈ b, (x ∈ s ↔ y ∈ s)
-- Mathlib/SetTheory/Cardinal/Basic.lean
lemma mk_lt_aleph0_iff : #α < ℵ₀ ↔ Finite α
-- Mathlib/Algebra/Periodic.lean
theorem Antiperiodic.mul [Add α] [Mul β] [HasDistribNeg β] (hf : Antiperiodic f c)
    (hg : Antiperiodic g c) : Periodic (f * g) c
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem sub_one (n) : n - 1 = pred n
-- Mathlib/Topology/Algebra/ContinuousAffineMap.lean
@[norm_cast, simp]
theorem coe_smul (t : S) (f : P →ᴬ[R] W) : ⇑(t • f) = t • ⇑f
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
@[reassoc (attr := simp)]
lemma cyclesIso_hom_comp_i : h.cyclesIso.hom ≫ h.i = S.iCycles
-- Mathlib/Dynamics/PeriodicPts.lean
/-- `m ^ (period m a)` fixes `a`. -/
@[to_additive (attr := simp) "`(period m a) • m` fixes `a`."]
theorem pow_period_smul (m : M) (a : α) : m ^ (period m a) • a = a
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem uniformity_eq_uniformity_interior : 𝓤 α = (𝓤 α).lift' interior
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem coe_id : ⇑(FrameHom.id α) = id
-- Mathlib/Algebra/BigOperators/Finprod.lean
/-- If `f a = 1`, then the product of `f i` over `i ∈ insert a s` equals the product of `f i` over
`i ∈ s`. -/
@[to_additive
      "If `f a = 0`, then the sum of `f i` over `i ∈ insert a s` equals the sum of `f i`
      over `i ∈ s`."]
theorem finprod_mem_insert_one (h : f a = 1) : ∏ᶠ i ∈ insert a s, f i = ∏ᶠ i ∈ s, f i
-- Mathlib/Data/Nat/PartENat.lean
theorem dom_of_le_natCast {x : PartENat} {y : ℕ} (h : x ≤ y) : x.Dom
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
theorem subsingleton_of_subsingleton_span_eq_top {s : Set P} (h₁ : s.Subsingleton)
    (h₂ : affineSpan k s = ⊤) : Subsingleton P
-- Mathlib/Algebra/Order/Monovary.lean
lemma monovary_iff_forall_smul_nonneg : Monovary f g ↔ ∀ i j, 0 ≤ (f j - f i) • (g j - g i)
-- Mathlib/LinearAlgebra/Matrix/Basis.lean
@[simp]
theorem Basis.toMatrix_map (b : Basis ι R M) (f : M ≃ₗ[R] N) (v : ι → N) :
    (b.map f).toMatrix v = b.toMatrix (f.symm ∘ v)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp]
theorem set_set (a b : α) : ∀ (l : List α) (n : Nat), (l.set n a).set n b = l.set n b
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigOWith.const_smul_left (h : IsBigOWith c l f' g) (c' : R) :
    IsBigOWith (‖c'‖ * c) l (fun x => c' • f' x) g
-- Mathlib/CategoryTheory/EqToHom.lean
@[simp]
theorem eqToHom_unop {X Y : Cᵒᵖ} (h : X = Y) :
    (eqToHom h).unop = eqToHom (congr_arg unop h.symm)
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem rpow_pos_of_pos {x : ℝ} (hx : 0 < x) (y : ℝ) : 0 < x ^ y
-- Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean
/-- The forgetful functor from `LocallyRingedSpace` to `SheafedSpace CommRing`. -/
@[simps]
def forgetToSheafedSpace : LocallyRingedSpace.{u} ⥤ SheafedSpace CommRingCat.{u}
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[measurability]
protected theorem real_toNNReal {f : α → ℝ} (hf : AEStronglyMeasurable f μ) :
    AEStronglyMeasurable (fun x => (f x).toNNReal) μ
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_apply_ite_of_true {p : α → Prop} {hp : DecidablePred p} (f g : α → γ) (k : γ → β)
    (h : ∀ x ∈ s, p x) : (∏ x ∈ s, k (if p x then f x else g x)) = ∏ x ∈ s, k (f x)
-- Mathlib/Data/Set/Subsingleton.lean
theorem Subsingleton.eq_empty_or_singleton (hs : s.Subsingleton) : s = ∅ ∨ ∃ x, s = {x}
-- Mathlib/Data/Matroid/Closure.lean
lemma Basis.closure_eq_right (h : M.Basis I (M.closure X)) : M.closure I = M.closure X
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
@[nolint unusedHavesSuffices] -- false positive from unfolding String.foldlAux
theorem foldlAux_of_valid (f : α → Char → α) : ∀ l m r a,
    foldlAux f ⟨l ++ m ++ r⟩ ⟨utf8Len l + utf8Len m⟩ ⟨utf8Len l⟩ a = m.foldl f a
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem aeval_C (r : R) : aeval f (C r) = algebraMap R S₁ r
-- Mathlib/CategoryTheory/Sites/Sieves.lean
@[simp]
theorem functorPullback_id (R : Sieve X) : R.functorPullback (𝟭 _) = R
-- Mathlib/MeasureTheory/Measure/AEMeasurable.lean
@[measurability]
theorem add_measure {f : α → β} (hμ : AEMeasurable f μ) (hν : AEMeasurable f ν) :
    AEMeasurable f (μ + ν)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem sub_lt_right_of_lt_add {n k m : Nat} (H : n ≤ k) (h : k < m + n) : k - n < m
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.prod_left (hf : f' =o[l] k') (hg : g' =o[l] k') :
    (fun x => (f' x, g' x)) =o[l] k'
-- Mathlib/Algebra/Periodic.lean
theorem Antiperiodic.sub_eq' [AddCommGroup α] [Neg β] (h : Antiperiodic f c) :
    f (c - x) = -f (-x)
-- Mathlib/Logic/Basic.lean
/-- See `IsEmpty.forall_iff` for the `False` version. -/
@[simp] theorem forall_true_left (p : True → Prop) : (∀ x, p x) ↔ p True.intro
-- Mathlib/Tactic/CC/Lemmas.lean
theorem and_eq_of_eq_true_left {a b : Prop} (h : a = True) : (a ∧ b) = b
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
lemma ofJ0_Δ : (ofJ0 R).Δ = -27
-- Mathlib/Algebra/Lie/Solvable.lean
theorem derivedLength_eq_derivedLengthOfIdeal (I : LieIdeal R L) :
    derivedLength R I = derivedLengthOfIdeal R L I
-- Mathlib/Data/Num/Lemmas.lean
@[simp, norm_cast]
theorem cast_to_int {α} [AddGroupWithOne α] (n : Num) : ((n : ℤ) : α) = n
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem lt_of_mul_lt_of_one_le_of_nonneg_left [PosMulMono α] (h : a * b < c) (hle : 1 ≤ b)
    (ha : 0 ≤ a) : a < c
-- Mathlib/Topology/Algebra/PontryaginDual.lean
@[simp]
nonrec theorem map_mul (f g : ContinuousMonoidHom A E) : map (f * g) = map f * map g
-- Mathlib/Computability/TMToPartrec.lean
theorem tr_push (k f q) : tr (Λ'.push k f q) = branch (fun s => (f s).isSome)
    ((push k fun s => (f s).iget) <| goto fun _ => q) (goto fun _ => q)
-- Mathlib/CategoryTheory/Limits/ConeCategory.lean
/-- Construct an object of the category `(Δ ↓ F)` from a cone on `F`. This is part of an
    equivalence, see `Cone.equivCostructuredArrow`. -/
@[simps]
def Cone.toCostructuredArrow (F : J ⥤ C) : Cone F ⥤ CostructuredArrow (const J) F
-- Mathlib/Data/Finset/Basic.lean
theorem not_subset : ¬s ⊆ t ↔ ∃ x ∈ s, x ∉ t
-- Mathlib/Algebra/GCDMonoid/Finset.lean
theorem lcm_eq_zero_iff [Nontrivial α] : s.lcm f = 0 ↔ 0 ∈ f '' s
-- Mathlib/Logic/Function/Basic.lean
/-- Composition by an injective function on the left is itself injective. -/
theorem Injective.comp_left {g : β → γ} (hg : Function.Injective g) :
    Function.Injective (g ∘ · : (α → β) → α → γ)
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
theorem norm_map_iff_adjoint_comp_self (u : H →L[𝕜] K) :
    (∀ x : H, ‖u x‖ = ‖x‖) ↔ adjoint u ∘L u = 1
-- Mathlib/AlgebraicTopology/FundamentalGroupoid/InducedMaps.lean
@[simp, nolint simpNF]
theorem ulift_apply (i : ULift.{u} I) (x : X) : H.uliftMap (i, x) = H (i.down, x)
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem preimage_div_preimage_subset {s t : Set β} : m ⁻¹' s / m ⁻¹' t ⊆ m ⁻¹' (s / t)
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem Decidable.iff_iff_and_or_not_and_not {a b : Prop} [Decidable b] :
    (a ↔ b) ↔ (a ∧ b) ∨ (¬a ∧ ¬b)
-- Mathlib/Order/WithBot.lean
@[simp]
theorem toDual_symm_apply (a : WithTop αᵒᵈ) : WithBot.toDual.symm a = WithTop.ofDual a
-- Mathlib/FieldTheory/IsSepClosed.lean
/-- Typeclass for separably closed fields.

To show `Polynomial.Splits p f` for an arbitrary ring homomorphism `f`,
see `IsSepClosed.splits_codomain` and `IsSepClosed.splits_domain`.
-/
class IsSepClosed : Prop where
  splits_of_separable : ∀ p : k[X], p.Separable → (p.Splits <| RingHom.id k)
-- Mathlib/Algebra/Order/Hom/Monoid.lean
theorem toOrderMonoidHom_injective : Injective (toOrderMonoidHom : _ → α →*o β)
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem Nonempty.mul : s.Nonempty → t.Nonempty → (s * t).Nonempty
-- Mathlib/CategoryTheory/Noetherian.lean
/-- A noetherian object is an object
which does not have infinite increasing sequences of subobjects.

See https://stacks.math.columbia.edu/tag/0FCG
-/
class NoetherianObject (X : C) : Prop where
  subobject_gt_wellFounded' : WellFounded ((· > ·) : Subobject X → Subobject X → Prop)
-- Mathlib/Algebra/Category/CoalgebraCat/ComonEquivalence.lean
theorem tensorObj_comul (K L : CoalgebraCat R) :
    Coalgebra.comul (R := R) (A := (K ⊗ L : CoalgebraCat R))
      = (TensorProduct.tensorTensorTensorComm R K K L L).toLinearMap
      ∘ₗ TensorProduct.map Coalgebra.comul Coalgebra.comul
-- Mathlib/AlgebraicTopology/SimplicialObject.lean
/-- Augment a cosimplicial object with an object. -/
@[simps]
def augment (X : CosimplicialObject C) (X₀ : C) (f : X₀ ⟶ X.obj [0])
    (w : ∀ (i : SimplexCategory) (g₁ g₂ : ([0] : SimplexCategory) ⟶ i),
      f ≫ X.map g₁ = f ≫ X.map g₂) : CosimplicialObject.Augmented C
-- Mathlib/Topology/AlexandrovDiscrete.lean
@[simp] lemma exterior_univ : exterior (univ : Set α) = univ
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[ext]
lemma ext (z₁ z₂ : Cochain F G n)
    (h : ∀ (p q hpq), z₁.v p q hpq = z₂.v p q hpq) : z₁ = z₂
-- .lake/packages/batteries/Batteries/Classes/SatisfiesM.lean
/--
`SatisfiesM` distributes over `<*>`, weakest precondition version 1.
(Use this when `x` and the goal are known and `f` is a subgoal.)
-/
protected theorem seq_pre [Applicative m] [LawfulApplicative m] {x : m α}
    (hf : SatisfiesM (fun f => ∀ {a}, p₂ a → q (f a)) f) (hx : SatisfiesM p₂ x) :
    SatisfiesM q (f <*> x)
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
/-- The canonical isomorphism `S.cycles ≅ S.homology` when `S.f = 0`. -/
@[simps! hom]
noncomputable def asIsoHomologyπ (hf : S.f = 0) [S.HasHomology] :
    S.cycles ≅ S.homology
-- Mathlib/Data/Nat/Prime/Defs.lean
@[aesop safe destruct] theorem not_prime_one : ¬Prime 1
-- Mathlib/Logic/Function/FromTypes.lean
/-- The definitional equality between `![]`-ary heterogeneous functions into `τ` and `τ`. -/
@[simps!]
def fromTypes_nil_equiv (τ : Type u) : FromTypes ![] τ ≃ τ
-- Mathlib/GroupTheory/GroupAction/Hom.lean
/-- The inverse of a bijective `MulSemiringActionHom` is a `MulSemiringActionHom`. -/
@[simps]
def inverse' (f : R →ₑ+*[φ] S) (g : S → R) (k : Function.RightInverse φ' φ)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) :
    S →ₑ+*[φ'] R
-- Mathlib/Algebra/Module/LinearMap/End.lean
@[simp]
lemma zero_smulRight (x : M) : (0 : M₁ →ₗ[R] S).smulRight x = 0
-- Mathlib/Algebra/Algebra/Operations.lean
lemma span_singleton_mul {x : A} {p : Submodule R A} :
    Submodule.span R {x} * p = x • p
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem IsCompact.inv (hs : IsCompact s) : IsCompact s⁻¹
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
theorem rank_fun_eq_lift_mul : Module.rank R (η → M) =
    (Fintype.card η : Cardinal.{max u₁' v}) * Cardinal.lift.{u₁'} (Module.rank R M)
-- Mathlib/Topology/Algebra/StarSubalgebra.lean
theorem isClosed_topologicalClosure (s : StarSubalgebra R A) :
    IsClosed (s.topologicalClosure : Set A)
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
@[reassoc]
theorem sum_comp {P Q R : C} {J : Type*} (s : Finset J) (f : J → (P ⟶ Q)) (g : Q ⟶ R) :
    (∑ j ∈ s, f j) ≫ g = ∑ j ∈ s, f j ≫ g
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
protected theorem comp {g : β → γ} {f : α → β} (hg : QuasiMeasurePreserving g μb μc)
    (hf : QuasiMeasurePreserving f μa μb) : QuasiMeasurePreserving (g ∘ f) μa μc
-- Mathlib/Analysis/BoxIntegral/Partition/SubboxInduction.lean
theorem isSubordinate_toSubordinate (π : Prepartition I) (r : (ι → ℝ) → Ioi (0 : ℝ)) :
    (π.toSubordinate r).IsSubordinate r
-- Mathlib/Order/Atoms.lean
theorem eq_iff_atom_le_iff {a b : α} : a = b ↔ ∀ c, IsAtom c → (c ≤ a ↔ c ≤ b)