ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
@[reassoc]
theorem comp_coconePointsIsoOfNatIso_hom {F G : J ⥤ C} {s : Cocone F} {t : Cocone G}
    (P : IsColimit s) (Q : IsColimit t) (w : F ≅ G) (j : J) :
    s.ι.app j ≫ (coconePointsIsoOfNatIso P Q w).hom = w.hom.app j ≫ t.ι.app j
-- Mathlib/Analysis/LocallyConvex/Barrelled.lean
theorem Seminorm.continuous_iSup
    {ι : Sort*} {𝕜 E : Type*} [NormedField 𝕜]  [AddCommGroup E] [Module 𝕜 E]
    [TopologicalSpace E] [BarrelledSpace 𝕜 E] (p : ι → Seminorm 𝕜 E)
    (hp : ∀ i, Continuous (p i)) (bdd : BddAbove (range p)) :
    Continuous (⨆ i, p i)
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem nonneg_of_mul_nonneg_right [PosMulStrictMono α]
    (h : 0 ≤ a * b) (ha : 0 < a) : 0 ≤ b
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
protected theorem pow_mem {x : A} (hx : x ∈ S) (n : ℕ) : x ^ n ∈ S
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
protected lemma mul_eq_one_iff_inv_eq (h : IsUnit a) : a * b = 1 ↔ a⁻¹ = b
-- Mathlib/Data/Sum/Basic.lean
@[simp]
theorem update_inr_comp_inr [DecidableEq β] [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : β}
    {x : γ} : update f (inr i) x ∘ inr = update (f ∘ inr) i x
-- Mathlib/Data/Set/Subsingleton.lean
theorem subsingleton_of_univ_subsingleton (h : (univ : Set α).Subsingleton) : Subsingleton α
-- Mathlib/Data/ZMod/Basic.lean
theorem val_one_eq_one_mod (n : ℕ) : (1 : ZMod n).val = 1 % n
-- Mathlib/Order/CompleteLattice.lean
theorem iSup_le (h : ∀ i, f i ≤ a) : iSup f ≤ a
-- Mathlib/Geometry/Manifold/IntegralCurve.lean
lemma isIntegralCurve_comp_add {dt : ℝ} :
    IsIntegralCurve γ v ↔ IsIntegralCurve (γ ∘ (· + dt)) v
-- Mathlib/Data/Set/Card.lean
theorem pred_ncard_le_ncard_diff_singleton (s : Set α) (a : α) : s.ncard - 1 ≤ (s \ {a}).ncard
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
@[simp]
theorem lintegral_mk (f : α → ℝ≥0∞) (hf) : (mk f hf : α →ₘ[μ] ℝ≥0∞).lintegral = ∫⁻ a, f a ∂μ
-- Mathlib/Analysis/Calculus/Deriv/ZPow.lean
theorem Differentiable.zpow (hf : Differentiable 𝕜 f) (h : (∀ x, f x ≠ 0) ∨ 0 ≤ m) :
    Differentiable 𝕜 fun x => f x ^ m
-- Mathlib/CategoryTheory/Localization/Triangulated.lean
lemma essImageDistTriang_mem_of_iso {T₁ T₂ : Triangle D} (e : T₂ ≅ T₁)
    (h : T₁ ∈ L.essImageDistTriang) : T₂ ∈ L.essImageDistTriang
-- Mathlib/Probability/Kernel/RadonNikodym.lean
lemma measurableSet_mutuallySingularSet (κ η : Kernel α γ) :
    MeasurableSet (mutuallySingularSet κ η)
-- Mathlib/Computability/Primrec.lean
theorem succ : Primrec Nat.succ
-- Mathlib/RingTheory/AdicCompletion/Functoriality.lean
theorem sum_comp_sumInv : sum I M ∘ₗ sumInv I M = LinearMap.id
-- Mathlib/Data/Part.lean
theorem right_dom_of_union_dom [Union α] {a b : Part α} (hab : Dom (a ∪ b)) : b.Dom
-- Mathlib/Algebra/ContinuedFractions/Translations.lean
@[simp]
theorem zeroth_conv'Aux_eq_zero {s : Stream'.Seq <| Pair K} :
    convs'Aux s 0 = (0 : K)
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
/-- Uses `left` co(ntra)variant. -/
@[to_additive (attr := simp) "Uses `left` co(ntra)variant."]
theorem Left.one_le_inv_iff : 1 ≤ a⁻¹ ↔ a ≤ 1
-- Mathlib/Analysis/Convex/Cone/Proper.lean
theorem hyperplane_separation_of_nmem (K : ProperCone ℝ E) {f : E →L[ℝ] F} {b : F}
    (disj : b ∉ K.map f) : ∃ y : F, adjoint f y ∈ K.dual ∧ ⟪y, b⟫_ℝ < 0
