ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Shift/Basic.lean
@[reassoc]
lemma shiftFunctorAdd_assoc_hom_app (a₁ a₂ a₃ : A) (X : C) :
    (shiftFunctorAdd C (a₁ + a₂) a₃).hom.app X ≫
      ((shiftFunctorAdd C a₁ a₂).hom.app X)⟦a₃⟧' =
    (shiftFunctorAdd' C a₁ (a₂ + a₃) (a₁ + a₂ + a₃) (add_assoc _ _ _).symm).hom.app X ≫
      (shiftFunctorAdd C a₂ a₃).hom.app (X⟦a₁⟧)
-- Mathlib/ModelTheory/LanguageMap.lean
/-- The inclusion of the right factor into the sum of two languages. -/
@[simps]
protected def sumInr : L' →ᴸ L.sum L'
-- Mathlib/Algebra/BigOperators/Finsupp.lean
theorem single_finset_sum [AddCommMonoid M] (s : Finset ι) (f : ι → M) (a : α) :
    single a (∑ b ∈ s, f b) = ∑ b ∈ s, single a (f b)
-- Mathlib/NumberTheory/VonMangoldt.lean
theorem vonMangoldt_pos_iff {n : ℕ} : 0 < Λ n ↔ IsPrimePow n
-- Mathlib/SetTheory/Ordinal/Exponential.lean
theorem opow_isLimit_left {a b : Ordinal} (l : IsLimit a) (hb : b ≠ 0) : IsLimit (a ^ b)
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem eq_zero_of_mem_range_zero [Zero β] : ∀ {y : β}, y ∈ (0 : α →ₛ β).range → y = 0
-- Mathlib/Topology/Compactness/SigmaCompact.lean
/-- Countable unions of compact sets are σ-compact. -/
lemma isSigmaCompact_sUnion_of_isCompact {S : Set (Set X)} (hc : Set.Countable S)
    (hcomp : ∀ (s : Set X), s ∈ S → IsCompact s) : IsSigmaCompact (⋃₀ S)
-- Mathlib/Topology/ContinuousOn.lean
@[fun_prop]
theorem ContinuousOn.snd {f : α → β × γ} {s : Set α} (hf : ContinuousOn f s) :
    ContinuousOn (fun x => (f x).2) s
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
theorem Bool.or_assoc (a b c : Bool) : (a || b || c) = (a || (b || c))
-- Mathlib/CategoryTheory/EssentialImage.lean
/-- An object in the image is in the essential image. -/
theorem obj_mem_essImage (F : D ⥤ C) (Y : D) : F.obj Y ∈ essImage F
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem ContDiff.comp_contDiffAt {g : F → G} {f : E → F} (x : E) (hg : ContDiff 𝕜 n g)
    (hf : ContDiffAt 𝕜 n f x) : ContDiffAt 𝕜 n (g ∘ f) x
-- Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean
protected theorem IsClosed.balancedCore (hU : IsClosed U) : IsClosed (balancedCore 𝕜 U)
-- Mathlib/Topology/Connected/TotallyDisconnected.lean
lemma Embedding.isTotallyDisconnected_image [TopologicalSpace β] {f : α → β} (hf : Embedding f)
    {s : Set α} : IsTotallyDisconnected (f '' s) ↔ IsTotallyDisconnected s
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem abs_sinh (x : ℝ) : |sinh x| = sinh |x|
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
@[reassoc]
lemma rightHomologyIso_inv_naturality :
    S₁.rightHomologyIso.inv ≫ rightHomologyMap φ =
      homologyMap φ ≫ S₂.rightHomologyIso.inv
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
@[reassoc (attr := simp)]
lemma LeftHomologyData.leftHomologyIso_hom_comp_homologyIso_inv (h : S.LeftHomologyData) :
    h.leftHomologyIso.hom ≫ h.homologyIso.inv = S.leftHomologyIso.hom
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
theorem surjOn_logb' : SurjOn (logb b) (Iio 0) univ
-- Mathlib/Combinatorics/Quiver/Covering.lean
theorem Prefunctor.IsCovering.of_comp_left (hφ : φ.IsCovering) (hφψ : (φ ⋙q ψ).IsCovering)
    (φsur : Surjective φ.obj) : ψ.IsCovering
-- Mathlib/Data/Set/Finite.lean
theorem infinite_of_injective_forall_mem [Infinite α] {s : Set β} {f : α → β} (hi : Injective f)
    (hf : ∀ x : α, f x ∈ s) : s.Infinite
-- Mathlib/Algebra/Module/CharacterModule.lean
lemma eq_zero_of_ofSpanSingleton_apply_self (a : A)
    (h : ofSpanSingleton a ⟨a, Submodule.mem_span_singleton_self a⟩ = 0) : a = 0
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
theorem LinearMap.toMatrix₂Aux_eq (B : M₁ →ₗ[R] M₂ →ₗ[R] N₂) :
    LinearMap.toMatrix₂Aux R b₁ b₂ B = LinearMap.toMatrix₂ b₁ b₂ B
-- Mathlib/Geometry/Manifold/Algebra/LieGroup.lean
theorem SmoothOn_inv₀ : SmoothOn I I (Inv.inv : G → G) {0}ᶜ
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
@[simp]
lemma degree_polynomial [Nontrivial R] : W.polynomial.degree = 2
-- Mathlib/Order/CompleteBooleanAlgebra.lean
lemma sup_iInf₂_eq {f : ∀ i, κ i → α} (a : α) : (a ⊔ ⨅ i, ⨅ j, f i j) = ⨅ i, ⨅ j, a ⊔ f i j
-- Mathlib/Topology/Instances/Matrix.lean
@[continuity]
theorem Continuous.matrix_vecMul [NonUnitalNonAssocSemiring R] [ContinuousAdd R] [ContinuousMul R]
    [Fintype m] {A : X → m → R} {B : X → Matrix m n R} (hA : Continuous A) (hB : Continuous B) :
    Continuous fun x => A x ᵥ* B x
-- Mathlib/RingTheory/Regular/IsSMulRegular.lean
lemma isSMulRegular_iff_mem_nonZeroSMulDivisors :
    IsSMulRegular M r ↔ r ∈ nonZeroSMulDivisors R M
-- Mathlib/NumberTheory/LSeries/Basic.lean
lemma LSeriesHasSum_iff {f : ℕ → ℂ} {s a : ℂ} :
    LSeriesHasSum f s a ↔ LSeriesSummable f s ∧ LSeries f s = a
-- Mathlib/NumberTheory/FLT/Four.lean
theorem ne_zero {a b c : ℤ} (h : Fermat42 a b c) : c ≠ 0
-- Mathlib/Algebra/Lie/Engel.lean
theorem isNilpotentOfIsNilpotentSpanSupEqTop (hnp : IsNilpotent <| toEnd R L M x)
    (hIM : IsNilpotent R I M) : IsNilpotent R L M
-- Mathlib/Topology/LocallyConstant/Basic.lean
theorem exists_open {f : X → Y} (hf : IsLocallyConstant f) (x : X) :
    ∃ U : Set X, IsOpen U ∧ x ∈ U ∧ ∀ x' ∈ U, f x' = f x
-- Mathlib/Data/Finset/Sort.lean
theorem min'_eq_sorted_zero {s : Finset α} {h : s.Nonempty} :
    s.min' h = (s.sort (· ≤ ·)).get ⟨0, (by rw [length_sort]; exact card_pos.2 h)⟩
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- If the sign of the angle between three points is negative, the first and third points are not
equal. -/
theorem left_ne_right_of_oangle_sign_eq_neg_one {p₁ p₂ p₃ : P} (h : (∡ p₁ p₂ p₃).sign = -1) :
    p₁ ≠ p₃
-- Mathlib/MeasureTheory/Integral/CircleIntegral.lean
theorem circleMap_ne_mem_ball {c : ℂ} {R : ℝ} {w : ℂ} (hw : w ∈ ball c R) (θ : ℝ) :
    circleMap c R θ ≠ w
-- Mathlib/Combinatorics/Derangements/Finite.lean
theorem card_derangements_fin_eq_numDerangements {n : ℕ} :
    card (derangements (Fin n)) = numDerangements n
-- Mathlib/Data/Finsupp/Defs.lean
theorem single_add_erase (a : α) (f : α →₀ M) : single a (f a) + f.erase a = f
-- Mathlib/RingTheory/DiscreteValuationRing/Basic.lean
theorem addVal_def (r : R) (u : Rˣ) {ϖ : R} (hϖ : Irreducible ϖ) (n : ℕ) (hr : r = u * ϖ ^ n) :
    addVal R r = n
-- Mathlib/Order/GaloisConnection.lean
protected theorem dual {l : α → β} {u : β → α} (gc : GaloisConnection l u) :
    GaloisConnection (OrderDual.toDual ∘ u ∘ OrderDual.ofDual)
      (OrderDual.toDual ∘ l ∘ OrderDual.ofDual)
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem integral_comp_mul_right_Ioi (g : ℝ → E) (a : ℝ) {b : ℝ} (hb : 0 < b) :
    (∫ x in Ioi a, g (x * b)) = b⁻¹ • ∫ x in Ioi (a * b), g x
-- Mathlib/Analysis/Calculus/Deriv/AffineMap.lean
theorem hasStrictDerivAt_lineMap : HasStrictDerivAt (lineMap a b) (b - a) x
-- Mathlib/Order/BooleanAlgebra.lean
theorem himp_le : x ⇨ y ≤ z ↔ y ≤ z ∧ Codisjoint x z
-- Mathlib/Algebra/Tropical/Basic.lean
theorem leftInverse_trop : Function.LeftInverse (trop : R → Tropical R) untrop
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_disjiUnion (s : Finset ι) (t : ι → Finset α) (h) :
    ∏ x ∈ s.disjiUnion t h, f x = ∏ i ∈ s, ∏ x ∈ t i, f x
-- Mathlib/MeasureTheory/Constructions/Polish/EmbeddingReal.lean
theorem measurableEquiv_range_coe_nat_of_infinite_of_countable [Infinite α] [Countable α] :
    Nonempty (α ≃ᵐ range ((↑) : ℕ → ℝ))
-- Mathlib/Logic/Equiv/Set.lean
theorem Equiv.swap_bijOn_self (hs : a ∈ s ↔ b ∈ s) : BijOn (Equiv.swap a b) s s
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem nhds_eq_uniformity {x : α} : 𝓝 x = (𝓤 α).lift' (ball x)
-- Mathlib/Combinatorics/Quiver/Cast.lean
theorem Hom.cast_heq {u v u' v' : U} (hu : u = u') (hv : v = v') (e : u ⟶ v) :
    HEq (e.cast hu hv) e
-- Mathlib/CategoryTheory/Preadditive/OfBiproducts.lean
theorem distrib (f g h k : X ⟶ Y) : (f +ᵣ g) +ₗ h +ᵣ k = (f +ₗ h) +ᵣ g +ₗ k
-- Mathlib/Logic/Equiv/TransferInstance.lean
@[to_additive]
theorem inv_def [Inv β] (x : α) :
    letI := Equiv.Inv e
    x⁻¹ = e.symm (e x)⁻¹
-- Mathlib/Data/Nat/ModEq.lean
theorem le_of_lt_add (h1 : a ≡ b [MOD m]) (h2 : a < b + m) : a ≤ b
-- Mathlib/Order/Heyting/Basic.lean
theorem sdiff_le_comm : a \ b ≤ c ↔ a \ c ≤ b
-- Mathlib/Topology/UniformSpace/Equiv.lean
@[simp]
theorem uniformEquiv_mk_coe (a : Equiv α β) (b c) : (UniformEquiv.mk a b c : α → β) = a
-- Mathlib/Algebra/Order/AbsoluteValue.lean
lemma abv_add (x y) : abv (x + y) ≤ abv x + abv y
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
@[simp, mfld_simps]
protected theorem left_inv (x : H) : I.symm (I x) = x
-- .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean
@[simp] theorem size_enum (n) : (enum n).size = n
-- .lake/packages/lean4/src/lean/Init/Control/Lawful/Basic.lean
theorem seqRight_eq_bind [Monad m] [LawfulMonad m] (x : m α) (y : m β) : x *> y = x >>= fun _ => y
-- Mathlib/Analysis/Convex/Star.lean
/-- The image of a star-convex set under an affine map is star-convex. -/
theorem StarConvex.affine_image (f : E →ᵃ[𝕜] F) {s : Set E} (hs : StarConvex 𝕜 x s) :
    StarConvex 𝕜 (f x) (f '' s)
-- Mathlib/FieldTheory/Separable.lean
/-- If `IsUnit n` in a `CommRing R`, then `X ^ n - u` is separable for any unit `u`. -/
theorem separable_X_pow_sub_C_unit {n : ℕ} (u : Rˣ) (hn : IsUnit (n : R)) :
    Separable (X ^ n - C (u : R))
-- Mathlib/Order/RelClasses.lean
theorem ssubset_of_subset_not_subset (h₁ : a ⊆ b) (h₂ : ¬b ⊆ a) : a ⊂ b
-- Mathlib/Analysis/SpecialFunctions/Complex/Log.lean
nonrec
theorem _root_.ContinuousAt.clog {f : α → ℂ} {x : α} (h₁ : ContinuousAt f x)
    (h₂ : f x ∈ slitPlane) : ContinuousAt (fun t => log (f t)) x
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem ContDiffAt.sin {n} (hf : ContDiffAt ℝ n f x) : ContDiffAt ℝ n (fun x => Real.sin (f x)) x
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem tensorTensorTensorAssoc_tmul (m : M) (n : N) (p : P) (q : Q) :
    tensorTensorTensorAssoc R M N P Q (m ⊗ₜ n ⊗ₜ (p ⊗ₜ q)) = m ⊗ₜ (n ⊗ₜ p) ⊗ₜ q
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem exists_eq_disjoint_finiteSpanningSetsIn (μ ν : Measure α) [SigmaFinite μ] [SigmaFinite ν] :
    ∃ (S : μ.FiniteSpanningSetsIn { s | MeasurableSet s })
      (T : ν.FiniteSpanningSetsIn { s | MeasurableSet s }),
      S.set = T.set ∧ Pairwise (Disjoint on S.set)
-- Mathlib/Data/Set/Defs.lean
@[simp] theorem mem_diagonal_iff {x : α × α} : x ∈ diagonal α ↔ x.1 = x.2
-- Mathlib/Algebra/Order/Ring/Canonical.lean
lemma Odd.pos [Nontrivial α] : Odd a → 0 < a
-- Mathlib/Analysis/Convex/Side.lean
theorem sOppSide_iff_exists_left {s : AffineSubspace R P} {x y p₁ : P} (h : p₁ ∈ s) :
    s.SOppSide x y ↔ x ∉ s ∧ y ∉ s ∧ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
theorem finrank_span_eq_card [Nontrivial R] {ι : Type*} [Fintype ι] {b : ι → M}
    (hb : LinearIndependent R b) :
    finrank R (span R (Set.range b)) = Fintype.card ι
-- Mathlib/Algebra/Star/Subalgebra.lean
theorem map_mono {S₁ S₂ : StarSubalgebra R A} {f : A →⋆ₐ[R] B} : S₁ ≤ S₂ → S₁.map f ≤ S₂.map f
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem map_sSup (s : Set (Ideal R)) : (sSup s).map f = ⨆ I ∈ s, (I : Ideal R).map f
-- Mathlib/Algebra/Lie/Derivation/Killing.lean
/-- The range of the adjoint action on a finite-dimensional Killing Lie algebra is full. -/
@[simp]
lemma range_ad_eq_top : 𝕀 = ⊤
-- Mathlib/Testing/SlimCheck/Functions.lean
theorem applyId_mem_iff [DecidableEq α] {xs ys : List α} (h₀ : List.Nodup xs) (h₁ : xs ~ ys)
    (x : α) : List.applyId.{u} (xs.zip ys) x ∈ ys ↔ x ∈ xs
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- Two closed sets are at zero Hausdorff distance if and only if they coincide. -/
theorem _root_.IsClosed.hausdorffDist_zero_iff_eq (hs : IsClosed s) (ht : IsClosed t)
    (fin : hausdorffEdist s t ≠ ⊤) : hausdorffDist s t = 0 ↔ s = t
-- Mathlib/RingTheory/Discriminant.lean
/-- A variation of `Algebra.discr_powerBasis_eq_prod`. -/
theorem discr_powerBasis_eq_prod' [Algebra.IsSeparable K L] (e : Fin pb.dim ≃ (L →ₐ[K] E)) :
    algebraMap K E (discr K pb.basis) =
      ∏ i : Fin pb.dim, ∏ j ∈ Ioi i, -((e j pb.gen - e i pb.gen) * (e i pb.gen - e j pb.gen))
-- Mathlib/RingTheory/Nilpotent/Defs.lean
theorem IsNilpotent.map [MonoidWithZero R] [MonoidWithZero S] {r : R} {F : Type*}
    [FunLike F R S] [MonoidWithZeroHomClass F R S] (hr : IsNilpotent r) (f : F) :
    IsNilpotent (f r)
-- Mathlib/NumberTheory/Pell.lean
/-- If `(x, y)` is a solution with `x` and `y` positive, then the `y` component of any power
has the same sign as the exponent. -/
theorem sign_y_zpow_eq_sign_of_x_pos_of_y_pos {a : Solution₁ d} (hax : 0 < a.x) (hay : 0 < a.y)
    (n : ℤ) : (a ^ n).y.sign = n.sign
-- Mathlib/Topology/Order/LawsonTopology.lean
theorem isOpen_preimage_ofLawson {S : Set α} :
    IsOpen (ofLawson ⁻¹' S) ↔ (lawson α).IsOpen S
-- Mathlib/Topology/Bornology/Hom.lean
@[ext]
theorem ext {f g : LocallyBoundedMap α β} (h : ∀ a, f a = g a) : f = g
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem lt_add_of_neg_lt_sub_right {a b c : Int} (h : -b < a - c) : c < a + b
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem cmp_compares : ∀ (a b : ONote) [NF a] [NF b], (cmp a b).Compares a b
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
/-- The `Matrix` version of `inv_sub_inv'` -/
theorem inv_sub_inv {A B : Matrix n n α} (h : IsUnit A ↔ IsUnit B) :
    A⁻¹ - B⁻¹ = A⁻¹ * (B - A) * B⁻¹
-- Mathlib/Data/Real/EReal.lean
@[simp]
theorem bot_ne_coe (x : ℝ) : (⊥ : EReal) ≠ x
-- Mathlib/AlgebraicGeometry/OpenImmersion.lean
theorem lift_app {X Y U : Scheme.{u}} (f : U ⟶ Y) (g : X ⟶ Y) [IsOpenImmersion f] (H)
    (V : U.Opens) :
    (IsOpenImmersion.lift f g H).app V = (f.appIso V).inv ≫ g.app (f ''ᵁ V) ≫
      X.presheaf.map (eqToHom <| IsOpenImmersion.app_eq_invApp_app_of_comp_eq_aux _ _ _
        (IsOpenImmersion.lift_fac f g H).symm V).op
-- Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean
/-- We can more explicitly show that a category has a terminal object by specifying the object,
and showing there is a unique morphism to it from any other object. -/
theorem hasTerminal_of_unique (X : C) [h : ∀ Y : C, Unique (Y ⟶ X)] : HasTerminal C
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem imp_congr_left (h : a ↔ b) : (a → c) ↔ (b → c)
-- Mathlib/Analysis/SpecialFunctions/Complex/Log.lean
theorem log_exp {x : ℂ} (hx₁ : -π < x.im) (hx₂ : x.im ≤ π) : log (exp x) = x
-- Mathlib/Data/Real/Irrational.lean
theorem sub_rat (h : Irrational x) : Irrational (x - q)
-- Mathlib/Data/Seq/Computation.lean
theorem results_think {s : Computation α} {a n} (h : Results s a n) : Results (think s) a (n + 1)
-- Mathlib/Data/Setoid/Partition.lean
/-- A family of bijective functions with pairwise disjoint
domains and pairwise disjoint ranges can be glued together
to form a bijective function. -/
theorem piecewise_bij {β : Type*} {f : ι → α → β}
    {t : ι → Set β} (ht : IndexedPartition t)
    (hf : ∀ i, BijOn (f i) (s i) (t i)) :
    Bijective (piecewise hs f)
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem lt_mul_of_one_le_of_lt_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (h : b < c) (hc : 0 ≤ c) :
    b < a * c
-- Mathlib/RingTheory/Ideal/IsPrincipal.lean
theorem associatesNonZeroDivisorsEquivIsPrincipal_mul (x y : Associates R⁰) :
    (associatesNonZeroDivisorsEquivIsPrincipal R (x * y) : Ideal R) =
      (associatesNonZeroDivisorsEquivIsPrincipal R x) *
        (associatesNonZeroDivisorsEquivIsPrincipal R y)
-- Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean
theorem map_zero (d : ℕ) (a : Fin 0 → ℕ) : map d a = 0
-- Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean
@[ext]
theorem initial.strict_hom_ext {A : C} (f g : A ⟶ ⊥_ C) : f = g
-- Mathlib/Logic/Function/CompTypeclasses.lean
/-- Class of composing triples -/
class CompTriple  {M N P : Type*} (φ : M → N) (ψ : N → P) (χ : outParam (M → P)) : Prop where
  /-- The maps form a commuting triangle -/
  comp_eq : ψ.comp φ = χ
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
/-- Composition of affine maps acts as applying the two functions. -/
@[simp]
theorem coe_comp (f : P2 →ᵃ[k] P3) (g : P1 →ᵃ[k] P2) : ⇑(f.comp g) = f ∘ g
-- Mathlib/Data/Vector/Mem.lean
@[simp]
theorem get_mem (i : Fin n) (v : Vector α n) : v.get i ∈ v.toList
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem range_loop_range' : ∀ s n : Nat, range.loop s (range' s n) = range' 0 (n + s)
-- Mathlib/Data/Real/Archimedean.lean
theorem exists_isLUB {S : Set ℝ} (hne : S.Nonempty) (hbdd : BddAbove S) : ∃ x, IsLUB S x
-- Mathlib/RingTheory/FractionalIdeal/Norm.lean
theorem absNorm_bot : absNorm (⊥ : FractionalIdeal R⁰ K) = 0
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.of_const_mul_right {g : α → R} {c : R} (h : f =o[l] fun x => c * g x) :
    f =o[l] g
-- Mathlib/Logic/Equiv/Basic.lean
/-- `PUnit` is a right identity for type product up to an equivalence. -/
@[simps]
def prodPUnit (α) : α × PUnit ≃ α
-- Mathlib/AlgebraicGeometry/OpenImmersion.lean
@[simp]
theorem toScheme_toLocallyRingedSpace :
    (toScheme Y f).toLocallyRingedSpace = toLocallyRingedSpace Y.1 f
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_unique_nonempty {α β : Type*} [CommMonoid β] [Unique α] (s : Finset α) (f : α → β)
    (h : s.Nonempty) : ∏ x ∈ s, f x = f default
-- Mathlib/NumberTheory/Harmonic/Bounds.lean
theorem harmonic_floor_le_one_add_log (y : ℝ) (hy : 1 ≤ y) :
    harmonic ⌊y⌋₊ ≤ 1 + Real.log y
-- Mathlib/Logic/Embedding/Basic.lean
/-- Given an equivalence to a subtype, produce an embedding to the elements of the corresponding
set. -/
@[simps!]
def asEmbedding {β α : Sort*} {p : β → Prop} (e : α ≃ Subtype p) : α ↪ β
-- Mathlib/LinearAlgebra/Span.lean
theorem span_span : span R (span R s : Set M) = span R s
-- Mathlib/Topology/Algebra/ProperAction.lean
/-- Proper group action in the sense of Bourbaki:
the map `G × X → X × X` is a proper map (see `IsProperMap`). -/
class ProperVAdd (G X : Type*) [TopologicalSpace G] [TopologicalSpace X] [AddGroup G]
    [AddAction G X] : Prop where
  /-- Proper group action in the sense of Bourbaki:
  the map `G × X → X × X` is a proper map (see `IsProperMap`). -/
  isProperMap_vadd_pair : IsProperMap (fun gx ↦ (gx.1 +ᵥ gx.2, gx.2) : G × X → X × X)
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
@[simp]
theorem norm_p : ‖(p : ℤ_[p])‖ = (p : ℝ)⁻¹
-- Mathlib/GroupTheory/Perm/Subgroup.lean
@[simp]
theorem subtypeCongrHom.card_range {α : Type*} (p : α → Prop) [DecidablePred p]
    [Fintype (subtypeCongrHom p).range] [Fintype (Perm { a // p a } × Perm { a // ¬p a })] :
    Fintype.card (subtypeCongrHom p).range =
      Fintype.card (Perm { a // p a } × Perm { a // ¬p a })
-- Mathlib/Data/Sym/Basic.lean
theorem mem_fill_iff {a b : α} {i : Fin (n + 1)} {s : Sym α (n - i)} :
    a ∈ Sym.fill b i s ↔ (i : ℕ) ≠ 0 ∧ a = b ∨ a ∈ s
-- Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean
@[simp] lemma unmop_braiding (X Y : Cᴹᵒᵖ) : (β_ X Y).unmop = β_ (unmop Y) (unmop X)
-- Mathlib/Computability/TMToPartrec.lean
theorem trList_ne_consₗ : ∀ (l), ∀ x ∈ trList l, x ≠ Γ'.consₗ
-- Mathlib/Data/Finset/Pointwise.lean
lemma smul_finset_univ₀ [Fintype β] (ha : a ≠ 0) : a • (univ : Finset β) = univ
-- Mathlib/Topology/Filter.lean
@[simp]
theorem nhds_iInf (f : ι → Filter α) : 𝓝 (⨅ i, f i) = ⨅ i, 𝓝 (f i)
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
@[simp (high)]
theorem norm_p_zpow (n : ℤ) : ‖(p : ℚ_[p]) ^ n‖ = (p : ℝ) ^ (-n)
-- Mathlib/Topology/Constructions.lean
theorem ContinuousAt.prod_map' {f : X → Z} {g : Y → W} {x : X} {y : Y} (hf : ContinuousAt f x)
    (hg : ContinuousAt g y) : ContinuousAt (fun p : X × Y => (f p.1, g p.2)) (x, y)
-- Mathlib/Analysis/MeanInequalities.lean
theorem geom_mean_le_arith_mean2_weighted {w₁ w₂ p₁ p₂ : ℝ} (hw₁ : 0 ≤ w₁) (hw₂ : 0 ≤ w₂)
    (hp₁ : 0 ≤ p₁) (hp₂ : 0 ≤ p₂) (hw : w₁ + w₂ = 1) : p₁ ^ w₁ * p₂ ^ w₂ ≤ w₁ * p₁ + w₂ * p₂
-- Mathlib/Algebra/FreeMonoid/Basic.lean
@[to_additive]
theorem toList_map (f : α → β) (xs : FreeMonoid α) : toList (map f xs) = xs.toList.map f
-- Mathlib/GroupTheory/Perm/Finite.lean
nonrec theorem Disjoint.orderOf {σ τ : Perm α} (hστ : Disjoint σ τ) :
    orderOf (σ * τ) = Nat.lcm (orderOf σ) (orderOf τ)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem tan_sub_pi (x : ℝ) : tan (x - π) = tan x
-- Mathlib/Combinatorics/SimpleGraph/Turan.lean
lemma degree_eq_card_sub_part_card : G.degree s = Fintype.card V - (h.finpartition.part s).card
-- Mathlib/MeasureTheory/Measure/Stieltjes.lean
theorem measure_univ {l u : ℝ} (hfl : Tendsto f atBot (𝓝 l)) (hfu : Tendsto f atTop (𝓝 u)) :
    f.measure univ = ofReal (u - l)
-- Mathlib/Order/Heyting/Hom.lean
@[simp]
theorem id_apply (a : α) : BiheytingHom.id α a = a
-- Mathlib/Data/Nat/Factorial/Basic.lean
/-- Avoid in favor of `Nat.factorial_mul_ascFactorial'` if you can. ℕ-division isn't worth it. -/
theorem ascFactorial_eq_div' (n k : ℕ) (h : 0 < n) :
    n.ascFactorial k = (n + k - 1)! / (n - 1) !
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unique.lean
@[simp]
lemma toNNReal_neg_one : (-1 : C(X, ℝ)).toNNReal = 0
-- Mathlib/FieldTheory/PerfectClosure.lean
theorem mk_eq_iff (x y : ℕ × K) :
    mk K p x = mk K p y ↔ ∃ z, (frobenius K p)^[y.1 + z] x.2 = (frobenius K p)^[x.1 + z] y.2
-- Mathlib/Algebra/Module/Basic.lean
lemma indicator_smul_left (s : Set α) (r : α → R) (f : α → M) :
    indicator s (fun a ↦ r a • f a) = fun a ↦ indicator s r a • f a
-- Mathlib/MeasureTheory/Covering/VitaliFamily.lean
theorem eventually_filterAt_mem_setsAt (x : α) : ∀ᶠ a in v.filterAt x, a ∈ v.setsAt x
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
/-- Note that the identity is a cycle on any subsingleton set, but not a cycle. -/
protected theorem IsCycleOn.subtypePerm (hf : f.IsCycleOn s) :
    (f.subtypePerm fun _ => hf.apply_mem_iff.symm : Perm s).IsCycleOn _root_.Set.univ
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem eq_inv_mul_of_mul_eq (h : b * a = c) : a = b⁻¹ * c
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
@[simp, norm_cast]
lemma mk_apply (μ : Measure Ω) (hμ) (s : Set Ω) :
    DFunLike.coe (F := FiniteMeasure Ω) ⟨μ, hμ⟩ s = (μ s).toNNReal
-- Mathlib/SetTheory/Cardinal/PartENat.lean
theorem toPartENat_lift (c : Cardinal.{v}) : toPartENat (lift.{u, v} c) = toPartENat c
-- Mathlib/CategoryTheory/Triangulated/Basic.lean
/-- The second projection `Triangle C ⥤ C`. -/
@[simps]
def π₂ : Triangle C ⥤ C
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem uIcc_subset_uIcc_iff_le' :
    [[a₁, b₁]] ⊆ [[a₂, b₂]] ↔ a₂ ⊓ b₂ ≤ a₁ ⊓ b₁ ∧ a₁ ⊔ b₁ ≤ a₂ ⊔ b₂
-- Mathlib/Analysis/InnerProductSpace/OfNorm.lean
private theorem add_left_aux7 (y z : E) :
    ‖(I : 𝕜) • y + 2 • z‖ * ‖(I : 𝕜) • y + 2 • z‖ =
    2 * (‖(I : 𝕜) • y + z‖ * ‖(I : 𝕜) • y + z‖ + ‖z‖ * ‖z‖) - ‖(I : 𝕜) • y‖ * ‖(I : 𝕜) • y‖
-- Mathlib/Analysis/Normed/Ring/SeminormFromConst.lean
/-- The image of `seminormFromConst_seq c f x` is bounded below by zero. -/
theorem seminormFromConst_bddBelow (x : R) :
    BddBelow (Set.range (seminormFromConst_seq c f x))
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive (attr := simp)]
theorem mul_eq_empty : s * t = ∅ ↔ s = ∅ ∨ t = ∅
-- Mathlib/Data/Matroid/IndepAxioms.lean
@[simp] theorem ofBddAugment_E (E : Set α) Indep indep_empty indep_subset indep_aug
    indep_bdd subset_ground : (IndepMatroid.ofBddAugment
      E Indep indep_empty indep_subset indep_aug indep_bdd subset_ground).E = E
-- Mathlib/Algebra/Quaternion.lean
@[simp]
theorem imK_star : (star a).imK = -a.imK
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem div_le_div_of_nonpos_of_le (hc : c ≤ 0) (h : b ≤ a) : a / c ≤ b / c
-- Mathlib/Analysis/Analytic/Basic.lean
theorem hasFPowerSeriesOnBall_changeOrigin (k : ℕ) (hr : 0 < p.radius) :
    HasFPowerSeriesOnBall (fun x => p.changeOrigin x k) (p.changeOriginSeries k) 0 p.radius
-- Mathlib/Data/NNReal/Basic.lean
theorem _root_.Real.le_coe_toNNReal (r : ℝ) : r ≤ Real.toNNReal r
-- Mathlib/Data/Num/Lemmas.lean
@[simp, norm_cast]
theorem div_to_nat : ∀ n d, ((n / d : Num) : ℕ) = n / d
-- Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean
/-- The **Ahlswede-Zhang Identity**. -/
lemma infSum_eq_one (h𝒜₁ : 𝒜.Nonempty) (h𝒜₀ : ∅ ∉ 𝒜) : infSum 𝒜 = 1
-- Mathlib/LinearAlgebra/Finsupp.lean
@[simp]
theorem mapRange.linearEquiv_refl :
    mapRange.linearEquiv (LinearEquiv.refl R M) = LinearEquiv.refl R (α →₀ M)