ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/MorphismProperty/Limits.lean
theorem universally_mono : Monotone (universally : MorphismProperty C → MorphismProperty C)
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem WfDvdMonoid.max_power_factor' [CommMonoidWithZero α] [WfDvdMonoid α] {a₀ x : α}
    (h : a₀ ≠ 0) (hx : ¬IsUnit x) : ∃ (n : ℕ) (a : α), ¬x ∣ a ∧ a₀ = x ^ n * a
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem utf8GetAux_of_valid (cs cs' : List Char) {i p : Nat} (hp : i + utf8Len cs = p) :
    utf8GetAux (cs ++ cs') ⟨i⟩ ⟨p⟩ = cs'.headD default
-- Mathlib/Data/ENNReal/Real.lean
theorem ofReal_lt_ofReal_iff_of_nonneg {p q : ℝ} (hp : 0 ≤ p) :
    ENNReal.ofReal p < ENNReal.ofReal q ↔ p < q
-- Mathlib/Data/List/Chain.lean
theorem Chain'.infix (h : Chain' R l) (h' : l₁ <:+: l) : Chain' R l₁
-- Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean
theorem midpoint_zero_add (x y : V) : midpoint R 0 (x + y) = midpoint R x y
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
@[simp]
theorem coe_mapAlgEquiv (f : A ≃ₐ[R] B) : ⇑(mapAlgEquiv f) = map f
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
@[simp]
theorem mk_d_2_1 : (mk X₀ X₁ X₂ d₀ d₁ s succ).d 2 1 = d₁
-- Mathlib/CategoryTheory/Subobject/Limits.lean
@[reassoc (attr := simp)]
theorem equalizerSubobject_arrow :
    (equalizerSubobjectIso f g).hom ≫ equalizer.ι f g = (equalizerSubobject f g).arrow
-- Mathlib/Data/List/GetD.lean
@[simp]
theorem getElem?_getD_replicate_default_eq (r n : ℕ) : (replicate r d)[n]?.getD d = d
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem erase_sublist (a : α) (l : List α) : l.erase a <+ l
-- Mathlib/Order/Interval/Basic.lean
@[simp]
theorem dual_map (f : α →o β) (a : NonemptyInterval α) :
    dual (a.map f) = a.dual.map (OrderHom.dual f)
-- Mathlib/CategoryTheory/Extensive.lean
lemma FinitaryExtensive.isPullback_initial_to_sigma_ι [FinitaryExtensive C] {ι : Type*} [Finite ι]
    (X : ι → C) (i j : ι) (e : i ≠ j) :
    IsPullback (initial.to _) (initial.to _) (Sigma.ι X i) (Sigma.ι X j)
-- Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean
lemma growsPolynomially_id : GrowsPolynomially (fun x => x)
-- Mathlib/Order/Filter/Partial.lean
theorem rcomap_rcomap (r : Rel α β) (s : Rel β γ) (l : Filter γ) :
    rcomap r (rcomap s l) = rcomap (r.comp s) l
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[simp]
theorem image2_vsub : (image2 VSub.vsub s t : Set α) = s -ᵥ t
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
theorem ImageMap.map_uniq {f g : Arrow C} [HasImage f.hom] [HasImage g.hom]
    {sq : f ⟶ g} (F G : ImageMap sq) : F.map = G.map
-- Mathlib/Data/Set/Image.lean
theorem image_id (s : Set α) : id '' s = s
-- Mathlib/Data/Matroid/Map.lean
@[simp] lemma map_emptyOn (f : α → β) : (emptyOn α).map f (by simp) = emptyOn β
-- Mathlib/Analysis/LocallyConvex/WithSeminorms.lean
theorem WithSeminorms.hasBasis (hp : WithSeminorms p) :
    (𝓝 (0 : E)).HasBasis (fun s : Set E => s ∈ p.basisSets) id
-- Mathlib/Data/Real/Hyperreal.lean
theorem isSt_ofSeq_iff_tendsto {f : ℕ → ℝ} {r : ℝ} :
    IsSt (ofSeq f) r ↔ Tendsto f (hyperfilter ℕ) (𝓝 r)
-- Mathlib/NumberTheory/RamificationInertia.lean
@[simp]
theorem ramificationIdx_of_not_le (h : ¬map f p ≤ P) : ramificationIdx f p P = 0
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
@[simp]
theorem Ideal.dvd_span_singleton {I : Ideal A} {x : A} : I ∣ Ideal.span {x} ↔ x ∈ I
-- Mathlib/Topology/StoneCech.lean
theorem stoneCech_hom_ext {g₁ g₂ : StoneCech α → β} (h₁ : Continuous g₁) (h₂ : Continuous g₂)
    (h : g₁ ∘ stoneCechUnit = g₂ ∘ stoneCechUnit) : g₁ = g₂
-- Mathlib/RingTheory/Etale/Basic.lean
theorem comp [FormallyEtale R A] [FormallyEtale A B] : FormallyEtale R B
-- Mathlib/CategoryTheory/MorphismProperty/Basic.lean
lemma map_eq_of_iso (P : MorphismProperty C) {F G : C ⥤ D} (e : F ≅ G) :
    P.map F = P.map G
-- Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
lemma quotTensorEquivQuotSMul_symm_comp_mkQ (I : Ideal R) :
    (quotTensorEquivQuotSMul M I).symm ∘ₗ (I • ⊤ : Submodule R M).mkQ =
      TensorProduct.mk R (R ⧸ I) M 1
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
@[to_additive sum_le_card_nsmul]
theorem prod_le_pow_card (s : Finset ι) (f : ι → N) (n : N) (h : ∀ x ∈ s, f x ≤ n) :
    s.prod f ≤ n ^ s.card
-- Mathlib/Topology/UniformSpace/Completion.lean
theorem uniformContinuous_extension₂ : UniformContinuous₂ (Completion.extension₂ f)
-- Mathlib/Logic/Equiv/Option.lean
@[simp]
theorem removeNone_symm : (removeNone e).symm = removeNone e.symm
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
@[simp]
theorem iUnion_bot : (⊥ : Prepartition I).iUnion = ∅
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem coeFn_compLp' (L : E →L[𝕜] F) (f : Lp E p μ) : L.compLp f =ᵐ[μ] fun a => L (f a)
-- Mathlib/RingTheory/WittVector/Defs.lean
theorem sub_coeff (x y : 𝕎 R) (n : ℕ) :
    (x - y).coeff n = peval (wittSub p n) ![x.coeff, y.coeff]
-- Mathlib/Data/ZMod/Basic.lean
private theorem mul_inv_cancel_aux (a : ZMod p) (h : a ≠ 0) : a * a⁻¹ = 1
-- Mathlib/Order/SuccPred/Basic.lean
theorem Ioo_succ_right_eq_insert_of_not_isMax (h₁ : a < b) (h₂ : ¬IsMax b) :
    Ioo a (succ b) = insert b (Ioo a b)
-- Mathlib/Data/Sign.lean
@[simp]
theorem sign_nonpos_iff : sign a ≤ 0 ↔ a ≤ 0
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem coe_mem {s : Finset α} (x : (s : Set α)) : ↑x ∈ s
-- Mathlib/GroupTheory/PushoutI.lean
/-- A constructor that multiplies a `NormalWord` by an element, with condition to make
sure the underlying list does get longer.  -/
@[simps!]
noncomputable def cons {i} (g : G i) (w : NormalWord d) (hmw : w.fstIdx ≠ some i)
    (hgr : g ∉ (φ i).range) : NormalWord d
-- Mathlib/Analysis/Normed/Field/Basic.lean
/-- A normed division ring is a division ring endowed with a seminorm which satisfies the equality
`‖x y‖ = ‖x‖ ‖y‖`. -/
class NormedDivisionRing (α : Type*) extends Norm α, DivisionRing α, MetricSpace α where
  /-- The distance is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = norm (x - y)
  /-- The norm is multiplicative. -/
  norm_mul' : ∀ a b, norm (a * b) = norm a * norm b
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
/-- A family `𝓕 : ι → β → α` is uniformly equicontinuous iff `range 𝓕` is uniformly equicontinuous,
i.e the family `(↑) : range F → β → α` is uniformly equicontinuous. -/
theorem uniformEquicontinuous_iff_range {F : ι → β → α} :
    UniformEquicontinuous F ↔ UniformEquicontinuous ((↑) : range F → β → α)
-- Mathlib/Topology/Algebra/Group/Basic.lean
/-- If a point in a topological group has a compact neighborhood, then the group is
locally compact. -/
@[to_additive]
theorem IsCompact.locallyCompactSpace_of_mem_nhds_of_group {K : Set G} (hK : IsCompact K) {x : G}
    (h : K ∈ 𝓝 x) : LocallyCompactSpace G
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem eq_of_factors_eq_factors {a b : Associates α} (h : a.factors = b.factors) : a = b
-- Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean
/-- The head term of the gcf of `v` is `⌊v⌋`. -/
@[simp]
theorem of_h_eq_floor : (of v).h = ⌊v⌋
-- Mathlib/Analysis/Matrix.lean
theorem norm_lt_iff {r : ℝ} (hr : 0 < r) {A : Matrix m n α} : ‖A‖ < r ↔ ∀ i j, ‖A i j‖ < r
-- Mathlib/Analysis/Convex/Side.lean
theorem setOf_sSameSide_eq_image2 {s : AffineSubspace R P} {x p : P} (hx : x ∉ s) (hp : p ∈ s) :
    { y | s.SSameSide x y } = Set.image2 (fun (t : R) q => t • (x -ᵥ p) +ᵥ q) (Set.Ioi 0) s
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- Assumes left covariance.
The lemma assuming right covariance is `Right.one_lt_mul_of_le_of_lt`. -/
@[to_additive Left.add_pos_of_nonneg_of_pos
      "Assumes left covariance.
      The lemma assuming right covariance is `Right.add_pos_of_nonneg_of_pos`."]
theorem Left.one_lt_mul_of_le_of_lt [CovariantClass α α (· * ·) (· < ·)] {a b : α} (ha : 1 ≤ a)
    (hb : 1 < b) :
    1 < a * b
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem add_lt_of_lt_sub_left {a b c : Int} (h : b < c - a) : a + b < c
-- Mathlib/Probability/IdentDistrib.lean
theorem essSup_eq [ConditionallyCompleteLinearOrder γ] [TopologicalSpace γ] [OpensMeasurableSpace γ]
    [OrderClosedTopology γ] (h : IdentDistrib f g μ ν) : essSup f μ = essSup g ν
-- Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean
/-- The property of being `C^n`, initially defined in terms of the Fréchet derivative, can be
reformulated in terms of the one-dimensional derivative. -/
theorem contDiff_iff_iteratedDeriv {n : ℕ∞} : ContDiff 𝕜 n f ↔
    (∀ m : ℕ, (m : ℕ∞) ≤ n → Continuous (iteratedDeriv m f)) ∧
      ∀ m : ℕ, (m : ℕ∞) < n → Differentiable 𝕜 (iteratedDeriv m f)
-- Mathlib/Topology/Category/CompHausLike/Limits.lean
/--
The pullback cone whose cone point is the explicit pullback.
-/
@[simps! pt π]
def pullback.cone : Limits.PullbackCone f g
-- Mathlib/Analysis/Complex/LocallyUniformLimit.lean
theorem cderiv_sub (hr : 0 < r) (hf : ContinuousOn f (sphere z r))
    (hg : ContinuousOn g (sphere z r)) : cderiv r (f - g) z = cderiv r f z - cderiv r g z
-- Mathlib/CategoryTheory/Groupoid.lean
/-- A `Groupoid` is a category such that all morphisms are isomorphisms. -/
class Groupoid (obj : Type u) extends Category.{v} obj : Type max u (v + 1) where
  /-- The inverse morphism -/
  inv : ∀ {X Y : obj}, (X ⟶ Y) → (Y ⟶ X)
  /-- `inv f` composed `f` is the identity -/
  inv_comp : ∀ {X Y : obj} (f : X ⟶ Y), comp (inv f) f = id Y := by aesop_cat
  /-- `f` composed with `inv f` is the identity -/
  comp_inv : ∀ {X Y : obj} (f : X ⟶ Y), comp f (inv f) = id X := by aesop_cat
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
@[gcongr]
theorem mul_lt_mul_of_pos_left [PosMulStrictMono α] (bc : b < c) (a0 : 0 < a) : a * b < a * c
-- Mathlib/Data/Fintype/Card.lean
theorem card_eq_one_of_forall_eq {i : α} (h : ∀ j, j = i) : card α = 1
-- Mathlib/Topology/Instances/ENNReal.lean
theorem exists_frequently_lt_of_liminf_ne_top' {ι : Type*} {l : Filter ι} {x : ι → ℝ}
    (hx : liminf (fun n => (Real.nnabs (x n) : ℝ≥0∞)) l ≠ ∞) : ∃ R, ∃ᶠ n in l, R < x n
-- Mathlib/GroupTheory/GroupAction/Hom.lean
protected theorem congr_fun {f g : X →ₑ[φ] Y} (h : f = g) (x : X) :
    f x = g x
-- Mathlib/Analysis/Convolution.lean
theorem _root_.HasCompactSupport.convolutionExistsRightOfContinuousLeft (hcg : HasCompactSupport g)
    (hf : Continuous f) (hg : LocallyIntegrable g μ) : ConvolutionExists f g L μ
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
theorem map_fst_darts_append {u v : V} (p : G.Walk u v) :
    p.darts.map (·.fst) ++ [v] = p.support
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem degree_of_c_eq_zero' : (toPoly ⟨0, 0, 0, d⟩).degree ≤ 0
-- Mathlib/Topology/MetricSpace/Contracting.lean
theorem fixedPoint_unique {x} (hx : IsFixedPt f x) : x = fixedPoint f hf
-- Mathlib/Deprecated/Subfield.lean
theorem closure_subset {T : Set F} (hT : IsSubfield T) (H : S ⊆ T) : closure S ⊆ T
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
theorem mul_empty (s : Finset α) : s * ∅ = ∅
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem zero_dotProduct : 0 ⬝ᵥ v = 0
-- Mathlib/NumberTheory/LegendreSymbol/Basic.lean
/-- When `p ∤ a`, then `legendreSym p a = 1` iff `a` is a square mod `p`. -/
theorem eq_one_iff {a : ℤ} (ha0 : (a : ZMod p) ≠ 0) : legendreSym p a = 1 ↔ IsSquare (a : ZMod p)
-- Mathlib/Data/Set/Sigma.lean
theorem sigma_preimage_left {f : ι' → ι} :
    ((f ⁻¹' s).sigma fun i ↦ t (f i)) = (fun p : Σ i, α (f i) ↦ Sigma.mk _ p.2) ⁻¹' s.sigma t
-- Mathlib/MeasureTheory/Covering/Besicovitch.lean
theorem lastStep_nonempty :
    {i | ¬∃ b : β, p.c b ∉ p.iUnionUpTo i ∧ p.R i ≤ p.τ * p.r b}.Nonempty
-- Mathlib/Algebra/Group/Even.lean
@[to_additive Even.nsmul'] lemma Even.isSquare_pow : Even n → ∀ a : α, IsSquare (a ^ n)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
lemma ofJ_1728_of_three_eq_zero (h3 : (3 : F) = 0) :
    ofJ 1728 = @ofJ1728 _ _ (invertibleOfNonzero <| two_or_three_ne_zero.neg_resolve_right h3)
-- Mathlib/Data/Real/EReal.lean
@[simp]
theorem bot_sub (x : EReal) : ⊥ - x = ⊥
-- Mathlib/Algebra/Ring/Pi.lean
/-- Ring homomorphism between the function spaces `I → α` and `I → β`, induced by a ring
homomorphism `f` between `α` and `β`. -/
@[simps]
protected def RingHom.compLeft {α β : Type*} [NonAssocSemiring α] [NonAssocSemiring β]
    (f : α →+* β) (I : Type*) : (I → α) →+* I → β
-- Mathlib/NumberTheory/NumberField/FractionalIdeal.lean
theorem basisOfFractionalIdeal_apply (I : (FractionalIdeal (𝓞 K)⁰ K)ˣ)
    (i : Free.ChooseBasisIndex ℤ I) :
    basisOfFractionalIdeal K I i = fractionalIdealBasis K I.1 i
-- Mathlib/MeasureTheory/Covering/Besicovitch.lean
/-- The **measurable Besicovitch covering theorem**. Assume that, for any `x` in a set `s`,
one is given a set of admissible closed balls centered at `x`, with arbitrarily small radii.
Then there exists a disjoint covering of almost all `s` by admissible closed balls centered at some
points of `s`.
This version requires that the underlying measure is finite, and that the space has the Besicovitch
covering property (which is satisfied for instance by normed real vector spaces). It expresses the
conclusion in a slightly awkward form (with a subset of `α × ℝ`) coming from the proof technique.
For a version assuming that the measure is sigma-finite,
see `exists_disjoint_closedBall_covering_ae_aux`.
For a version giving the conclusion in a nicer form, see `exists_disjoint_closedBall_covering_ae`.
-/
theorem exists_disjoint_closedBall_covering_ae_of_finiteMeasure_aux (μ : Measure α)
    [IsFiniteMeasure μ] (f : α → Set ℝ) (s : Set α)
    (hf : ∀ x ∈ s, ∀ δ > 0, (f x ∩ Ioo 0 δ).Nonempty) :
    ∃ t : Set (α × ℝ), t.Countable ∧ (∀ p ∈ t, p.1 ∈ s) ∧ (∀ p ∈ t, p.2 ∈ f p.1) ∧
      μ (s \ ⋃ (p : α × ℝ) (_ : p ∈ t), closedBall p.1 p.2) = 0 ∧
        t.PairwiseDisjoint fun p => closedBall p.1 p.2
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem not_not_of_not_imp : ¬(a → b) → ¬¬a
-- Mathlib/MeasureTheory/Measure/Complex.lean
/-- The complex measures form a linear isomorphism to the type of pairs of signed measures. -/
@[simps]
def equivSignedMeasureₗ : ComplexMeasure α ≃ₗ[R] SignedMeasure α × SignedMeasure α
-- Mathlib/Topology/Category/CompHausLike/Limits.lean
@[reassoc (attr := simp)]
lemma finiteCoproduct.ι_desc {B : CompHausLike P} (e : (a : α) → (X a ⟶ B)) (a : α) :
    finiteCoproduct.ι X a ≫ finiteCoproduct.desc X e = e a
-- Mathlib/Algebra/DirectLimit.lean
lemma congr_symm_apply_of [IsDirected ι (· ≤ ·)]
    (e : (i : ι) → G i ≃+ G' i)
    (he : ∀ i j h, (e j).toAddMonoidHom.comp (f i j h) = (f' i j h).comp (e i))
    {i : ι} (g : G' i) :
    (congr e he).symm (of G' f' i g) = of G f i ((e i).symm g)
-- Mathlib/RingTheory/AdjoinRoot.lean
/-- The power basis `1, root f, ..., root f ^ (d - 1)` for `AdjoinRoot f`,
where `f` is an irreducible polynomial over a field of degree `d`. -/
@[simps!]  -- Porting note: was `[simps]`
def powerBasis (hf : f ≠ 0) : PowerBasis K (AdjoinRoot f)
-- Mathlib/Algebra/BigOperators/Finprod.lean
@[to_additive]
theorem finprod_mem_inter_mul_diff' (t : Set α) (h : (s ∩ mulSupport f).Finite) :
    ((∏ᶠ i ∈ s ∩ t, f i) * ∏ᶠ i ∈ s \ t, f i) = ∏ᶠ i ∈ s, f i
-- Mathlib/CategoryTheory/Sites/Coverage.lean
lemma isSheafFor_of_factorsThru
    {X : C} {S T : Presieve X}
    (P : Cᵒᵖ ⥤ Type*)
    (H : S.FactorsThru T) (hS : S.IsSheafFor P)
    (h : ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, T f → ∃ (R : Presieve Y),
      R.IsSeparatedFor P ∧ R.FactorsThruAlong S f) :
    T.IsSheafFor P
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
/-- Homotopy between morphisms of short complexes is compatible with postcomposition. -/
@[simps]
def compRight (h : Homotopy φ₁ φ₂) (ψ : S₂ ⟶ S₃) : Homotopy (φ₁ ≫ ψ) (φ₂ ≫ ψ)
-- Mathlib/CategoryTheory/Subobject/Basic.lean
@[reassoc (attr := simp)]
theorem underlying_arrow {X : C} {Y Z : Subobject X} (f : Y ⟶ Z) :
    underlying.map f ≫ arrow Z = arrow Y
-- Mathlib/Combinatorics/Quiver/Push.lean
theorem lift_comp : (of σ ⋙q lift σ φ τ h) = φ
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)] theorem swap_inl (x : M) : swap M N (inl x) = inr x
-- Mathlib/CategoryTheory/GradedObject.lean
/-- The natural isomorphism comparing between
pulling back along two propositionally equal functions.
-/
@[simps]
def comapEq {β γ : Type w} {f g : β → γ} (h : f = g) : comap C f ≅ comap C g
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
theorem isUnit_iff_mulRight_bijective {a : M} :
    IsUnit a ↔ Function.Bijective (· * a)
-- Mathlib/Data/TypeVec.lean
theorem id_eq_nilFun {α : TypeVec 0} : @id _ α = nilFun
-- Mathlib/Topology/Semicontinuous.lean
theorem lowerSemicontinuous_const : LowerSemicontinuous fun _x : α => z
-- Mathlib/Algebra/FreeMonoid/Basic.lean
@[to_additive (attr := simp)]
theorem lift_restrict (f : FreeMonoid α →* M) : lift (f ∘ of) = f
-- Mathlib/RingTheory/PrincipalIdealDomain.lean
theorem span_gcd : Ideal.span {gcd x y} = Ideal.span {x, y}
-- Mathlib/Tactic/Lift.lean
/-- A class specifying that you can lift elements from `α` to `β` assuming `cond` is true.
  Used by the tactic `lift`. -/
class CanLift (α β : Sort*) (coe : outParam <| β → α) (cond : outParam <| α → Prop) : Prop where
  /-- An element of `α` that satisfies `cond` belongs to the range of `coe`. -/
  prf : ∀ x : α, cond x → ∃ y : β, coe y = x
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
@[simp]
theorem comap_exp_nhds_zero : comap exp (𝓝 0) = atBot
-- Mathlib/CategoryTheory/Functor/EpiMono.lean
@[simp]
theorem mono_map_iff_mono [hF₁ : PreservesMonomorphisms F] [hF₂ : ReflectsMonomorphisms F] :
    Mono (F.map f) ↔ Mono f
-- Mathlib/Data/Real/GoldenRatio.lean
/-- As expected, the Fibonacci sequence is a solution of `fibRec`. -/
theorem fib_isSol_fibRec : fibRec.IsSolution (fun x => x.fib : ℕ → α)
-- Mathlib/Data/Finset/Union.lean
@[simp, norm_cast]
lemma coe_biUnion : (s.biUnion t : Set β) = ⋃ x ∈ (s : Set α), t x
-- Mathlib/Order/Interval/Set/WithBotTop.lean
theorem image_coe_Ici : (some : α → WithBot α) '' Ici a = Ici (a : WithBot α)
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
theorem Matrix.mulVec_stdBasis [DecidableEq n] (M : Matrix m n R) (i j) :
    (M *ᵥ LinearMap.stdBasis R (fun _ ↦ R) j 1) i = M i j
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem measurePreserving_piUnique {π : ι → Type*} [Unique ι] {m : ∀ i, MeasurableSpace (π i)}
    (μ : ∀ i, Measure (π i)) :
    MeasurePreserving (MeasurableEquiv.piUnique π) (Measure.pi μ) (μ default)
-- Mathlib/Order/Filter/Basic.lean
theorem generate_empty : Filter.generate ∅ = (⊤ : Filter α)
-- Mathlib/GroupTheory/Commensurable.lean
theorem eq {H K : Subgroup G} (hk : Commensurable H K) : commensurator H = commensurator K
-- Mathlib/Algebra/MvPolynomial/Cardinal.lean
@[simp]
theorem cardinal_mk_eq_lift [IsEmpty σ] : #(MvPolynomial σ R) = Cardinal.lift.{u} #R
-- Mathlib/Data/Sym/Basic.lean
@[simp]
theorem attach_nil : (nil : Sym α 0).attach = nil
-- Mathlib/CategoryTheory/EqToHom.lean
/-- Reducible form of `congrArg_mpr_hom_right` -/
@[simp]
theorem congrArg_cast_hom_right {X Y Z : C} (p : X ⟶ Y) (q : Z = Y) :
    cast (congrArg (fun W : C => X ⟶ W) q.symm) p = p ≫ eqToHom q.symm
-- Mathlib/Analysis/SpecialFunctions/CompareExp.lean
theorem of_boundedUnder_im (hre : Tendsto re l atTop) (him_le : IsBoundedUnder (· ≤ ·) l im)
    (him_ge : IsBoundedUnder (· ≥ ·) l im) : IsExpCmpFilter l
-- Mathlib/Analysis/Convex/Intrinsic.lean
theorem intrinsicClosure_subset_affineSpan : intrinsicClosure 𝕜 s ⊆ affineSpan 𝕜 s
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
theorem fderiv_add_const (c : F) : fderiv 𝕜 (fun y => f y + c) x = fderiv 𝕜 f x
-- Mathlib/RingTheory/PowerBasis.lean
theorem aeval_minpolyGen (pb : PowerBasis A S) : aeval pb.gen (minpolyGen pb) = 0
-- Mathlib/Data/Finsupp/Defs.lean
/-- Coercion from a `Finsupp` to a function type is an `AddMonoidHom`. -/
@[simps]
noncomputable def coeFnAddHom : (α →₀ M) →+ α → M
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[to_additive]
theorem Measurable.mul_iff_left {G : Type*} [MeasurableSpace G] [MeasurableSpace α] [CommGroup G]
    [MeasurableMul₂ G] [MeasurableInv G] {f g : α → G} (hf : Measurable f) :
    Measurable (g * f) ↔ Measurable g
-- Mathlib/RingTheory/OreLocalization/Basic.lean
/-- A characterization of the addition on the Ore localizaion, allowing for arbitrary Ore
numerator and Ore denominator. -/
theorem oreDiv_add_char {r r' : X} (s s' : S) (rb : R) (sb : S) (h : sb * s = rb * s') :
    r /ₒ s + r' /ₒ s' = (sb • r + rb • r') /ₒ (sb * s)
-- Mathlib/NumberTheory/DirichletCharacter/Basic.lean
lemma conductor_one_dvd (n : ℕ) : conductor (1 : DirichletCharacter R 1) ∣ n
-- Mathlib/Combinatorics/Additive/Corner/Defs.lean
lemma isCornerFree_empty : IsCornerFree (∅ : Set (G × G))
-- Mathlib/MeasureTheory/Measure/Regular.lean
/-- If a measure `μ` admits finite spanning open sets such that the restriction of `μ` to each set
is outer regular, then the original measure is outer regular as well. -/
protected theorem FiniteSpanningSetsIn.outerRegular [OpensMeasurableSpace α] {μ : Measure α}
    (s : μ.FiniteSpanningSetsIn { U | IsOpen U ∧ OuterRegular (μ.restrict U) }) :
    OuterRegular μ
-- Mathlib/Topology/Bornology/BoundedOperation.lean
lemma isBounded_sub [Bornology R] [Sub R] [BoundedSub R] {s t : Set R}
    (hs : Bornology.IsBounded s) (ht : Bornology.IsBounded t) :
    Bornology.IsBounded (s - t)
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem toMeasureOfLEZero_apply (hi : s ≤[i] 0) (hi₁ : MeasurableSet i) (hj₁ : MeasurableSet j) :
    s.toMeasureOfLEZero i hi₁ hi j = ((↑) : ℝ≥0 → ℝ≥0∞) ⟨-s (i ∩ j), neg_apply s (i ∩ j) ▸
      nonneg_of_zero_le_restrict _ (zero_le_restrict_subset _ hi₁ Set.inter_subset_left
      (@neg_zero (VectorMeasure α ℝ) _ ▸ neg_le_neg _ _ hi₁ hi))⟩
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem Nat.succ.injEq (u v : Nat) : (u.succ = v.succ) = (u = v)
-- Mathlib/Algebra/BigOperators/Group/Multiset.lean
@[to_additive]
theorem prod_map_one : prod (m.map fun _ => (1 : α)) = 1
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem mulVec_zero [Fintype n] (A : Matrix m n α) : A *ᵥ 0 = 0
-- Mathlib/Algebra/Order/Hom/Monoid.lean
@[to_additive (attr := simp)]
theorem comp_apply (f : β →*o γ) (g : α →*o β) (a : α) : (f.comp g) a = f (g a)
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem mem_bot : a ∈ (⊥ : UpperSet α)
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem DifferentiableOn.hasDerivAt (h : DifferentiableOn 𝕜 f s) (hs : s ∈ 𝓝 x) :
    HasDerivAt f (deriv f x) x
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive (attr := simp) nsmul_eq_smul]
theorem npow_eq_pow (n : ℕ) (x : M) : Monoid.npow n x = x ^ n
-- Mathlib/Algebra/Quaternion.lean
theorem mul_coe_eq_smul : a * r = r • a
-- Mathlib/Algebra/Star/Subalgebra.lean
theorem star_subset_adjoin (s : Set A) : star s ⊆ adjoin R s
-- Mathlib/Topology/Basic.lean
theorem mem_closure_iff_nhds_basis' {p : ι → Prop} {s : ι → Set X} (h : (𝓝 x).HasBasis p s) :
    x ∈ closure t ↔ ∀ i, p i → (s i ∩ t).Nonempty
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
protected theorem LocallyIntegrable.sub (hf : LocallyIntegrable f μ) (hg : LocallyIntegrable g μ) :
    LocallyIntegrable (f - g) μ
-- Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean
@[to_additive]
theorem one_min (a : α) : min 1 a = 1
-- Mathlib/Order/Ideal.lean
theorem lt_sup_principal_of_not_mem (hx : x ∉ I) : I < I ⊔ principal x
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem one_le_rpow {x : ℝ≥0∞} {z : ℝ} (hx : 1 ≤ x) (hz : 0 < z) : 1 ≤ x ^ z
-- Mathlib/Data/Set/Lattice.lean
lemma kernImage_eq_compl {s : Set α} : kernImage f s = (f '' sᶜ)ᶜ
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
/--
Accessing bits in `x.rotateRight r` the range `[w-r, w)` is equal to
accessing bits `x` in the range `[0, r)`.

Proof by example:
Let x := <6 5 4 3 2 1 0> : BitVec 7.
x.rotateRight 2 = (<6 5 4 3 2 | 1 0>).rotateRight 2 = <1 0 | 6 5 4 3 2>

(x.rotateLeft 2).getLsb ⟨i, i ≥ 7 - 2⟩
= <1 0 | 6 5 4 3 2>.getLsb ⟨i, i ≤ 7 - 2⟩
= <1 0>.getLsb (i - len(<6 5 4 3 2>)
= <6 5 4 3 2 | 1 0> (i - len<6 4 4 3 2>)
 -/
theorem getLsb_rotateRightAux_of_geq {x : BitVec w} {r : Nat} {i : Nat} (hi : i ≥ w - r) :
    (x.rotateRightAux r).getLsb i = (decide (i < w) && x.getLsb (i - (w - r)))
-- Mathlib/Order/UpperLower/Basic.lean
theorem IsUpperSet.preimage (hs : IsUpperSet s) {f : β → α} (hf : Monotone f) :
    IsUpperSet (f ⁻¹' s : Set β)
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma closedEmbedding_cfcₙHom_of_cfcHom {a : A} (ha : p a) :
    ClosedEmbedding (cfcₙHom_of_cfcHom R ha)