ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Real/EReal.lean
@[simp, norm_cast]
protected theorem coe_neg' {x : ℝ} : (x : EReal) < 0 ↔ x < 0
-- Mathlib/Data/List/Basic.lean
theorem erase_diff_erase_sublist_of_sublist {a : α} :
    ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → (l₂.erase a).diff (l₁.erase a) <+ l₂.diff l₁
-- Mathlib/Data/Multiset/Dedup.lean
@[simp]
theorem dedup_subset' {s t : Multiset α} : dedup s ⊆ t ↔ s ⊆ t
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
@[simp]
theorem mop_id {X : C} : (𝟙 X).mop = 𝟙 (mop X)
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.disjoint_iff_left (h : l.HasBasis p s) :
    Disjoint l l' ↔ ∃ i, p i ∧ (s i)ᶜ ∈ l'
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
@[simp]
lemma isClique_insert : G.IsClique (insert a s) ↔ G.IsClique s ∧ ∀ b ∈ s, a ≠ b → G.Adj a b
-- Mathlib/Topology/Order/LeftRightNhds.lean
theorem mem_nhdsWithin_Iic_iff_exists_mem_Ico_Ioc_subset {a l' : α} {s : Set α} (hl' : l' < a) :
    s ∈ 𝓝[≤] a ↔ ∃ l ∈ Ico l' a, Ioc l a ⊆ s
-- Mathlib/Data/NNRat/Defs.lean
@[simp]
theorem toNNRat_eq_zero : toNNRat q = 0 ↔ q ≤ 0
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem IsStrongLimit.ne_zero {c} (h : IsStrongLimit c) : c ≠ 0
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
theorem mul_coeff_right' [NonUnitalNonAssocSemiring R] {x y : HahnSeries Γ R} {a : Γ} {s : Set Γ}
    (hs : s.IsPWO) (hys : y.support ⊆ s) :
    (x * y).coeff a =
      ∑ ij ∈ addAntidiagonal x.isPWO_support hs a, x.coeff ij.fst * y.coeff ij.snd
-- Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean
theorem IsTheta.rpow (hr : 0 ≤ r) (hf : 0 ≤ᶠ[l] f) (hg : 0 ≤ᶠ[l] g) (h : f =Θ[l] g) :
    (fun x => f x ^ r) =Θ[l] fun x => g x ^ r
-- Mathlib/CategoryTheory/Monad/Equalizer.lean
/-- The top map in the equalizer diagram we will construct. -/
@[simps!]
def CofreeEqualizer.topMap :  (Comonad.cofree T).obj X.A ⟶ (Comonad.cofree T).obj (T.obj X.A)
-- Mathlib/Topology/PartialHomeomorph.lean
theorem trans_apply {x : X} : (e.trans e') x = e' (e x)
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Iso.lean
theorem hasPushout_of_left_iso : HasPushout f g
-- Mathlib/Data/Finset/Pointwise.lean
@[simp] lemma inv_smul_finset_distrib₀ (a : α) (s : Finset α) : (a • s)⁻¹ = op a⁻¹ • s⁻¹
-- Mathlib/Topology/Bornology/Basic.lean
@[simp]
theorem isCobounded_inter : IsCobounded (s ∩ t) ↔ IsCobounded s ∧ IsCobounded t
-- Mathlib/Data/DFinsupp/Basic.lean
lemma prod_ne_zero_iff : f.prod g ≠ 0 ↔ ∀ i ∈ f.support, g i (f i) ≠ 0
-- Mathlib/LinearAlgebra/AffineSpace/Basis.lean
@[simp]
theorem sum_coord_apply_eq_one [Fintype ι] (q : P) : ∑ i, b.coord i q = 1
-- Mathlib/Order/SupClosed.lean
@[simp] lemma infClosure_univ : infClosure (Set.univ : Set α) = Set.univ
-- Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean
theorem hasTerminal_of_hasInitial_op [HasInitial Cᵒᵖ] : HasTerminal C
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
theorem trim_sum_ge {ι} (m : ι → OuterMeasure α) : (sum fun i => (m i).trim) ≤ (sum m).trim
-- Mathlib/Order/UpperLower/Basic.lean
theorem IsLowerSet.Iio_subset (h : IsLowerSet s) ⦃a⦄ (ha : a ∈ s) : Iio a ⊆ s
-- Mathlib/Analysis/Convex/Function.lean
/-- For a function on a convex set in a linearly ordered space (where the order and the algebraic
structures aren't necessarily compatible), in order to prove that it is concave it suffices to
verify the inequality `a • f x + b • f y ≤ f (a • x + b • y)` for `x < y` and positive `a`, `b`. The
main use case is `E = ℝ` however one can apply it, e.g., to `ℝ^n` with lexicographic order. -/
theorem LinearOrder.concaveOn_of_lt (hs : Convex 𝕜 s)
    (hf : ∀ ⦃x⦄, x ∈ s → ∀ ⦃y⦄, y ∈ s → x < y → ∀ ⦃a b : 𝕜⦄, 0 < a → 0 < b → a + b = 1 →
      a • f x + b • f y ≤ f (a • x + b • y)) :
    ConcaveOn 𝕜 s f
-- Mathlib/SetTheory/Cardinal/ENat.lean
@[simp] lemma ofENat_eq_lift {x : Cardinal.{v}} {m : ℕ∞} : m = lift.{u} x ↔ m = x
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem MDifferentiable.mfderivWithin (h : MDifferentiableAt I I' f x)
    (hxs : UniqueMDiffWithinAt I s x) : mfderivWithin I I' f s x = mfderiv I I' f x
-- Mathlib/LinearAlgebra/AffineSpace/Independent.lean
/-- A family with at most one point is affinely independent. -/
theorem affineIndependent_of_subsingleton [Subsingleton ι] (p : ι → P) : AffineIndependent k p
-- Mathlib/Algebra/Homology/ComplexShape.lean
lemma next_eq_self (c : ComplexShape ι) (j : ι) (hj : ¬ c.Rel j (c.next j)) :
    c.next j = j
-- Mathlib/Data/Int/Cast/Prod.lean
@[simp]
theorem fst_intCast (n : ℤ) : (n : α × β).fst = n
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
/-- Data exhibiting that a given factorisation through a mono is initial. -/
structure IsImage (F : MonoFactorisation f) where
  lift : ∀ F' : MonoFactorisation f, F.I ⟶ F'.I
  lift_fac : ∀ F' : MonoFactorisation f, lift F' ≫ F'.m = F.m := by aesop_cat
-- Mathlib/Topology/Compactness/Compact.lean
@[simp]
theorem isCompact_empty : IsCompact (∅ : Set X)
-- Mathlib/Data/NNRat/Defs.lean
@[simp, norm_cast]
theorem coe_add (p q : ℚ≥0) : ((p + q : ℚ≥0) : ℚ) = p + q
-- Mathlib/Data/Nat/GCD/Basic.lean
theorem Coprime.mul_add_mul_ne_mul {m n a b : ℕ} (cop : Coprime m n) (ha : a ≠ 0) (hb : b ≠ 0) :
    a * m + b * n ≠ m * n
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/Indicator.lean
/-- The conditional expectation of the indicator of a function over an `m`-measurable set with
respect to the σ-algebra `m` is a.e. equal to the indicator of the conditional expectation. -/
theorem condexp_indicator (hf_int : Integrable f μ) (hs : MeasurableSet[m] s) :
    μ[s.indicator f|m] =ᵐ[μ] s.indicator (μ[f|m])
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
theorem trim_eq_iInf (s : Set α) : m.trim s = ⨅ (t) (_ : s ⊆ t) (_ : MeasurableSet t), m t
-- Mathlib/Order/Directed.lean
/-- An antitone function on a downwards-directed type is directed. -/
theorem directed_of_isDirected_ge [LE α] [IsDirected α (· ≥ ·)] {r : β → β → Prop} {f : α → β}
    (hf : ∀ a₁ a₂, a₁ ≤ a₂ → r (f a₂) (f a₁)) : Directed r f
-- Mathlib/Topology/Baire/Lemmas.lean
/-- One of the most useful consequences of Baire theorem: if a countable union of closed sets
covers the space, then one of the sets has nonempty interior. -/
theorem nonempty_interior_of_iUnion_of_closed [Nonempty X] [Countable ι] {f : ι → Set X}
    (hc : ∀ i, IsClosed (f i)) (hU : ⋃ i, f i = univ) : ∃ i, (interior <| f i).Nonempty
-- Mathlib/Topology/Order.lean
@[continuity, fun_prop]
theorem continuous_top {t : TopologicalSpace α} : Continuous[t, ⊤] f
-- Mathlib/Order/Iterate.lean
theorem iterate_le_of_map_le (h : Commute f g) (hf : Monotone f) (hg : Monotone g) {x}
    (hx : f x ≤ g x) (n : ℕ) : f^[n] x ≤ g^[n] x
-- Mathlib/Analysis/Convex/Strict.lean
theorem strictConvex_iff_ordConnected : StrictConvex 𝕜 s ↔ s.OrdConnected
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem rootMultiplicity_eq_rootMultiplicity {p : R[X]} {t : R} :
    p.rootMultiplicity t = (p.comp (X + C t)).rootMultiplicity 0
-- Mathlib/Algebra/Module/Submodule/Basic.lean
theorem copy_eq (S : Submodule R M) (s : Set M) (hs : s = ↑S) : S.copy s hs = S
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
@[reassoc (attr := simp)]
lemma cyclesIsoLeftHomology_inv_hom_id (hf : S.f = 0) :
    (S.cyclesIsoLeftHomology hf).inv ≫ S.leftHomologyπ = 𝟙 _
-- Mathlib/Algebra/CharP/Defs.lean
lemma char_ne_one [Nontrivial R] (p : ℕ) [hc : CharP R p] : p ≠ 1
-- Mathlib/Order/BoundedOrder.lean
theorem not_isTop_iff_ne_top : ¬IsTop a ↔ a ≠ ⊤
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
@[simp]
theorem arsinh_neg (x : ℝ) : arsinh (-x) = -arsinh x
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem enumFrom_nil : ([] : List α).enumFrom i = []
-- Mathlib/Data/Bool/Basic.lean
theorem eq_true_of_not_eq_false' {a : Bool} : !a = false → a = true
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem mul_le_mul_of_nonpos_of_nonpos [ExistsAddOfLE α] [MulPosMono α] [PosMulMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hca : c ≤ a) (hdb : d ≤ b) (hc : c ≤ 0) (hb : b ≤ 0) : a * b ≤ c * d
-- Mathlib/Data/Sum/Interval.lean
@[simp]
lemma Ioo_inr_inl : Ioo (inrₗ b) (inlₗ a) = ∅
-- Mathlib/RingTheory/AdicCompletion/Functoriality.lean
@[simp]
theorem map_id : map I (LinearMap.id (M := M)) = LinearMap.id
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
lemma Set.Iic_ciInf [Nonempty ι] {f : ι → α} (hf : BddBelow (range f)) :
    Iic (⨅ i, f i) = ⋂ i, Iic (f i)
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Images.lean
@[reassoc]
theorem factorThruImage_comp_hom {X Y : A} (f : X ⟶ Y) :
    factorThruImage (L.map f) ≫ (iso L f).hom = L.map (factorThruImage f)
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem map_comap_eq_self_of_surjective
    {f : R →+* S} (hf : Function.Surjective f) (t : Subring S) : (t.comap f).map f = t
-- Mathlib/Data/PEquiv.lean
/-- If the domain of a `PEquiv` is `α` except a point, its forward direction is injective. -/
theorem injective_of_forall_ne_isSome (f : α ≃. β) (a₂ : α)
    (h : ∀ a₁ : α, a₁ ≠ a₂ → isSome (f a₁)) : Injective f
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem fin_two_eq_of_eq_zero_iff : ∀ {a b : Fin 2}, (a = 0 ↔ b = 0) → a = b
-- Mathlib/Order/Monotone/Basic.lean
theorem antitone_app (f : β → α → γ) (b : β) (hf : Antitone fun a b ↦ f b a) : Antitone (f b)
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
theorem norm_const (q : ℚ) : norm (const (padicNorm p) q) = padicNorm p q
-- Mathlib/Data/Nat/Digits.lean
theorem digits_add_two_add_one (b n : ℕ) :
    digits (b + 2) (n + 1) = ((n + 1) % (b + 2)) :: digits (b + 2) ((n + 1) / (b + 2))
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Prod.lean
theorem _root_.ContinuousOn.prod_mapL {f : X → M₁ →L[𝕜] M₂} {g : X → M₃ →L[𝕜] M₄} {s : Set X}
    (hf : ContinuousOn f s) (hg : ContinuousOn g s) :
    ContinuousOn (fun x => (f x).prodMap (g x)) s
-- Mathlib/Order/Partition/Finpartition.lean
theorem parts_top_subsingleton (a : α) [Decidable (a = ⊥)] :
    ((⊤ : Finpartition a).parts : Set α).Subsingleton
-- Mathlib/Topology/Irreducible.lean
theorem exists_preirreducible (s : Set X) (H : IsPreirreducible s) :
    ∃ t : Set X, IsPreirreducible t ∧ s ⊆ t ∧ ∀ u, IsPreirreducible u → t ⊆ u → u = t
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem UInt16.toNat_zero : (0 : UInt16).toNat = 0
-- Mathlib/Order/Minimal.lean
@[simp]
theorem maximals_singleton : maximals r {a} = {a}
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem sup_eq_lsub {ι : Type u} (f : ι → Ordinal.{max u v}) :
    sup.{_, v} (succ ∘ f) = lsub.{_, v} f
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem C_mul_X_pow_eq_monomial {s : σ} {a : R} {n : ℕ} :
    C a * X s ^ n = monomial (Finsupp.single s n) a
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[simp]
theorem zeta_apply {x : ℕ} : ζ x = if x = 0 then 0 else 1
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem abs_cpow_eq_rpow_re_of_nonneg {x : ℝ} (hx : 0 ≤ x) {y : ℂ} (hy : re y ≠ 0) :
    abs (x ^ y) = x ^ re y
-- Mathlib/Order/Disjoint.lean
theorem Disjoint.of_disjoint_inf_of_le (h : Disjoint (a ⊓ b) c) (hle : a ≤ c) : Disjoint a b
-- Mathlib/NumberTheory/Padics/PadicNorm.lean
/-- The `p`-adic norm of an integer is at most `1`. -/
protected theorem of_int (z : ℤ) : padicNorm p z ≤ 1
-- Mathlib/Logic/Basic.lean
theorem Decidable.ne_or_eq {α : Sort*} (x y : α) [Decidable (x = y)] : x ≠ y ∨ x = y
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[measurability]
theorem Measurable.const_pow (hg : Measurable g) (c : β) : Measurable fun x => c ^ g x
-- Mathlib/Probability/Kernel/CondDistrib.lean
theorem condexp_ae_eq_integral_condDistrib_id [NormedSpace ℝ F] [CompleteSpace F] {X : Ω → β}
    {μ : Measure Ω} [IsFiniteMeasure μ] (hX : Measurable X) {f : Ω → F} (hf_int : Integrable f μ) :
    μ[f|mβ.comap X] =ᵐ[μ] fun a => ∫ y, f y ∂condDistrib id X μ (X a)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem eq_or_lt_of_not_lt {a b : Nat} (hnlt : ¬ a < b) : a = b ∨ b < a
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
/-- The elements of `A.nonunits` are those of the maximal ideal of `A`.

See also `coe_mem_nonunits_iff`, which has a simpler right hand side but requires the element
to be in `A` already.
 -/
theorem mem_nonunits_iff_exists_mem_maximalIdeal {a : K} :
    a ∈ A.nonunits ↔ ∃ ha, (⟨a, ha⟩ : A) ∈ LocalRing.maximalIdeal A
-- Mathlib/Order/Hom/Basic.lean
protected theorem wellFounded (f : α ↪o β) :
    WellFounded ((· < ·) : β → β → Prop) → WellFounded ((· < ·) : α → α → Prop)
-- Mathlib/FieldTheory/Adjoin.lean
/-- If `E / F` is a finite extension such that `E = F(α)`, then for any intermediate field `K`, the
`F` adjoin the coefficients of `minpoly K α` is equal to `K` itself. -/
theorem adjoin_minpoly_coeff_of_exists_primitive_element
    [FiniteDimensional F E] (hprim : adjoin F {α} = ⊤) (K : IntermediateField F E) :
    adjoin F ((minpoly K α).map (algebraMap K E)).coeffs = K
-- Mathlib/Algebra/Order/ToIntervalMod.lean
private theorem toIxxMod_total (a b c : α) :
    toIcoMod hp a b ≤ toIocMod hp a c ∨ toIcoMod hp c b ≤ toIocMod hp c a
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
/-- Given a prepartition `π` of a box `I` and a collection of prepartitions `πi J` of all boxes
`J ∈ π`, returns the prepartition of `I` into the union of the boxes of all `πi J`.

Though we only use the values of `πi` on the boxes of `π`, we require `πi` to be a globally defined
function. -/
@[simps]
def biUnion (πi : ∀ J : Box ι, Prepartition J) : Prepartition I
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
protected theorem sub (hf : UnifIntegrable f p μ) (hg : UnifIntegrable g p μ) (hp : 1 ≤ p)
    (hf_meas : ∀ i, AEStronglyMeasurable (f i) μ) (hg_meas : ∀ i, AEStronglyMeasurable (g i) μ) :
    UnifIntegrable (f - g) p μ
-- Mathlib/RingTheory/Kaehler/Basic.lean
theorem KaehlerDifferential.tensorProductTo_surjective :
    Function.Surjective (KaehlerDifferential.D R S).tensorProductTo
-- Mathlib/Order/Filter/Bases.lean
protected theorem HasAntitoneBasis.map {l : Filter α} {s : ι'' → Set α}
    (hf : HasAntitoneBasis l s) (m : α → β) : HasAntitoneBasis (map m l) (m '' s ·)
-- Mathlib/Algebra/Lie/IdealOperations.lean
theorem comap_bracket_incl {I₁ I₂ : LieIdeal R L} :
    ⁅comap I.incl I₁, comap I.incl I₂⁆ = comap I.incl ⁅I ⊓ I₁, I ⊓ I₂⁆
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
@[simp]
theorem smul_bot (a : α) : a • (⊥ : AddSubmonoid A) = ⊥
-- Mathlib/AlgebraicTopology/DoldKan/GammaCompN.lean
@[simp]
theorem N₁Γ₀_inv_app_f_f (K : ChainComplex C ℕ) (n : ℕ) :
    (N₁Γ₀.inv.app K).f.f n = (Γ₀.splitting K).toKaroubiNondegComplexIsoN₁.hom.f.f n
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[ext]
theorem ext (p q : MvPolynomial σ R) : (∀ m, coeff m p = coeff m q) → p = q
-- Mathlib/Topology/Connected/Clopen.lean
theorem IsClopen.connectedComponent_subset {x} (hs : IsClopen s) (hx : x ∈ s) :
    connectedComponent x ⊆ s
-- Mathlib/LinearAlgebra/FreeModule/PID.lean
@[simp]
theorem Ideal.smithCoeffs_ne_zero (b : Basis ι R S) (I : Ideal S) (hI : I ≠ ⊥) (i) :
    Ideal.smithCoeffs b I hI i ≠ 0
-- Mathlib/RingTheory/AlgebraicIndependent.lean
theorem algebraicIndependent_image {ι} {s : Set ι} {f : ι → A} (hf : Set.InjOn f s) :
    (AlgebraicIndependent R fun x : s => f x) ↔ AlgebraicIndependent R fun x : f '' s => (x : A)
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem Adapted.measurable_upcrossings (hf : Adapted ℱ f) (hab : a < b) :
    Measurable (upcrossings a b f)
-- Mathlib/Computability/Reduce.lean
@[simp]
theorem of_eq_of {p : α → Prop} {q : β → Prop} : of p = of q ↔ ManyOneEquiv p q
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive (attr := simp)]
theorem singleton_mul : {a} * t = (a * ·) '' t
-- Mathlib/Algebra/Algebra/Spectrum.lean
theorem apply_mem_spectrum [Nontrivial R] (φ : F) (a : A) : φ a ∈ σ a
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma Y_eq_of_equiv {P Q : Fin 3 → R} (h : P ≈ Q) : P y * Q z ^ 3 = Q y * P z ^ 3
-- Mathlib/Dynamics/FixedPoints/Basic.lean
/-- Every point is a fixed point of `id`. -/
theorem isFixedPt_id (x : α) : IsFixedPt id x
-- Mathlib/Algebra/Module/Torsion.lean
@[simp]
theorem torsionOf_zero : torsionOf R M (0 : M) = ⊤
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem ciInf_mem [Nonempty ι] (f : ι → α) : iInf f ∈ range f
-- Mathlib/RingTheory/Polynomial/GaussLemma.lean
/-- If `K = Frac(R)` and `g : K[X]` divides a monic polynomial with coefficients in `R`, then
    `g * (C g.leadingCoeff⁻¹)` has coefficients in `R` -/
theorem IsIntegrallyClosed.eq_map_mul_C_of_dvd [IsIntegrallyClosed R] {f : R[X]} (hf : f.Monic)
    {g : K[X]} (hg : g ∣ f.map (algebraMap R K)) :
    ∃ g' : R[X], g'.map (algebraMap R K) * (C <| leadingCoeff g) = g
-- Mathlib/Order/Interval/Set/Image.lean
lemma AntitoneOn.mapsTo_Iic (h : AntitoneOn f (Iic b)) : MapsTo f (Iic b) (Ici (f b))
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If `r` is a negative constant, `fun x ↦ r * f x` tends to negative infinity along a filter `l`
if and only if `f` tends to infinity along `l`. -/
theorem tendsto_const_mul_atBot_of_neg (hr : r < 0) :
    Tendsto (fun x => r * f x) l atBot ↔ Tendsto f l atTop
-- Mathlib/FieldTheory/IntermediateField.lean
theorem le_extendScalars_iff (E' : IntermediateField F L) :
    E' ≤ extendScalars h ↔ E'.toSubfield ≤ E
-- Mathlib/CategoryTheory/Preadditive/AdditiveFunctor.lean
@[simp]
theorem AdditiveFunctor.ofLeftExact_obj_fst (F : C ⥤ₗ D) :
    ((AdditiveFunctor.ofLeftExact C D).obj F).obj = F.obj
-- Mathlib/Algebra/Order/Group/OrderIso.lean
@[to_additive neg_le]
theorem inv_le' : a⁻¹ ≤ b ↔ b⁻¹ ≤ a
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
@[simp]
theorem csInf_Ioi [NoMaxOrder α] [DenselyOrdered α] : sInf (Ioi a) = a
-- Mathlib/CategoryTheory/Triangulated/Opposite.lean
lemma shiftFunctorAdd'_op_inv_app (X : Cᵒᵖ) (a₁ a₂ a₃ : ℤ) (h : a₁ + a₂ = a₃)
    (b₁ b₂ b₃ : ℤ) (h₁ : a₁ + b₁ = 0) (h₂ : a₂ + b₂ = 0) (h₃ : a₃ + b₃ = 0) :
    (shiftFunctorAdd' Cᵒᵖ a₁ a₂ a₃ h).inv.app X =
      (shiftFunctor Cᵒᵖ a₂).map ((shiftFunctorOpIso C _ _ h₁).hom.app X) ≫
      (shiftFunctorOpIso C _ _ h₂).hom.app _ ≫
      ((shiftFunctorAdd' C b₁ b₂ b₃ (by omega)).hom.app X.unop).op ≫
      (shiftFunctorOpIso C _ _ h₃).inv.app X
-- Mathlib/Order/Hom/Lattice.lean
theorem copy_eq (f : SupHom α β) (f' : α → β) (h : f' = f) : f.copy f' h = f
-- Mathlib/Analysis/Complex/AbelLimit.lean
/-- **Abel's limit theorem**. Given a power series converging at 1, the corresponding function
is continuous at 1 when approaching 1 within any fixed Stolz cone. -/
theorem tendsto_tsum_powerSeries_nhdsWithin_stolzCone
    (h : Tendsto (fun n ↦ ∑ i ∈ range n, f i) atTop (𝓝 l)) {s : ℝ} (hs : 0 < s) :
    Tendsto (fun z ↦ ∑' n, f n * z ^ n) (𝓝[stolzCone s] 1) (𝓝 l)
-- Mathlib/Topology/VectorBundle/Basic.lean
@[simp, mfld_simps]
theorem trivializationAt_continuousLinearMapAt {b₀ b : B}
    (hb : b ∈ (trivializationAt F Z.Fiber b₀).baseSet) :
    (trivializationAt F Z.Fiber b₀).continuousLinearMapAt R b =
      Z.coordChange (Z.indexAt b) (Z.indexAt b₀) b
-- Mathlib/LinearAlgebra/Matrix/IsDiag.lean
/-- Every zero matrix is diagonal. -/
@[simp]
theorem isDiag_zero [Zero α] : (0 : Matrix n n α).IsDiag
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem IsCoprime.mul_left_iff : IsCoprime (x * y) z ↔ IsCoprime x z ∧ IsCoprime y z
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- Given `f : β → ℝ≥0∞`, if `f` sends `{i | p i}` to a set of positive numbers
accumulating to zero, then `f i`-neighborhoods of the diagonal form a basis of `𝓤 α`.

For specific bases see `uniformity_basis_edist`, `uniformity_basis_edist'`,
`uniformity_basis_edist_nnreal`, and `uniformity_basis_edist_inv_nat`. -/
protected theorem EMetric.mk_uniformity_basis {β : Type*} {p : β → Prop} {f : β → ℝ≥0∞}
    (hf₀ : ∀ x, p x → 0 < f x) (hf : ∀ ε, 0 < ε → ∃ x, p x ∧ f x ≤ ε) :
    (𝓤 α).HasBasis p fun x => { p : α × α | edist p.1 p.2 < f x }
-- Mathlib/Topology/Inseparable.lean
lemma stableUnderSpecialization_sInter (S : Set (Set X))
    (H : ∀ s ∈ S, StableUnderSpecialization s) : StableUnderSpecialization (⋂₀ S)
-- Mathlib/Algebra/Ring/Subring/MulOpposite.lean
theorem op_le_iff {S₁ : Subring R} {S₂ : Subring Rᵐᵒᵖ} : S₁.op ≤ S₂ ↔ S₁ ≤ S₂.unop
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
@[simp] theorem and_zero (x : Nat) : x &&& 0 = 0
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
theorem bot : Ideal.IsHomogeneous 𝒜 ⊥
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
@[simp]
theorem mem_skewAdjointSubmodule (f : Module.End R₁ M₁) :
    f ∈ B₁.skewAdjointSubmodule ↔ B₁.IsSkewAdjoint f
-- Mathlib/RingTheory/Localization/Integer.lean
/-- Each element `a : S` has an `M`-multiple which is an integer.

This version multiplies `a` on the left, matching the argument order in the `SMul` instance.
-/
theorem exists_integer_multiple (a : S) : ∃ b : M, IsInteger R ((b : R) • a)
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean
theorem ext_iff_val (f g : HomogeneousLocalization 𝒜 x) : f = g ↔ f.val = g.val
-- Mathlib/MeasureTheory/Function/L1Space.lean
@[simp]
theorem ContinuousLinearEquiv.integrable_comp_iff {φ : α → H} (L : H ≃L[𝕜] E) :
    Integrable (fun a : α ↦ L (φ a)) μ ↔ Integrable φ μ
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem pointReflection_symm (x : P) : (pointReflection 𝕜 x).symm = pointReflection 𝕜 x
-- Mathlib/Analysis/Normed/Module/FiniteDimension.lean
@[simp]
theorem toAffineIsometryEquiv_apply [Inhabited P₁] (li : P₁ →ᵃⁱ[𝕜] P₂)
    (h : finrank 𝕜 V₁ = finrank 𝕜 V₂) (x : P₁) : (li.toAffineIsometryEquiv h) x = li x
-- Mathlib/FieldTheory/SeparableDegree.lean
/-- A monic irreducible polynomial over a field `F` of exponential characteristic `q` has
separable degree one if and only if it is of the form `X ^ (q ^ n) - C y`
for some `n : ℕ` and `y : F`. -/
theorem natSepDegree_eq_one_iff_of_monic (q : ℕ) [ExpChar F q] (hm : f.Monic)
    (hi : Irreducible f) : f.natSepDegree = 1 ↔ ∃ (n : ℕ) (y : F), f = X ^ q ^ n - C y
-- Mathlib/Logic/Equiv/Defs.lean
theorem comp_injective (f : α → β) (e : β ≃ γ) : Injective (e ∘ f) ↔ Injective f
-- Mathlib/Computability/Primrec.lean
theorem comp {f : β → σ} {g : α → β} (hf : Primrec f) (hg : Primrec g) : Primrec fun a => f (g a)
-- Mathlib/Analysis/Calculus/LineDeriv/Measurable.lean
theorem measurableSet_lineDifferentiableAt (hf : Continuous f) :
    MeasurableSet {x : E | LineDifferentiableAt 𝕜 f x v}
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
nonrec theorem HasFDerivWithinAt.const_smul (h : HasFDerivWithinAt f f' s x) (c : R) :
    HasFDerivWithinAt (fun x => c • f x) (c • f') s x
-- Mathlib/Algebra/GCDMonoid/Finset.lean
theorem gcd_congr {f g : β → α} (hs : s₁ = s₂) (hfg : ∀ a ∈ s₂, f a = g a) :
    s₁.gcd f = s₂.gcd g
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem lcm_eq_right_iff [NormalizedGCDMonoid α] (a b : α) (h : normalize b = b) :
    lcm a b = b ↔ a ∣ b
-- .lake/packages/batteries/Batteries/Data/List/Count.lean
theorem count_concat (a : α) (l : List α) : count a (concat l a) = succ (count a l)
-- Mathlib/LinearAlgebra/Matrix/Block.lean
theorem blockTriangular_diagonal [DecidableEq m] (d : m → R) : BlockTriangular (diagonal d) b
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
@[simp] theorem byteIdx_zero : (0 : Pos).byteIdx = 0
-- Mathlib/Topology/Sets/Opens.lean
theorem comap_mono (f : C(α, β)) {s t : Opens β} (h : s ≤ t) : comap f s ≤ comap f t
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem takeWhile_replicate (p : α → Bool) :
    (replicate n a).takeWhile p = if p a then replicate n a else []
-- Mathlib/Topology/Sets/Opens.lean
theorem iSup_def {ι} (s : ι → Opens α) : ⨆ i, s i = ⟨⋃ i, s i, isOpen_iUnion fun i => (s i).2⟩
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem injective_iff_ker_eq_bot : Function.Injective f ↔ ker f = ⊥
-- Mathlib/CategoryTheory/LiftingProperties/Basic.lean
theorem op (h : HasLiftingProperty i p) : HasLiftingProperty p.op i.op
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem continuousWithinAt_writtenInExtend_iff {f' : PartialHomeomorph M' H'} {g : M → M'} {y : M}
    (hy : y ∈ f.source) (hgy : g y ∈ f'.source) (hmaps : MapsTo g s f'.source) :
    ContinuousWithinAt (f'.extend I' ∘ g ∘ (f.extend I).symm)
      ((f.extend I).symm ⁻¹' s ∩ range I) (f.extend I y) ↔ ContinuousWithinAt g s y