-- Mathlib/GroupTheory/PushoutI.lean
/-- The empty normalized word, representing the identity element of the group. -/
@[simps!]
def empty : NormalWord d
-- Mathlib/SetTheory/Game/PGame.lean
theorem lt_of_le_of_lf {x y : PGame} (h₁ : x ≤ y) (h₂ : x ⧏ y) : x < y
-- Mathlib/Topology/Sets/Closeds.lean
@[simp]
theorem coe_mk (s : Set α) (h : IsIrreducible s) (h' : IsClosed s) : (mk s h h' : Set α) = s
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
/-- The square with `0 : 0 ⟶ 0` on the bottom and `𝟙 X` on the top is a pullback square. -/
@[simp]
theorem zero_bot (X : C) : IsPullback (𝟙 X) (0 : X ⟶ 0) (0 : X ⟶ 0) (0 : (0 : C) ⟶ 0)
-- Mathlib/Data/Complex/ExponentialBounds.lean
theorem exp_neg_one_gt_d9 : 0.36787944116 < exp (-1)
-- Mathlib/Data/Finsupp/Basic.lean
theorem mapDomain_smul {_ : Monoid R} [AddCommMonoid M] [DistribMulAction R M] {f : α → β} (b : R)
    (v : α →₀ M) : mapDomain f (b • v) = b • mapDomain f v
-- Mathlib/Algebra/Category/Grp/EpiMono.lean
theorem h_apply_infinity (x : B) (hx : x ∈ f.range) : (h x) ∞ = ∞
-- Mathlib/Data/Finset/Lattice.lean
/-- If finsets `s` and `t` are interleaved, then `Finset.card s ≤ Finset.card t + 1`. -/
theorem card_le_of_interleaved {s t : Finset α}
    (h : ∀ᵉ (x ∈ s) (y ∈ s),
        x < y → (∀ z ∈ s, z ∉ Set.Ioo x y) → ∃ z ∈ t, x < z ∧ z < y) :
    s.card ≤ t.card + 1
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive]
theorem lt_mul_inv_iff_lt : 1 < a * b⁻¹ ↔ b < a
-- Mathlib/Topology/Sets/Opens.lean
protected theorem comap_comap (g : C(β, γ)) (f : C(α, β)) (U : Opens γ) :
    comap f (comap g U) = comap (g.comp f) U
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurable_uniqueElim [Unique δ] [∀ i, MeasurableSpace (π i)] :
    Measurable (uniqueElim : π (default : δ) → ∀ i, π i)
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
@[simp]
theorem coe_comap (f : P₁ →ᵃ[k] P₂) (s : AffineSubspace k P₂) : (s.comap f : Set P₁) = f ⁻¹' ↑s
-- Mathlib/RingTheory/Trace/Basic.lean
theorem traceMatrix_eq_embeddingsMatrix_mul_trans : (traceMatrix K b).map (algebraMap K E) =
    embeddingsMatrix K E b * (embeddingsMatrix K E b)ᵀ
