ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Finset/Basic.lean
theorem forall_mem_union {p : α → Prop} : (∀ a ∈ s ∪ t, p a) ↔ (∀ a ∈ s, p a) ∧ ∀ a ∈ t, p a
-- Mathlib/Data/NNReal/Basic.lean
theorem inv_lt_one_iff {x : ℝ≥0} (hx : x ≠ 0) : x⁻¹ < 1 ↔ 1 < x
-- Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean
@[simp]
lemma prodEquiv_symm_apply_fst (x : X₁ × X₂) :
    (Limits.prod.fst : X₁ ⨯ X₂ ⟶ X₁) ((prodEquiv X₁ X₂).symm x) = x.1
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIocDiv_neg' (a b : α) : toIocDiv hp (-a) b = -(toIcoDiv hp a (-b) + 1)
-- Mathlib/Order/Interval/Finset/Defs.lean
@[simp]
theorem mem_Iio : x ∈ Iio a ↔ x < a
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
theorem dist_iterate_succ_le_geometric {f : α → α} (hf : LipschitzWith K f) (x n) :
    dist (f^[n] x) (f^[n + 1] x) ≤ dist x (f x) * (K : ℝ) ^ n
-- Mathlib/CategoryTheory/Shift/InducedShiftSequence.lean
@[simp, reassoc]
lemma induced_isoShiftZero_hom_app_obj (X : C) :
    letI := (induced e M F' e')
    (F.isoShiftZero M).hom.app (L.obj X) =
      (e' 0).hom.app X ≫ (isoShiftZero G M).hom.app X ≫ e.inv.app X
-- Mathlib/CategoryTheory/Limits/Indization/IndObject.lean
/-- If `A` and `B` are isomorphic, then an ind-object presentation of `A` can be extended to an
    ind-object presentation of `B`. -/
@[simps!]
noncomputable def extend {A B : Cᵒᵖ ⥤ Type v} (P : IndObjectPresentation A) (η : A ⟶ B) [IsIso η] :
    IndObjectPresentation B
-- Mathlib/Algebra/Polynomial/Eval.lean
protected theorem map_ne_zero_iff (hf : Function.Injective f) : p.map f ≠ 0 ↔ p ≠ 0
-- Mathlib/Data/Complex/Module.lean
theorem imaginaryPart_apply_coe (a : A) : (ℑ a : A) = -I • (2 : ℝ)⁻¹ • (a - star a)
-- Mathlib/Data/Nat/Defs.lean
lemma div_add_mod' (a b : ℕ) : a / b * b + a % b = a
-- Mathlib/Algebra/Quandle.lean
/-- A quick way to convert a `PreEnvelGroupRel'` to a `PreEnvelGroupRel`.
-/
theorem PreEnvelGroupRel'.rel {R : Type u} [Rack R] {a b : PreEnvelGroup R} :
    PreEnvelGroupRel' R a b → PreEnvelGroupRel R a b
-- Mathlib/Topology/Algebra/InfiniteSum/Order.lean
@[to_additive]
theorem le_hasProd (hf : HasProd f a) (i : ι) (hb : ∀ j, j ≠ i → 1 ≤ f j) : f i ≤ a
-- Mathlib/Order/CompleteLattice.lean
theorem le_sInf_inter {s t : Set α} : sInf s ⊔ sInf t ≤ sInf (s ∩ t)
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_empty : #Empty = 0
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem measure_union_add_inter (s : Set α) (ht : MeasurableSet t) :
    μ (s ∪ t) + μ (s ∩ t) = μ s + μ t
-- Mathlib/Topology/Instances/NNReal.lean
theorem tendsto_atTop_zero_of_summable {f : ℕ → ℝ≥0} (hf : Summable f) : Tendsto f atTop (𝓝 0)
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
/-- If the angle between three points is 0, they are collinear. -/
theorem collinear_of_angle_eq_zero {p₁ p₂ p₃ : P} (h : ∠ p₁ p₂ p₃ = 0) :
    Collinear ℝ ({p₁, p₂, p₃} : Set P)
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
/-- The identification `- ⊗ unmop X = unmop (X ⊗ mop -)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorRightUnmopIso (X : Cᴹᵒᵖ) :
    tensorRight (unmop X) ≅ mopFunctor C ⋙ tensorLeft X ⋙ unmopFunctor C
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem nnnorm_Integral_le_one : ‖integralCLM (α := α) (E := E) (μ := μ)‖₊ ≤ 1
-- Mathlib/MeasureTheory/Measure/Restrict.lean
lemma NullMeasurable.measure_preimage_eq_measure_restrict_preimage_of_ae_compl_eq_const
    {β : Type*} [MeasurableSpace β] {b : β} {f : α → β} {s : Set α}
    (f_mble : NullMeasurable f (μ.restrict s)) (hs : f =ᵐ[Measure.restrict μ sᶜ] (fun _ ↦ b))
    {t : Set β} (t_mble : MeasurableSet t) (ht : b ∉ t) :
    μ (f ⁻¹' t) = μ.restrict s (f ⁻¹' t)
-- Mathlib/LinearAlgebra/TensorPower.lean
theorem mul_one {n} (a : ⨂[R]^n M) : cast R M (add_zero _) (a ₜ* ₜ1) = a
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
theorem isUnit_of_mul_eq_one [CommMonoid M] (a b : M) (h : a * b = 1) : IsUnit a
-- Mathlib/Order/Filter/Basic.lean
theorem neBot_iff {f : Filter α} : NeBot f ↔ f ≠ ⊥
-- Mathlib/Analysis/Normed/Module/FiniteDimension.lean
theorem summable_of_isEquivalent {ι E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [FiniteDimensional ℝ E] {f : ι → E} {g : ι → E} (hg : Summable g) (h : f ~[cofinite] g) :
    Summable f
-- Mathlib/CategoryTheory/Limits/Final.lean
theorem final_natIso_iff {F F' : C ⥤ D} (i : F ≅ F') : Final F ↔ Final F'
-- Mathlib/CategoryTheory/Preadditive/Mat.lean
theorem id_def (M : Mat R) : 𝟙 M = fun i j => if i = j then 1 else 0
-- .lake/packages/batteries/Batteries/WF.lean
@[csimp] private theorem ndrecOn_eq_ndrecOnC : @Acc.ndrecOn = @Acc.ndrecOnC
-- Mathlib/Algebra/Ring/Parity.lean
@[simp] lemma Odd.mul : Odd a → Odd b → Odd (a * b)
-- Mathlib/Topology/UniformSpace/Compact.lean
@[to_additive]
theorem HasCompactMulSupport.uniformContinuous_of_continuous {f : α → β} [One β]
    (h1 : HasCompactMulSupport f) (h2 : Continuous f) : UniformContinuous f
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
/-- Each function of an equicontinuous family is continuous. -/
theorem Equicontinuous.continuous {F : ι → X → α} (h : Equicontinuous F) (i : ι) :
    Continuous (F i)
-- Mathlib/Topology/PartitionOfUnity.lean
theorem IsSubordinate.toPartitionOfUnity {f : BumpCovering ι X s} {U : ι → Set X}
    (h : f.IsSubordinate U) : f.toPartitionOfUnity.IsSubordinate U
-- Mathlib/Order/Filter/IndicatorFunction.lean
@[to_additive]
theorem Filter.EventuallyEq.of_mulIndicator [One β] {l : Filter α} {f : α → β}
    (hf : ∀ᶠ x in l, f x ≠ 1) {s t : Set α} (h : s.mulIndicator f =ᶠ[l] t.mulIndicator f) :
    s =ᶠ[l] t
-- Mathlib/Data/Set/Basic.lean
theorem inclusion_eq_id (h : s ⊆ s) : inclusion h = id
-- .lake/packages/batteries/Batteries/Data/AssocList.lean
@[simp] theorem beq_cons₂ [BEq α] [BEq β] :
    ((.cons a b t : AssocList α β) == .cons a' b' t') = (a == a' && b == b' && t == t')
-- Mathlib/Data/Set/Lattice.lean
theorem iInter_congr_of_surjective {f : ι → Set α} {g : ι₂ → Set α} (h : ι → ι₂) (h1 : Surjective h)
    (h2 : ∀ x, g (h x) = f x) : ⋂ x, f x = ⋂ y, g y
-- Mathlib/Data/List/Sigma.lean
theorem dedupKeys_cons {x : Sigma β} (l : List (Sigma β)) :
    dedupKeys (x :: l) = kinsert x.1 x.2 (dedupKeys l)
-- Mathlib/AlgebraicGeometry/OpenImmersion.lean
lemma image_le_image_of_le {U V : X.Opens} (e : U ≤ V) : f ''ᵁ U ≤ f ''ᵁ V
-- Mathlib/Algebra/GroupWithZero/Semiconj.lean
lemma zpow_left₀ (h : Commute a b) (m : ℤ) : Commute (a ^ m) b
-- Mathlib/Data/Nat/Squarefree.lean
theorem Squarefree.nodup_primeFactorsList {n : ℕ} (hn : Squarefree n) : n.primeFactorsList.Nodup
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
@[simp]
theorem pow_pos [ZeroLEOneClass α] [PosMulStrictMono α]
    (H : 0 < a) : ∀ n : ℕ, 0 < a ^ n
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem lt_rpow_inv_iff {x y : ℝ≥0∞} {z : ℝ} (hz : 0 < z) : x < y ^ z⁻¹ ↔ x ^ z < y
-- Mathlib/Topology/Algebra/Nonarchimedean/Bases.lean
theorem nonarchimedean (hB : SubmodulesBasis B) : @NonarchimedeanAddGroup M _ hB.topology
-- Mathlib/Analysis/Complex/ReImTopology.lean
theorem quotientMap_re : QuotientMap re
-- Mathlib/Analysis/Convex/Segment.lean
theorem segment_subset_uIcc (x y : E) : [x -[𝕜] y] ⊆ uIcc x y
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean
theorem left_nonuniformWitnesses_subset (h : ¬G.IsUniform ε s t) :
    (G.nonuniformWitnesses ε s t).1 ⊆ s
-- Mathlib/CategoryTheory/Closed/Cartesian.lean
theorem curry_eq_iff (f : A ⨯ Y ⟶ X) (g : Y ⟶ A ⟹ X) : curry f = g ↔ f = uncurry g
-- Mathlib/Order/CompleteLattice.lean
theorem biSup_congr' {p : ι → Prop} {f g : (i : ι) → p i → α}
    (h : ∀ i (hi : p i), f i hi = g i hi) :
    ⨆ i, ⨆ (hi : p i), f i hi = ⨆ i, ⨆ (hi : p i), g i hi
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem mul_sub_mul_div_mul_neg_iff (hc : c ≠ 0) (hd : d ≠ 0) :
    (a * d - b * c) / (c * d) < 0 ↔ a / c < b / d
-- Mathlib/Algebra/Module/LinearMap/End.lean
/-- Each element of the monoid defines a module endomorphism.

This is a stronger version of `DistribMulAction.toAddMonoidEnd`. -/
@[simps]
def toModuleEnd : S →* Module.End R M
-- Mathlib/Analysis/SpecialFunctions/PolarCoord.lean
protected theorem polarCoord_target :
    Complex.polarCoord.target = Set.Ioi (0 : ℝ) ×ˢ Set.Ioo (-π) π
-- Mathlib/Probability/Kernel/WithDensity.lean
theorem withDensity_of_not_measurable (κ : Kernel α β) [IsSFiniteKernel κ]
    (hf : ¬Measurable (Function.uncurry f)) : withDensity κ f = 0
-- Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean
theorem gramSchmidtNormed_unit_length {f : ι → E} (n : ι) (h₀ : LinearIndependent 𝕜 f) :
    ‖gramSchmidtNormed 𝕜 f n‖ = 1
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem HasFDerivWithinAt.ccosh (hf : HasFDerivWithinAt f f' s x) :
    HasFDerivWithinAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) • f') s x
-- Mathlib/Algebra/Group/Center.lean
@[to_additive (attr := simp) addCentralizer_univ]
lemma centralizer_univ : centralizer univ = center M
-- Mathlib/Algebra/Lie/OfAssociative.lean
theorem coe_map_toEnd_le :
    (N : Submodule R M).map (LieModule.toEnd R L M x) ≤ N
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
@[simp]
protected theorem inter (hs : NullMeasurableSet s μ) (ht : NullMeasurableSet t μ) :
    NullMeasurableSet (s ∩ t) μ
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
theorem coprime_of_dvd_coprime {a b : ℤ√d} (hcoprime : IsCoprime a.re a.im) (hdvd : b ∣ a) :
    IsCoprime b.re b.im
-- Mathlib/Topology/Algebra/ConstMulAction.lean
theorem IsOpen.smul₀ {c : G₀} {s : Set α} (hs : IsOpen s) (hc : c ≠ 0) : IsOpen (c • s)
-- Mathlib/CategoryTheory/Limits/ConeCategory.lean
/-- A cocone `c` on `F : J ⥤ C` lifts to a cocone in `Over c.pt` with cone point `𝟙 c.pt`. -/
@[simps]
def Cocone.toOver {F : J ⥤ C} (c : Cocone F) :
    Cocone (c.toCostructuredArrow ⋙ CostructuredArrow.toOver _ _)
-- Mathlib/CategoryTheory/Comma/Presheaf.lean
/-- This is the reverse direction of the equivalence we're constructing. -/
@[simps! obj map]
def costructuredArrowPresheafToOver (A : Cᵒᵖ ⥤ Type v) :
    ((CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v) ⥤ Over A
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
theorem comap_singleton_isClosed_of_surjective (f : R →+* S) (hf : Function.Surjective f)
    (x : PrimeSpectrum S) (hx : IsClosed ({x} : Set (PrimeSpectrum S))) :
    IsClosed ({comap f x} : Set (PrimeSpectrum R))
-- Mathlib/Data/Part.lean
theorem mem_some (a : α) : a ∈ some a
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem abs_intervalIntegral_eq (f : ℝ → ℝ) (a b : ℝ) (μ : Measure ℝ) :
    |∫ x in a..b, f x ∂μ| = |∫ x in Ι a b, f x ∂μ|
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
theorem Filter.Tendsto.isCoboundedUnder_ge [NeBot f] (h : Tendsto u f (𝓝 a)) :
    f.IsCoboundedUnder (· ≥ ·) u
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem smoothAt_fst {p : M × N} : SmoothAt (I.prod J) I Prod.fst p
-- Mathlib/Algebra/Category/MonCat/Basic.lean
@[to_additive (attr := ext)]
lemma ext {X Y : CommMonCat} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g
-- Mathlib/CategoryTheory/Preadditive/InjectiveResolution.lean
/-- An injective object admits a trivial injective resolution: itself in degree 0. -/
@[simps]
def self [Injective Z] : InjectiveResolution Z
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
@[simp]
theorem coe_submonoidClass_iff {M B : Type*} [CommMonoid M] [SetLike B M] [SubmonoidClass B M]
    {N : B} {ζ : N} : IsPrimitiveRoot (ζ : M) k ↔ IsPrimitiveRoot ζ k
-- Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean
/-- Auxiliary lemma for `rnDeriv_withDensity_right`. -/
lemma rnDeriv_withDensity_right_of_absolutelyContinuous {ν : Measure α} [SigmaFinite μ]
    [SigmaFinite ν] (hμν : μ ≪ ν) (hf : AEMeasurable f ν)
    (hf_ne_zero : ∀ᵐ x ∂ν, f x ≠ 0) (hf_ne_top : ∀ᵐ x ∂ν, f x ≠ ∞) :
    μ.rnDeriv (ν.withDensity f) =ᵐ[ν] fun x ↦ (f x)⁻¹ * μ.rnDeriv ν x
-- Mathlib/Analysis/Calculus/IteratedDeriv/Lemmas.lean
theorem iteratedDerivWithin_neg' :
    iteratedDerivWithin n (fun z => -f z) s x = -iteratedDerivWithin n f s x
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Square.lean
lemma IsPushout.of_iso {sq₁ sq₂ : Square C} (h : sq₁.IsPushout)
    (e : sq₁ ≅ sq₂) : sq₂.IsPushout
-- Mathlib/Topology/Algebra/Module/LocallyConvex.lean
theorem locallyConvexSpace_sInf {ts : Set (TopologicalSpace E)}
    (h : ∀ t ∈ ts, @LocallyConvexSpace 𝕜 E _ _ _ t) : @LocallyConvexSpace 𝕜 E _ _ _ (sInf ts)
-- Mathlib/Order/LiminfLimsup.lean
/-- In other words, `liminf cofinite s` is the set of elements lying outside the family `s`
finitely often. -/
theorem cofinite.liminf_set_eq : liminf s cofinite = { x | { n | x ∉ s n }.Finite }
-- Mathlib/Algebra/Algebra/Subalgebra/MulOpposite.lean
@[simp, norm_cast]
theorem unop_coe (S : Subalgebra R Aᵐᵒᵖ) : S.unop = MulOpposite.op ⁻¹' (S : Set Aᵐᵒᵖ)
-- Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
/-- The canonical morphism of sheafed spaces from `X` to the spectrum of its global sections. -/
@[simps]
def toΓSpecSheafedSpace : X.toSheafedSpace ⟶ Spec.toSheafedSpace.obj (op (Γ.obj (op X)))
-- Mathlib/Order/Cover.lean
theorem wcovBy_iff_eq_or_covBy : a ⩿ b ↔ a = b ∨ a ⋖ b
-- Mathlib/Data/Matrix/Basic.lean
theorem star_mulVec [Fintype n] [StarRing α] (M : Matrix m n α) (v : n → α) :
    star (M *ᵥ v) = star v ᵥ* Mᴴ
-- Mathlib/Data/Fin/Basic.lean
theorem lt_rev_iff {i j : Fin n} : i < rev j ↔ j < rev i
-- Mathlib/Data/Finmap.lean
/-- An equivalence between `Finmap β` and pairs `(keys : Finset α, lookup : ∀ a, Option (β a))` such
that `(lookup a).isSome ↔ a ∈ keys`. -/
@[simps apply_coe_fst apply_coe_snd]
def keysLookupEquiv :
    Finmap β ≃ { f : Finset α × (∀ a, Option (β a)) // ∀ i, (f.2 i).isSome ↔ i ∈ f.1 }
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem sub_inv_antitoneOn_Icc_left (ha : b < c) :
    AntitoneOn (fun x ↦ (x-c)⁻¹) (Set.Icc a b)
-- Mathlib/Topology/Order.lean
theorem mem_nhds_induced [T : TopologicalSpace α] (f : β → α) (a : β) (s : Set β) :
    s ∈ @nhds β (TopologicalSpace.induced f T) a ↔ ∃ u ∈ 𝓝 (f a), f ⁻¹' u ⊆ s
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
/-- The adjoint of the linear map associated to a matrix is the linear map associated to the
conjugate transpose of that matrix. -/
theorem Matrix.toEuclideanLin_conjTranspose_eq_adjoint (A : Matrix m n 𝕜) :
    Matrix.toEuclideanLin A.conjTranspose = LinearMap.adjoint (Matrix.toEuclideanLin A)
-- Mathlib/Algebra/AddConstMap/Equiv.lean
@[simp] lemma symm_symm (e : G ≃+c[a, b] H) : e.symm.symm = e
-- Mathlib/Analysis/Convex/Topology.lean
/-- Every vector in `stdSimplex 𝕜 ι` has `max`-norm at most `1`. -/
theorem stdSimplex_subset_closedBall : stdSimplex ℝ ι ⊆ Metric.closedBall 0 1
-- Mathlib/CategoryTheory/Localization/Construction.lean
/-- The lifting of a functor to the path category of `LocQuiver W` -/
@[simps!]
def liftToPathCategory : Paths (LocQuiver W) ⥤ D
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem neg_of_sign_eq_neg_one : ∀ {a : Int}, sign a = -1 → a < 0
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem modify_get?_length (f : α → α) : ∀ n l, length (modifyNth f n l) = length l
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
theorem normalize_num_den' (num den nz) : ∃ d : Nat, d ≠ 0 ∧
    num = (normalize num den nz).num * d ∧ den = (normalize num den nz).den * d
-- Mathlib/Topology/MetricSpace/Dilation.lean
@[simp]
theorem mk_coe_of_nndist_eq {α β} [PseudoMetricSpace α] [PseudoMetricSpace β] (f : α →ᵈ β)
    (h) : Dilation.mkOfNNDistEq f h = f
-- Mathlib/Topology/Algebra/UniformGroup.lean
@[to_additive]
-- Porting note: renamed theorem to conform to naming convention
theorem comm_topologicalGroup_is_uniform : UniformGroup G
-- Mathlib/Analysis/RCLike/Basic.lean
theorem norm_sq_re_add_conj (x : K) : ‖x + conj x‖ ^ 2 = re (x + conj x) ^ 2
-- Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean
theorem four_zero_nine_six_lt_exp_sixteen : 4096 < exp 16
-- Mathlib/Analysis/Normed/Field/Basic.lean
/-- If `α` is a seminormed ring with `‖1‖ = 1`, then `‖a ^ n‖ ≤ ‖a‖ ^ n`.
See also `norm_pow_le'`. -/
theorem norm_pow_le [NormOneClass α] (a : α) (n : ℕ) : ‖a ^ n‖ ≤ ‖a‖ ^ n
-- Mathlib/RingTheory/IsAdjoinRoot.lean
theorem map_eq_zero_iff (h : IsAdjoinRoot S f) {p} : h.map p = 0 ↔ f ∣ p
-- Mathlib/RingTheory/Bialgebra/Hom.lean
protected theorem congr_fun {φ₁ φ₂ : A →ₐc[R] B} (H : φ₁ = φ₂) (x : A) : φ₁ x = φ₂ x
-- Mathlib/LinearAlgebra/Span.lean
theorem disjoint_span_singleton' {K E : Type*} [DivisionRing K] [AddCommGroup E] [Module K E]
    {p : Submodule K E} {x : E} (x0 : x ≠ 0) : Disjoint p (K ∙ x) ↔ x ∉ p
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
/-- A filter `f` is measurably generates if each `s ∈ f` includes a measurable `t ∈ f`. -/
class IsMeasurablyGenerated (f : Filter α) : Prop where
  exists_measurable_subset : ∀ ⦃s⦄, s ∈ f → ∃ t ∈ f, MeasurableSet t ∧ t ⊆ s
-- Mathlib/Algebra/Homology/HomotopyCofiber.lean
lemma ext_from_X' (i : ι) (hi : ¬ c.Rel i (c.next i)) {A : C} {f g : X φ i ⟶ A}
    (h : inrX φ i ≫ f = inrX φ i ≫ g) : f = g
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Bounds.lean
/-- **Jordan's inequality** for `cos`. -/
lemma one_sub_two_div_pi_mul_le_cos (hx₀ : 0 ≤ x) (hx : x ≤ π / 2) : 1 - 2 / π * x ≤ cos x
-- Mathlib/GroupTheory/CoprodI.lean
theorem lift_range_le {N} [Group N] (f : ∀ i, G i →* N) {s : Subgroup N}
    (h : ∀ i, (f i).range ≤ s) : (lift f).range ≤ s
-- Mathlib/RingTheory/Noetherian.lean
/-- If `M / S / R` is a scalar tower, and `M / R` is Noetherian, then `M / S` is
also noetherian. -/
theorem isNoetherian_of_tower (R) {S M} [Semiring R] [Semiring S] [AddCommMonoid M] [SMul R S]
    [Module S M] [Module R M] [IsScalarTower R S M] (h : IsNoetherian R M) : IsNoetherian S M
-- Mathlib/Analysis/SpecificLimits/Basic.lean
/-- If `dist (f n) (f (n+1))` is bounded by `(C / 2) / 2^n`, then the distance from
`f n` to the limit of `f` is bounded above by `C / 2^n`. -/
theorem dist_le_of_le_geometric_two_of_tendsto {a : α} (ha : Tendsto f atTop (𝓝 a)) (n : ℕ) :
    dist (f n) a ≤ C / 2 ^ n
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive]
theorem Left.inv_le_self (h : 1 ≤ a) : a⁻¹ ≤ a
-- Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
lemma Spec.map_injective {R S : CommRingCat} : Function.Injective (Spec.map : (R ⟶ S) → _)
-- Mathlib/Analysis/Calculus/MeanValue.lean
/-- Let `f : ℝ → ℝ` be a differentiable function. If `f' < C`, then `f` grows slower than
`C * x` on `D`, i.e., `f y - f x < C * (y - x)` whenever `x < y`. -/
theorem image_sub_lt_mul_sub_of_deriv_lt {f : ℝ → ℝ} (hf : Differentiable ℝ f) {C}
    (lt_hf' : ∀ x, deriv f x < C) ⦃x y⦄ (hxy : x < y) : f y - f x < C * (y - x)
-- Mathlib/Data/Finset/Density.lean
@[simp] lemma dens_univ : dens (univ : Finset α) = 1
-- Mathlib/LinearAlgebra/Determinant.lean
/-- Conjugating a linear equiv by a linear equiv does not change its determinant. -/
@[simp]
theorem det_conj (f : M ≃ₗ[R] M) (e : M ≃ₗ[R] M') :
    LinearEquiv.det ((e.symm.trans f).trans e) = LinearEquiv.det f
-- Mathlib/Algebra/Order/Monovary.lean
lemma MonovaryOn.pow_right₀ (hg : ∀ i ∈ s, 0 ≤ g i) (hfg : MonovaryOn f g s) (n : ℕ) :
    MonovaryOn f (g ^ n) s
-- Mathlib/Algebra/AddConstMap/Basic.lean
@[scoped simp]
theorem map_nsmul_add [AddCommMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
    (f : F) (n : ℕ) (x : G) : f (n • a + x) = f x + n • b
-- Mathlib/Data/Matrix/RowCol.lean
theorem col_injective [Nonempty ι] : Function.Injective (col ι : (m → α) → Matrix m ι α)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem pos_of_ne_zero {n : Nat} : n ≠ 0 → 0 < n
-- Mathlib/Data/Multiset/Basic.lean
lemma cons_lt_cons (a : α) (h : s < t) : a ::ₘ s < a ::ₘ t
-- Mathlib/Order/UpperLower/Basic.lean
@[simp, norm_cast]
theorem coe_inf (s t : LowerSet α) : (↑(s ⊓ t) : Set α) = (s : Set α) ∩ t
-- Mathlib/Data/ENNReal/Basic.lean
@[simp] theorem top_toNNReal : ∞.toNNReal = 0
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem le_one_iff {a : Ordinal} : a ≤ 1 ↔ a = 0 ∨ a = 1
-- Mathlib/Analysis/Analytic/Inverse.lean
@[simp]
theorem leftInv_coeff_zero (p : FormalMultilinearSeries 𝕜 E F) (i : E ≃L[𝕜] F) :
    p.leftInv i 0 = 0
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
theorem dimH_univ_eq_finrank : dimH (univ : Set E) = finrank ℝ E
-- Mathlib/Order/Lattice.lean
@[simp]
theorem sup_eq_left : a ⊔ b = a ↔ b ≤ a
-- Mathlib/Data/Finset/Lattice.lean
@[simp]
theorem max_empty : (∅ : Finset α).max = ⊥
-- Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean
/-- A variant of `measure_eq_iInf` which has a single `iInf`. This is useful when applying a
  lemma next that only works for non-empty infima, in which case you can use
  `nonempty_measurable_superset`. -/
theorem measure_eq_iInf' (μ : Measure α) (s : Set α) :
    μ s = ⨅ t : { t // s ⊆ t ∧ MeasurableSet t }, μ t
-- Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean
/-- The terms of the sequence have nonzero norm. -/
theorem seq_norm_ne_zero (n : ℕ) : Algebra.norm ℤ (seq K w₁ hB n : 𝓞 K) ≠ 0
-- Mathlib/GroupTheory/Schreier.lean
/-- **Schreier's Lemma**: If `R : Set G` is a `rightTransversal` of `H : Subgroup G`
  with `1 ∈ R`, and if `G` is generated by `S : Set G`, then `H` is generated by the `Set`
  `(R * S).image (fun g ↦ g * (toFun hR g)⁻¹)`. -/
theorem closure_mul_image_eq (hR : R ∈ rightTransversals (H : Set G)) (hR1 : (1 : G) ∈ R)
    (hS : closure S = ⊤) : closure ((R * S).image fun g => g * (toFun hR g : G)⁻¹) = H
-- Mathlib/MeasureTheory/Integral/Average.lean
/-- **First moment method**. The minimum of an integrable function is smaller than its mean. -/
theorem exists_le_average (hμ : μ ≠ 0) (hf : Integrable f μ) : ∃ x, f x ≤ ⨍ a, f a ∂μ
-- Mathlib/Topology/Connected/LocallyConnected.lean
/-- A topological space is **locally connected** if each neighborhood filter admits a basis
of connected *open* sets. Note that it is equivalent to each point having a basis of connected
(non necessarily open) sets but in a non-trivial way, so we choose this definition and prove the
equivalence later in `locallyConnectedSpace_iff_connected_basis`. -/
class LocallyConnectedSpace (α : Type*) [TopologicalSpace α] : Prop where
  /-- Open connected neighborhoods form a basis of the neighborhoods filter. -/
  open_connected_basis : ∀ x, (𝓝 x).HasBasis (fun s : Set α => IsOpen s ∧ x ∈ s ∧ IsConnected s) id
-- Mathlib/Analysis/Convex/Basic.lean
@[nontriviality] lemma stdSimplex_of_subsingleton [Subsingleton 𝕜] : stdSimplex 𝕜 ι = univ
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem contDiff_cos {n} : ContDiff ℂ n cos
-- Mathlib/CategoryTheory/Monoidal/Bimon_.lean
/-- The forgetful functor from bimonoid objects to comonoid objects. -/
@[simps!]
def toComon_ : Bimon_ C ⥤ Comon_ C
-- Mathlib/Analysis/Convex/Cone/Basic.lean
@[simp]
theorem mem_map {f : E →ₗ[𝕜] F} {S : ConvexCone 𝕜 E} {y : F} : y ∈ S.map f ↔ ∃ x ∈ S, f x = y
-- Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean
lemma setLIntegral_rnDeriv [HaveLebesgueDecomposition μ ν] [SFinite ν]
    (hμν : μ ≪ ν) (s : Set α) :
    ∫⁻ x in s, μ.rnDeriv ν x ∂ν = μ s
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
theorem lineMap_symm (p₀ p₁ : P1) :
    lineMap p₀ p₁ = (lineMap p₁ p₀).comp (lineMap (1 : k) (0 : k))
-- Mathlib/CategoryTheory/Shift/Basic.lean
lemma ShiftMkCore.shiftFunctorAdd_eq (h : ShiftMkCore C A) (a b : A) :
    letI := hasShiftMk C A h
    shiftFunctorAdd C a b = h.add a b
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
theorem zero_tprodCoeff (f : Π i, s i) : tprodCoeff R 0 f = 0
-- Mathlib/Data/Quot.lean
theorem Quot.eq {α : Type*} {r : α → α → Prop} {x y : α} :
    Quot.mk r x = Quot.mk r y ↔ EqvGen r x y
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean
/-- The sine of an angle in a right-angled triangle as a ratio of sides. -/
theorem sin_angle_of_angle_eq_pi_div_two {p₁ p₂ p₃ : P} (h : ∠ p₁ p₂ p₃ = π / 2)
    (h0 : p₁ ≠ p₂ ∨ p₃ ≠ p₂) : Real.sin (∠ p₂ p₃ p₁) = dist p₁ p₂ / dist p₁ p₃
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
theorem prev_eq (f : Hom C₁ C₂) {i j : ι} (w : c.Rel i j) :
    f.prev j = (C₁.xPrevIso w).hom ≫ f.f i ≫ (C₂.xPrevIso w).inv