-- Mathlib/FieldTheory/SeparableClosure.lean
@[simp]
theorem sepDegree_bot : sepDegree F (⊥ : IntermediateField F E) = 1
-- Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean
theorem toComplex_neg (x : ℤ[i]) : ((-x : ℤ[i]) : ℂ) = -x
-- Mathlib/Algebra/Tropical/Basic.lean
@[simp]
theorem untrop_trop (x : R) : untrop (trop x) = x
-- Mathlib/Algebra/Tropical/Basic.lean
@[simp]
theorem tropOrderIso_symm_coe_fn [Preorder R] : (tropOrderIso.symm : Tropical R → R) = untrop
-- Mathlib/Data/Set/Defs.lean
theorem mk_mem_prod (ha : a ∈ s) (hb : b ∈ t) : (a, b) ∈ s ×ˢ t
-- Mathlib/Algebra/Order/Group/MinMax.lean
theorem abs_min_sub_min_le_max (a b c d : α) : |min a b - min c d| ≤ max |a - c| |b - d|
-- Mathlib/Topology/Category/CompactlyGenerated.lean
lemma uCompactlyGeneratedSpace_of_continuous_maps {X : Type w} [t : TopologicalSpace X]
    (h : ∀ {Y : Type w} [tY : TopologicalSpace Y] (f : X → Y),
      (∀ (S : CompHaus.{u}) (g : C(S, X)), Continuous (f ∘ g)) → Continuous f) :
        UCompactlyGeneratedSpace.{u} X
-- Mathlib/CategoryTheory/Sites/LocallyInjective.lean
/-- If `F : Cᵒᵖ ⥤ D` is a presheaf with values in a concrete category, if `x` and `y` are
elements in `F.obj X`, this is the sieve of `X.unop` consisting of morphisms `f`
such that `F.map f.op x = F.map f.op y`. -/
@[simps]
def equalizerSieve {F : Cᵒᵖ ⥤ D} {X : Cᵒᵖ} (x y : F.obj X) : Sieve X.unop
-- Mathlib/CategoryTheory/Adjunction/Evaluation.lean
/-- The left adjoint of evaluation. -/
@[simps]
def evaluationLeftAdjoint (c : C) : D ⥤ C ⥤ D
-- Mathlib/Data/Finset/Option.lean
@[simp]
theorem map_some_eraseNone [DecidableEq (Option α)] (s : Finset (Option α)) :
    (eraseNone s).map Embedding.some = s.erase none
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
nonrec theorem HasDerivAtFilter.neg (h : HasDerivAtFilter f f' x L) :
    HasDerivAtFilter (fun x => -f x) (-f') x L
-- Mathlib/SetTheory/Game/PGame.lean
theorem Equiv.not_fuzzy' {x y : PGame} (h : x ≈ y) : ¬y ‖ x
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem leadingCoeff_zero : leadingCoeff (0 : R[X]) = 0
-- Mathlib/Analysis/ODE/PicardLindelof.lean
theorem hasDerivWithinAt_next (t : Icc v.tMin v.tMax) :
    HasDerivWithinAt (f.next ∘ v.proj) (v t (f t)) (Icc v.tMin v.tMax) t
-- Mathlib/Data/Nat/PartENat.lean
@[simp]
theorem zero_ne_top : (0 : PartENat) ≠ ⊤
-- Mathlib/CategoryTheory/Triangulated/Opposite.lean
@[reassoc (attr := simp)]
lemma opShiftFunctorEquivalence_counitIso_hom_naturality (n : ℤ) {X Y : Cᵒᵖ} (f : X ⟶ Y) :
    f.unop⟦n⟧'.op⟦n⟧' ≫ (opShiftFunctorEquivalence C n).counitIso.hom.app Y =
      (opShiftFunctorEquivalence C n).counitIso.hom.app X ≫ f
-- Mathlib/GroupTheory/Torsion.lean
/-- The torsion submonoid of a torsion monoid is `⊤`. -/
@[to_additive (attr := simp) "The additive torsion submonoid of an additive torsion monoid is `⊤`."]
theorem torsion_eq_top (tG : IsTorsion G) : torsion G = ⊤
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToL1SCLM_nonneg {T : Set α → G' →L[ℝ] G''} {C : ℝ} (hT : DominatedFinMeasAdditive μ T C)
    (hT_nonneg : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, 0 ≤ x → 0 ≤ T s x) {f : α →₁ₛ[μ] G'}
    (hf : 0 ≤ f) : 0 ≤ setToL1SCLM α G' μ hT f
-- Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean
theorem IsEquivalent.mul (htu : t ~[l] u) (hvw : v ~[l] w) : t * v ~[l] u * w
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem reverse_concat {u v w : V} (p : G.Walk u v) (h : G.Adj v w) :
    (p.concat h).reverse = cons (G.symm h) p.reverse
-- Mathlib/Algebra/Homology/ImageToKernel.lean
@[simp]
theorem imageToKernel_comp_hom_inv_comp [HasEqualizers V] [HasImages V] {Z : V} {i : B ≅ Z} (w) :
    imageToKernel (f ≫ i.hom) (i.inv ≫ g) w =
      (imageSubobjectCompIso _ _).hom ≫
        imageToKernel f g (by simpa using w) ≫ (kernelSubobjectIsoComp i.inv g).inv
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma negDblY_of_Y_eq [NoZeroDivisors R] {P Q : Fin 3 → R} (hQz : Q z ≠ 0)
    (hx : P x * Q z ^ 2 = Q x * P z ^ 2) (hy : P y * Q z ^ 3 = Q y * P z ^ 3)
    (hy' : P y * Q z ^ 3 = W'.negY Q * P z ^ 3) : W'.negDblY P = (-W'.dblU P) ^ 3
-- Mathlib/Algebra/Ring/BooleanRing.lean
private theorem of_boolalg_symmDiff_aux (a b : α) : (a + b + a * b) * (1 + a * b) = a + b
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Increment.lean
private theorem distinctPairs_increment :
    P.parts.offDiag.attach.biUnion (distinctPairs hP G ε) ⊆ (increment hP G ε).parts.offDiag
-- Mathlib/Probability/Process/Stopping.lean
theorem ProgMeasurable.stronglyMeasurable_stoppedProcess [MetrizableSpace ι]
    (hu : ProgMeasurable f u) (hτ : IsStoppingTime f τ) (i : ι) :
    StronglyMeasurable (MeasureTheory.stoppedProcess u τ i)
-- Mathlib/RingTheory/Trace/Basic.lean
theorem trace_eq_sum_embeddings_gen (pb : PowerBasis K L)
    (hE : (minpoly K pb.gen).Splits (algebraMap K E)) (hfx : IsSeparable K pb.gen) :
    algebraMap K E (Algebra.trace K L pb.gen) =
      (@Finset.univ _ (PowerBasis.AlgHom.fintype pb)).sum fun σ => σ pb.gen
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- If `E / F` is an algebraic extension, then the separable closure of `F` in `E` is
equal to `F` if and only if `E / F` is purely inseparable. -/
theorem separableClosure.eq_bot_iff [Algebra.IsAlgebraic F E] :
    separableClosure F E = ⊥ ↔ IsPurelyInseparable F E
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Sized.dual : ∀ {t : Ordnode α}, Sized t → Sized (dual t)
-- Mathlib/GroupTheory/Coset.lean
@[to_additive (attr := simp)]
lemma fiberEquiv_apply (f : α →* H) (a b : α) (g : f ⁻¹' {f a}) :
    f.fiberEquiv a b g = b * (a⁻¹ * g)
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
/-- The symmetric version of Tonelli's Theorem: For `ℝ≥0∞`-valued measurable
functions on `α × β`, the integral of `f` is equal to the iterated integral, in reverse order. -/
theorem lintegral_prod_symm' [SFinite μ] (f : α × β → ℝ≥0∞) (hf : Measurable f) :
    ∫⁻ z, f z ∂μ.prod ν = ∫⁻ y, ∫⁻ x, f (x, y) ∂μ ∂ν
-- Mathlib/Order/Filter/Basic.lean
theorem gc_map_comap (m : α → β) : GaloisConnection (map m) (comap m)
-- Mathlib/SetTheory/Ordinal/FixedPointApproximants.lean
/-- Some ordinal approximation of the least fixed point is the least fixed point. -/
theorem lfp_mem_range_lfpApprox : lfp f ∈ Set.range (lfpApprox f ⊥)
-- Mathlib/Algebra/Order/Group/Nat.lean
/-- See also `pow_left_strictMonoOn`. -/
protected lemma pow_left_strictMono (hn : n ≠ 0) : StrictMono (· ^ n : ℕ → ℕ)
-- Mathlib/Algebra/QuadraticDiscriminant.lean
/-- Roots of a quadratic equation. -/
theorem quadratic_eq_zero_iff (ha : a ≠ 0) {s : K} (h : discrim a b c = s * s) (x : K) :
    a * x * x + b * x + c = 0 ↔ x = (-b + s) / (2 * a) ∨ x = (-b - s) / (2 * a)
-- Mathlib/NumberTheory/LucasLehmer.lean
theorem mersenne_int_ne_zero (p : ℕ) (hp : p ≠ 0) : (2 ^ p - 1 : ℤ) ≠ 0
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.set_index_mem (h : l.HasBasis p s) (ht : t ∈ l) : s (h.index t ht) ∈ l
-- Mathlib/Data/List/Permutation.lean
theorem permutationsAux2_fst (t : α) (ts : List α) (r : List β) :
    ∀ (ys : List α) (f : List α → β), (permutationsAux2 t ts r ys f).1 = ys ++ ts
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
lemma _root_.MeasureTheory.NullMeasurableSet.prod {s : Set α} {t : Set β}
    (s_mble : NullMeasurableSet s μ) (t_mble : NullMeasurableSet t ν) :
    NullMeasurableSet (s ×ˢ t) (μ.prod ν)
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
theorem eq_zero_of_inner_left (hK : Dense (K : Set E)) (h : ∀ v : K, ⟪x, v⟫ = 0) : x = 0
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem div_zero (a : Ordinal) : a / 0 = 0
-- Mathlib/MeasureTheory/Group/Measure.lean
/-- If a left-invariant measure gives finite mass to a nonempty open set, then it gives finite mass
to any compact set. -/
@[to_additive
"If a left-invariant measure gives finite mass to a nonempty open set, then it gives finite mass to
any compact set."]
theorem measure_lt_top_of_isCompact_of_isMulLeftInvariant (U : Set G) (hU : IsOpen U)
    (h'U : U.Nonempty) (h : μ U ≠ ∞) {K : Set G} (hK : IsCompact K) : μ K < ∞
-- Mathlib/Data/Nat/Digits.lean
theorem digits_one_succ (n : ℕ) : digits 1 (n + 1) = 1 :: digits 1 n
-- Mathlib/Order/Category/CompleteLat.lean
theorem completeLat_dual_comp_forget_to_bddLat :
    CompleteLat.dual ⋙ forget₂ CompleteLat BddLat =
    forget₂ CompleteLat BddLat ⋙ BddLat.dual
-- Mathlib/Geometry/Euclidean/Angle/Sphere.lean
/-- Converse of "angles in same segment are equal" and "opposite angles of a cyclic quadrilateral
add to π", for oriented angles mod π, with a "concyclic or collinear" conclusion. -/
theorem concyclic_or_collinear_of_two_zsmul_oangle_eq {p₁ p₂ p₃ p₄ : P}
    (h : (2 : ℤ) • ∡ p₁ p₂ p₄ = (2 : ℤ) • ∡ p₁ p₃ p₄) :
    Concyclic ({p₁, p₂, p₃, p₄} : Set P) ∨ Collinear ℝ ({p₁, p₂, p₃, p₄} : Set P)
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
@[measurability]
protected theorem MeasurableSet.compl : MeasurableSet s → MeasurableSet sᶜ
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
theorem of_measurable_inverse (hf₁ : Measurable f) (hf₂ : MeasurableSet (range f))
    (hg : Measurable g) (H : LeftInverse g f) : MeasurableEmbedding f
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_norm_eq_lintegral_nnnorm {P : Type*} [NormedAddCommGroup P] {f : α → P}
    (hf : AEStronglyMeasurable f μ) : ∫ x, ‖f x‖ ∂μ = ENNReal.toReal (∫⁻ x, ‖f x‖₊ ∂μ)
-- Mathlib/Topology/Basic.lean
theorem closure_eq_compl_interior_compl : closure s = (interior sᶜ)ᶜ
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem one_lt_aleph0 : 1 < ℵ₀
-- Mathlib/Logic/Equiv/PartialEquiv.lean
@[simp, mfld_simps]
theorem refl_trans : (PartialEquiv.refl α).trans e = e
-- Mathlib/Topology/Category/FinTopCat.lean
@[simp]
theorem coe_of (X : Type u) [Fintype X] [TopologicalSpace X] :
    (of X : Type u) = X
-- Mathlib/Topology/Category/Profinite/Product.lean
theorem surjective_π_app :
    Function.Surjective (π_app C J)
-- Mathlib/Analysis/Analytic/Within.lean
/-- Analyticity on `s` implies analyticity within `s` -/
lemma AnalyticOn.analyticWithinOn {f : E → F} {s : Set E} (h : AnalyticOn 𝕜 f s) :
    AnalyticWithinOn 𝕜 f s
-- Mathlib/Analysis/CstarAlgebra/Multiplier.lean
theorem coe_eq_algebraMap : (DoubleCentralizer.coe 𝕜 : 𝕜 → 𝓜(𝕜, 𝕜)) = algebraMap 𝕜 𝓜(𝕜, 𝕜)
-- Mathlib/Topology/Algebra/Polynomial.lean
theorem eq_one_of_roots_le {p : F[X]} {f : F →+* K} {B : ℝ} (hB : B < 0) (h1 : p.Monic)
    (h2 : Splits f p) (h3 : ∀ z ∈ (map f p).roots, ‖z‖ ≤ B) : p = 1
-- Mathlib/MeasureTheory/Function/L1Space.lean
/-- A function has finite integral for the counting measure iff its norm is summable. -/
lemma hasFiniteIntegral_count_iff :
    HasFiniteIntegral f Measure.count ↔ Summable (‖f ·‖)
-- Mathlib/Algebra/Star/StarRingHom.lean
/-- A *non-unital ⋆-ring homomorphism* is a non-unital ring homomorphism between non-unital
non-associative semirings `A` and `B` equipped with a `star` operation, and this homomorphism is
also `star`-preserving. -/
structure NonUnitalStarRingHom (A B : Type*) [NonUnitalNonAssocSemiring A]
    [Star A] [NonUnitalNonAssocSemiring B] [Star B] extends A →ₙ+* B where
  /-- By definition, a non-unital ⋆-ring homomorphism preserves the `star` operation. -/
  map_star' : ∀ a : A, toFun (star a) = star (toFun a)
-- Mathlib/Computability/Partrec.lean
@[simp]
theorem rfind_dom {p : ℕ →. Bool} :
    (rfind p).Dom ↔ ∃ n, true ∈ p n ∧ ∀ {m : ℕ}, m < n → (p m).Dom
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If `f` tends to negative infinity along a nontrivial filter `l`,
then `fun x ↦ f x / r` tends to infinity if and only if `r < 0. `-/
lemma tendsto_div_const_atTop_iff_neg [NeBot l] (h : Tendsto f l atBot) :
    Tendsto (fun x ↦ f x / r) l atTop ↔ r < 0
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
@[mono]
theorem trim_mono : Monotone (trim : OuterMeasure α → OuterMeasure α)
-- Mathlib/Order/Filter/Prod.lean
theorem Eventually.prod_inl {la : Filter α} {p : α → Prop} (h : ∀ᶠ x in la, p x) (lb : Filter β) :
    ∀ᶠ x in la ×ˢ lb, p (x : α × β).1
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma shift_distinguished (n : ℤ) :
    (CategoryTheory.shiftFunctor (Triangle C) n).obj T ∈ distTriang C
-- Mathlib/NumberTheory/ZetaValues.lean
theorem bernoulliFun_eval_zero (k : ℕ) : bernoulliFun k 0 = bernoulli k
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- An angle in a right-angled triangle expressed using `arctan`, where one side is a multiple
of a rotation of another by `π / 2`, version subtracting vectors. -/
theorem oangle_sub_right_smul_rotation_pi_div_two {x : V} (h : x ≠ 0) (r : ℝ) :
    o.oangle (r • o.rotation (π / 2 : ℝ) x) (r • o.rotation (π / 2 : ℝ) x - x)
      = Real.arctan r⁻¹
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean
theorem bounds_nonempty [RingHomIsometric σ₁₂] {f : E →SL[σ₁₂] F} :
    ∃ c, c ∈ { c | 0 ≤ c ∧ ∀ x, ‖f x‖ ≤ c * ‖x‖ }
-- Mathlib/Algebra/Polynomial/Smeval.lean
@[simp]
theorem smeval_add : (p + q).smeval x = p.smeval x + q.smeval x
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem pow_eq {κ μ : Cardinal.{u}} (H1 : ℵ₀ ≤ κ) (H2 : 1 ≤ μ) (H3 : μ < ℵ₀) : κ ^ μ = κ
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Gcd.lean
theorem gcd_mul_dvd_mul_gcd (k m n : Nat) : gcd k (m * n) ∣ gcd k m * gcd k n
-- Mathlib/Data/Nat/ModEq.lean
/-- A common factor that's coprime with the modulus can be cancelled from a `ModEq` -/
lemma cancel_right_of_coprime (hmc : gcd m c = 1) (h : a * c ≡ b * c [MOD m]) : a ≡ b [MOD m]
-- Mathlib/Analysis/Calculus/Dslope.lean
theorem continuousWithinAt_dslope_of_ne (h : b ≠ a) :
    ContinuousWithinAt (dslope f a) s b ↔ ContinuousWithinAt f s b
-- Mathlib/Data/Nat/Bits.lean
@[simp]
lemma bodd_succ (n : ℕ) : bodd (succ n) = not (bodd n)
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
lemma isOpen_iff_isLowerSet : IsOpen s ↔ IsLowerSet s
-- Mathlib/Data/Finset/Fold.lean
@[congr]
theorem fold_congr {g : α → β} (H : ∀ x ∈ s, f x = g x) : s.fold op b f = s.fold op b g
-- Mathlib/Analysis/Convex/Cone/Basic.lean
@[simp]
theorem mem_toConvexCone {x : E} {S : Submodule 𝕜 E} : x ∈ S.toConvexCone ↔ x ∈ S
-- Mathlib/Data/Sym/Sym2.lean
theorem out_snd_mem (e : Sym2 α) : e.out.2 ∈ e
-- Mathlib/Topology/Compactness/LocallyCompact.lean
/-- In a weakly locally compact space,
every compact set is contained in the interior of a compact set. -/
theorem exists_compact_superset [WeaklyLocallyCompactSpace X] {K : Set X} (hK : IsCompact K) :
    ∃ K', IsCompact K' ∧ K ⊆ interior K'
-- Mathlib/CategoryTheory/Abelian/Opposite.lean
theorem cokernel.π_op :
    (cokernel.π f.op).unop =
      (cokernelOpUnop f).hom ≫ kernel.ι f ≫ eqToHom (Opposite.unop_op _).symm
-- Mathlib/MeasureTheory/Integral/TorusIntegral.lean
theorem torusIntegral_smul {𝕜 : Type*} [RCLike 𝕜] [NormedSpace 𝕜 E] [SMulCommClass 𝕜 ℂ E] (a : 𝕜)
    (f : ℂⁿ → E) (c : ℂⁿ) (R : ℝⁿ) : (∯ x in T(c, R), a • f x) = a • ∯ x in T(c, R), f x
-- Mathlib/Order/Interval/Basic.lean
theorem le_def : s ≤ t ↔ t.fst ≤ s.fst ∧ s.snd ≤ t.snd
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
@[simp]
theorem coe_infNndist : (infNndist x s : ℝ) = infDist x s
-- Mathlib/RingTheory/Adjoin/Basic.lean
/-- If `E / L / F` and `E / L' / F` are two ring extension towers, `L ≃ₐ[F] L'` is an isomorphism
compatible with `E / L` and `E / L'`, then for any subset `S` of `E`, `L[S]` and `L'[S]` are
equal as subalgebras of `E / F`. -/
theorem Algebra.restrictScalars_adjoin_of_algEquiv
    {F E L L' : Type*} [CommSemiring F] [CommSemiring L] [CommSemiring L'] [Semiring E]
    [Algebra F L] [Algebra L E] [Algebra F L'] [Algebra L' E] [Algebra F E]
    [IsScalarTower F L E] [IsScalarTower F L' E] (i : L ≃ₐ[F] L')
    (hi : algebraMap L E = (algebraMap L' E) ∘ i) (S : Set E) :
    (Algebra.adjoin L S).restrictScalars F = (Algebra.adjoin L' S).restrictScalars F
-- Mathlib/CategoryTheory/GlueData.lean
@[reassoc, elementwise (attr := simp)]
theorem t_inv (i j : D.J) : D.t i j ≫ D.t j i = 𝟙 _
-- Mathlib/MeasureTheory/PiSystem.lean
theorem has_union {s₁ s₂ : Set α} (h₁ : d.Has s₁) (h₂ : d.Has s₂) (h : Disjoint s₁ s₂) :
    d.Has (s₁ ∪ s₂)
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
theorem ContDiffOn.cexp {n} (hf : ContDiffOn 𝕜 n f s) :
    ContDiffOn 𝕜 n (fun x => Complex.exp (f x)) s
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_const_mul (r : R) (f : R → R) (a : A)
    (hf : ContinuousOn f (spectrum R a) := by cfc_cont_tac) :
    cfc (fun x ↦ r * f x) a = r • cfc f a
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem hnot_top : ￢(⊤ : α) = ⊥
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem mk_le_aleph0 [Countable α] : #α ≤ ℵ₀
-- Mathlib/Topology/Algebra/Order/Field.lean
theorem tendsto_const_mul_zpow_atTop_nhds_iff {n : ℤ} {c d : 𝕜} (hc : c ≠ 0) :
    Tendsto (fun x : 𝕜 => c * x ^ n) atTop (𝓝 d) ↔ n = 0 ∧ c = d ∨ n < 0 ∧ d = 0
-- Mathlib/Algebra/Order/Interval/Basic.lean
@[simp]
theorem length_zero : (0 : Interval α).length = 0
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem fin_one_eq_zero (a : Fin 1) : a = 0
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem bot_eq : (⊥ : PUnit) = unit
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem insert_eq_of_mem {a : α} {s : Set α} (h : a ∈ s) : insert a s = s
-- Mathlib/Algebra/Group/TypeTags.lean
@[simp]
lemma toMul_eq_one {α : Type*} [One α] {x : Additive α} :
    Additive.toMul x = 1 ↔ x = 0
-- Mathlib/FieldTheory/Minpoly/Basic.lean
theorem degree_eq_one_iff : (minpoly A x).degree = 1 ↔ x ∈ (algebraMap A B).range
-- Mathlib/Order/Antichain.lean
protected theorem IsAntichain.isWeakAntichain (hs : IsAntichain (· ≤ ·) s) : IsWeakAntichain s
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
theorem limit.existsUnique {F : J ⥤ C} [HasLimit F] (t : Cone F) :
    ∃! l : t.pt ⟶ limit F, ∀ j, l ≫ limit.π F j = t.π.app j
-- Mathlib/Order/Filter/Basic.lean
protected theorem Tendsto.if' {α β : Type*} {l₁ : Filter α} {l₂ : Filter β} {f g : α → β}
    {p : α → Prop} [DecidablePred p] (hf : Tendsto f l₁ l₂) (hg : Tendsto g l₁ l₂) :
    Tendsto (fun a => if p a then f a else g a) l₁ l₂
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma equiv_iff_eq_of_Z_eq [NoZeroDivisors R] {P Q : Fin 3 → R} (hz : P z = Q z) (hQz : Q z ≠ 0) :
    P ≈ Q ↔ P = Q
-- Mathlib/RingTheory/WittVector/Defs.lean
@[simp]
theorem wittOne_zero_eq_one : wittOne p 0 = 1
-- Mathlib/Data/Complex/Abs.lean
theorem isCauSeq_conj (f : CauSeq ℂ Complex.abs) :
    IsCauSeq Complex.abs fun n => conj (f n)
-- Mathlib/CategoryTheory/SmallObject/Construction.lean
@[reassoc]
lemma FunctorObjIndex.comm (x : FunctorObjIndex f πX) :
    f x.i ≫ Sigma.ι (functorObjTgtFamily f πX) x ≫ ρFunctorObj f πX = x.t ≫ ιFunctorObj f πX
-- Mathlib/Geometry/Manifold/ContMDiff/NormedSpace.lean
nonrec theorem ContMDiffAt.clm_apply {g : M → F₁ →L[𝕜] F₂} {f : M → F₁} {x : M}
    (hg : ContMDiffAt I 𝓘(𝕜, F₁ →L[𝕜] F₂) n g x) (hf : ContMDiffAt I 𝓘(𝕜, F₁) n f x) :
    ContMDiffAt I 𝓘(𝕜, F₂) n (fun x => g x (f x)) x