ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Adjunction/Basic.lean
theorem homEquiv_naturality_left_square_iff (f : X' ⟶ X) (g : F.obj X ⟶ Y')
    (h : F.obj X' ⟶ Y) (k : Y ⟶ Y') :
    (f ≫ (adj.homEquiv X Y') g = (adj.homEquiv X' Y) h ≫ G.map k) ↔
      (F.map f ≫ g = h ≫ k)
-- Mathlib/Order/MinMax.lean
theorem lt_max_of_lt_right (h : a < c) : a < max b c
-- Mathlib/Order/Monotone/Monovary.lean
protected theorem MonovaryOn.subset (hst : s ⊆ t) (h : MonovaryOn f g t) : MonovaryOn f g s
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
lemma mono_of_isZero_kernel {X Y : C} (f : X ⟶ Y) [HasKernel f] (h : IsZero (kernel f)) :
    Mono f
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Prod.lean
/-- The operator norm of the second projection `E × F → F` is at most 1. (It is 0 if `F` is zero, so
the inequality cannot be improved without further assumptions.) -/
lemma norm_snd_le : ‖snd 𝕜 E F‖ ≤ 1
-- Mathlib/CategoryTheory/Comma/Over.lean
@[simp]
theorem map_obj_hom : ((map f).obj U).hom = f ≫ U.hom
-- Mathlib/Analysis/SpecialFunctions/Complex/Circle.lean
/-- The homeomorphism between `AddCircle (2 * π)` and `circle`. -/
@[simps] noncomputable def homeomorphCircle' : AddCircle (2 * π) ≃ₜ circle
-- Mathlib/Order/Irreducible.lean
theorem SupIrred.not_isMin (ha : SupIrred a) : ¬IsMin a
-- Mathlib/Analysis/Complex/UpperHalfPlane/Topology.lean
theorem openEmbedding_coe : OpenEmbedding ((↑) : ℍ → ℂ)
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem map_add : ∀ (x y : R), min (v x) (v y) ≤ v (x + y)
-- Mathlib/Data/Rel.lean
theorem graph_id : graph id = @Eq α
-- Mathlib/GroupTheory/Perm/Support.lean
theorem Disjoint.mono {x y : Perm α} (h : Disjoint f g) (hf : x.support ≤ f.support)
    (hg : y.support ≤ g.support) : Disjoint x y
-- Mathlib/Order/Directed.lean
theorem isBot_iff_isMin [IsDirected α (· ≥ ·)] : IsBot a ↔ IsMin a
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
@[reassoc (attr := simp)]
lemma leftHomologyπ_naturality :
    S₁.leftHomologyπ ≫ leftHomologyMap φ = cyclesMap φ ≫ S₂.leftHomologyπ
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem eLpNorm'_measure_zero_of_exponent_zero {f : α → F} : eLpNorm' f 0 (0 : Measure α) = 1
-- .lake/packages/aesop/Aesop/Util/Basic.lean
theorem size_modify (a : Array α) (i : Nat) (f : α → α) :
    (a.modify i f).size = a.size
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem rev_succ (k : Fin n) : rev (succ k) = castSucc (rev k)
-- Mathlib/Analysis/Convex/Basic.lean
theorem convex_halfspace_lt {f : E → β} (h : IsLinearMap 𝕜 f) (r : β) : Convex 𝕜 { w | f w < r }
-- Mathlib/RingTheory/FreeCommRing.lean
theorem of_injective : Function.Injective (of : α → FreeCommRing α)
-- Mathlib/Order/Disjoint.lean
theorem le_left_iff (h : IsCompl x y) : z ≤ x ↔ Disjoint z y
-- Mathlib/Analysis/Calculus/UniformLimitsDeriv.lean
/-- `(d/dx) lim_{n → ∞} f n x = lim_{n → ∞} f' n x` when the `f' n` converge
_uniformly_ to their limit on an open set containing `x`. -/
theorem hasFDerivAt_of_tendstoUniformlyOn [NeBot l] {s : Set E} (hs : IsOpen s)
    (hf' : TendstoUniformlyOn f' g' l s)
    (hf : ∀ n : ι, ∀ x : E, x ∈ s → HasFDerivAt (f n) (f' n x) x)
    (hfg : ∀ x : E, x ∈ s → Tendsto (fun n => f n x) l (𝓝 (g x))) :
    ∀ x : E, x ∈ s → HasFDerivAt g (g' x) x
-- Mathlib/Analysis/Convolution.lean
theorem _root_.HasCompactSupport.contDiff_convolution_right {n : ℕ∞} (hcg : HasCompactSupport g)
    (hf : LocallyIntegrable f μ) (hg : ContDiff 𝕜 n g) : ContDiff 𝕜 n (f ⋆[L, μ] g)
-- Mathlib/Order/Filter/NAry.lean
@[simp]
theorem map₂_left [NeBot g] : map₂ (fun x _ => x) f g = f
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem lift_le_one_iff {a : Cardinal.{u}} :
    lift.{v} a ≤ 1 ↔ a ≤ 1
-- Mathlib/CategoryTheory/Sites/Subsheaf.lean
/-- A morphism factors through the sheafification of the image presheaf. -/
@[simps!]
def toImagePresheafSheafify (f : F' ⟶ F) : F' ⟶ ((imagePresheaf f).sheafify J).toPresheaf
-- Mathlib/Data/Stream/Init.lean
theorem get_of_bisim (bisim : IsBisimulation R) :
    ∀ {s₁ s₂} (n), s₁ ~ s₂ → get s₁ n = get s₂ n ∧ drop (n + 1) s₁ ~ drop (n + 1) s₂
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
theorem one_eq_closure_one_set : (1 : AddSubmonoid R) = closure 1
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp, norm_cast]
theorem coe_prod [Module R₁ M₂] [Module R₁ M₃] (f₁ : M₁ →L[R₁] M₂) (f₂ : M₁ →L[R₁] M₃) :
    (f₁.prod f₂ : M₁ →ₗ[R₁] M₂ × M₃) = LinearMap.prod f₁ f₂
-- Mathlib/CategoryTheory/Simple.lean
/-- `X` is simple iff it has subobject lattice `{⊥, ⊤}`. -/
theorem simple_iff_subobject_isSimpleOrder (X : C) : Simple X ↔ IsSimpleOrder (Subobject X)
-- Mathlib/Probability/Kernel/Disintegration/Integral.lean
lemma setIntegral_condKernel_univ_left (a : α) {t : Set Ω} (ht : MeasurableSet t)
    (hf : IntegrableOn f (Set.univ ×ˢ t) (κ a)) :
    ∫ b, ∫ ω in t, f (b, ω) ∂(Kernel.condKernel κ (a, b)) ∂(Kernel.fst κ a)
      = ∫ x in Set.univ ×ˢ t, f x ∂(κ a)
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem support_smul_eq {S₁ : Type*} [Semiring S₁] [Module S₁ R] [NoZeroSMulDivisors S₁ R] {a : S₁}
    (h : a ≠ 0) (p : MvPolynomial σ R) : (a • p).support = p.support
-- Mathlib/Data/Nat/PartENat.lean
theorem lt_wf : @WellFounded PartENat (· < ·)
-- Mathlib/Algebra/Algebra/Equiv.lean
theorem ofBijective_apply {f : A₁ →ₐ[R] A₂} {hf : Function.Bijective f} (a : A₁) :
    (AlgEquiv.ofBijective f hf) a = f a
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
theorem lift.unique {φ' : (⨂[R] i, s i) →ₗ[R] E} (H : ∀ f, φ' (PiTensorProduct.tprod R f) = φ f) :
    φ' = lift φ
-- Mathlib/Algebra/Category/BialgebraCat/Basic.lean
@[simp] theorem toBialgEquiv_symm (e : X ≅ Y) :
    toBialgEquiv e.symm = (toBialgEquiv e).symm
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem splitAux_of_valid (p l m r acc) :
    splitAux ⟨l ++ m ++ r⟩ p ⟨utf8Len l⟩ ⟨utf8Len l + utf8Len m⟩ acc =
      acc.reverse ++ (List.splitOnP.go p r m.reverse).map mk
-- Mathlib/Data/Set/Sups.lean
theorem infs_sups_subset_left : s ⊼ (t ⊻ u) ⊆ s ⊼ t ⊻ s ⊼ u
-- Mathlib/Data/Finset/Grade.lean
@[simp] lemma isAtom_singleton (a : α) : IsAtom ({a} : Finset α)
-- Mathlib/Topology/Algebra/Algebra.lean
@[simp]
theorem comp_id (f : A →A[R] B) : f.comp (ContinuousAlgHom.id R A) = f
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
@[simp, reassoc]
theorem comp_f {C₁ C₂ C₃ : HomologicalComplex V c} (f : C₁ ⟶ C₂) (g : C₂ ⟶ C₃) (i : ι) :
    (f ≫ g).f i = f.f i ≫ g.f i
-- Mathlib/Logic/Embedding/Set.lean
@[simp] theorem Function.Embedding.sigmaSet_range {s : ι → Set α}
    (h : Pairwise (Disjoint on s)) : Set.range (Function.Embedding.sigmaSet h) = ⋃ i, s i
-- Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean
@[simp]
theorem mem_filter {p : Box ι → Prop} : J ∈ π.filter p ↔ J ∈ π ∧ p J
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[simp]
theorem mem_range {f : α →ₛ β} {b} : b ∈ f.range ↔ b ∈ range f
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_mul_symm_re_eq_norm (x y : F) : re (⟪x, y⟫ * ⟪y, x⟫) = ‖⟪x, y⟫ * ⟪y, x⟫‖
-- Mathlib/Order/SupClosed.lean
protected lemma SupClosed.infClosure (hs : SupClosed s) : SupClosed (infClosure s)
-- Mathlib/NumberTheory/PellMatiyasevic.lean
@[simp]
theorem xn_zero : xn a1 0 = 1
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
/--
`Subtype p`, usually written as `{x : α // p x}`, is a type which
represents all the elements `x : α` for which `p x` is true. It is structurally
a pair-like type, so if you have `x : α` and `h : p x` then
`⟨x, h⟩ : {x // p x}`. An element `s : {x // p x}` will coerce to `α` but
you can also make it explicit using `s.1` or `s.val`.
-/
@[pp_using_anonymous_constructor]
structure Subtype {α : Sort u} (p : α → Prop) where
  /-- If `s : {x // p x}` then `s.val : α` is the underlying element in the base
  type. You can also write this as `s.1`, or simply as `s` when the type is
  known from context. -/
  val : α
  /-- If `s : {x // p x}` then `s.2` or `s.property` is the assertion that
  `p s.1`, that is, that `s` is in fact an element for which `p` holds. -/
  property : p val
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
@[simp]
theorem deriv_mul (hc : DifferentiableAt 𝕜 c x) (hd : DifferentiableAt 𝕜 d x) :
    deriv (fun y => c y * d y) x = deriv c x * d x + c x * deriv d x
-- Mathlib/Probability/Density.lean
theorem hasPDF_of_pdf_ne_zero {m : MeasurableSpace Ω} {ℙ : Measure Ω} {μ : Measure E} {X : Ω → E}
    (hac : map X ℙ ≪ μ) (hpdf : ¬pdf X ℙ μ =ᵐ[μ] 0) : HasPDF X ℙ μ
-- Mathlib/Algebra/Group/Action/Prod.lean
/-- Scalar multiplication as a monoid homomorphism. -/
@[simps]
def smulMonoidHom [Monoid α] [MulOneClass β] [MulAction α β] [IsScalarTower α β β]
    [SMulCommClass α β β] : α × β →* β
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
theorem continuousOn_tan : ContinuousOn tan {x | cos x ≠ 0}
-- Mathlib/Data/Finsupp/AList.lean
theorem lookupFinsupp_surjective : Function.Surjective (@lookupFinsupp α M _)
-- Mathlib/Analysis/Distribution/FourierSchwartz.lean
@[simp] lemma fourierTransformCLE_symm_apply (f : 𝓢(V, E)) :
    (fourierTransformCLE 𝕜).symm f = 𝓕⁻ f
-- Mathlib/Analysis/Complex/Basic.lean
/-- The `normSq` function on `ℂ` is proper. -/
theorem tendsto_normSq_cocompact_atTop : Tendsto normSq (cocompact ℂ) atTop
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
theorem HasStrictFDerivAt.arsinh (hf : HasStrictFDerivAt f f' a) :
    HasStrictFDerivAt (fun x => arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') a
-- Mathlib/RingTheory/WittVector/WittPolynomial.lean
theorem aeval_wittPolynomial {A : Type*} [CommRing A] [Algebra R A] (f : ℕ → A) (n : ℕ) :
    aeval f (W_ R n) = ∑ i ∈ range (n + 1), (p : A) ^ i * f i ^ p ^ (n - i)
-- Mathlib/Data/Int/Defs.lean
protected lemma mul_dvd_mul_right (a : ℤ) (h : b ∣ c) : b * a ∣ c * a
-- Mathlib/Data/Set/Basic.lean
/-- See also `Set.nonempty_iff_ne_empty`. -/
theorem not_nonempty_iff_eq_empty {s : Set α} : ¬s.Nonempty ↔ s = ∅
-- Mathlib/Data/Set/Image.lean
@[simp]
theorem image_singleton {f : α → β} {a : α} : f '' {a} = {f a}
-- Mathlib/Algebra/Star/Subsemiring.lean
@[simp, nolint simpNF]
theorem mem_carrier {s : StarSubsemiring R} {x : R} : x ∈ s.carrier ↔ x ∈ s
-- Mathlib/Computability/Language.lean
theorem kstar_eq_iSup_pow (l : Language α) : l∗ = ⨆ i : ℕ, l ^ i
-- Mathlib/Data/List/Enum.lean
@[simp]
theorem enum_map_snd (l : List α) : map Prod.snd (enum l) = l
-- Mathlib/Analysis/Convex/Extreme.lean
theorem IsExtreme.extremePoints_eq (hAB : IsExtreme 𝕜 A B) :
    B.extremePoints 𝕜 = B ∩ A.extremePoints 𝕜
-- Mathlib/Data/Finset/Union.lean
lemma biUnion_biUnion [DecidableEq γ] (s : Finset α) (f : α → Finset β) (g : β → Finset γ) :
    (s.biUnion f).biUnion g = s.biUnion fun a ↦ (f a).biUnion g
-- Mathlib/CategoryTheory/Subobject/Limits.lean
@[simp]
theorem factorThruKernelSubobject_comp_arrow {W : C} (h : W ⟶ X) (w : h ≫ f = 0) :
    factorThruKernelSubobject f h w ≫ (kernelSubobject f).arrow = h
-- Mathlib/LinearAlgebra/Ray.lean
@[simp]
theorem sameRay_neg_smul_right_iff {v : M} {r : R} : SameRay R (-v) (r • v) ↔ r ≤ 0 ∨ v = 0
-- Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
theorem weightedHomogeneousComponent_eq_zero'
    (h : ∀ d : σ →₀ ℕ, d ∈ φ.support → weight w d ≠ n) :
    weightedHomogeneousComponent w n φ = 0
-- Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean
@[reassoc (attr := simp)] lemma w₀₂_τ₂ : S.v₀₁.τ₂ ≫ S.v₁₂.τ₂ = 0
-- Mathlib/Topology/MetricSpace/Dilation.lean
/-- `Dilation.ratio` as a monoid homomorphism from `α →ᵈ α` to `ℝ≥0`. -/
@[simps]
def ratioHom : (α →ᵈ α) →* ℝ≥0
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem ae_le_trim_of_stronglyMeasurable [LinearOrder γ] [TopologicalSpace γ]
    [OrderClosedTopology γ] [PseudoMetrizableSpace γ] (hm : m ≤ m0) {f g : β → γ}
    (hf : StronglyMeasurable[m] f) (hg : StronglyMeasurable[m] g) (hfg : f ≤ᵐ[μ] g) :
    f ≤ᵐ[μ.trim hm] g
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive]
theorem NormedCommGroup.uniformity_basis_dist :
    (𝓤 E).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { p : E × E | ‖p.fst / p.snd‖ < ε }
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma add_smul_equiv (P Q : Fin 3 → R) {u v : R} (hu : IsUnit u) (hv : IsUnit v) :
    W'.add (u • P) (v • Q) ≈ W'.add P Q
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean
/-- The map that turns a triangle index into an explicit triangle. -/
@[simps] def toTriangle : α × β × γ ↪ Finset (α ⊕ β ⊕ γ)
-- Mathlib/Topology/Support.lean
@[to_additive]
theorem _root_.hasCompactMulSupport_comp_left (hg : ∀ {x}, g x = 1 ↔ x = 1) :
    HasCompactMulSupport (g ∘ f) ↔ HasCompactMulSupport f
-- Mathlib/Data/List/Indexes.lean
theorem mapIdx_eq_enum_map (l : List α) (f : ℕ → α → β) :
    l.mapIdx f = l.enum.map (Function.uncurry f)
-- Mathlib/Data/ENat/Basic.lean
theorem le_of_lt_add_one (h : m < n + 1) : m ≤ n
-- Mathlib/Order/Interval/Set/Monotone.lean
theorem monotone_Iio : Monotone (Iio : α → Set α)
-- Mathlib/Logic/Function/Basic.lean
/-- As a map from the left argument to a unary function, `f` is injective. -/
theorem left' (hf : Injective2 f) [Nonempty β] : Function.Injective f
-- Mathlib/SetTheory/Cardinal/PartENat.lean
@[simp]
theorem aleph0_toPartENat : toPartENat ℵ₀ = ⊤
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem fderiv_of_not_mem_tsupport (h : x ∉ tsupport f) : fderiv 𝕜 f x = 0
-- Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
@[reassoc (attr := simp)]
lemma inr_f_fst_v (p q : ℤ) (hpq : p + 1 = q) :
    (inr φ).f p ≫ (fst φ).1.v p q hpq = 0
-- Mathlib/Computability/Partrec.lean
protected theorem ofNat (α) [Denumerable α] : Computable (ofNat α)
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
@[simp] theorem of_symm_smul [PartialOrder Γ] [SMulZeroClass R V] (r : R) (x : HahnModule Γ R V) :
  (of R).symm (r • x) = r • (of R).symm x
-- Mathlib/Data/List/Defs.lean
@[csimp]
theorem iterate_eq_iterateTR : @iterate = @iterateTR
-- Mathlib/Topology/Semicontinuous.lean
theorem upperSemicontinuous_const : UpperSemicontinuous fun _x : α => z
-- Mathlib/Data/Set/Pairwise/Basic.lean
theorem PairwiseDisjoint.subset (ht : t.PairwiseDisjoint f) (h : s ⊆ t) : s.PairwiseDisjoint f
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
theorem le_trim_iff {m₁ m₂ : OuterMeasure α} :
    m₁ ≤ m₂.trim ↔ ∀ s, MeasurableSet s → m₁ s ≤ m₂ s
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem linearIndependent_fin2 {f : Fin 2 → V} :
    LinearIndependent K f ↔ f 1 ≠ 0 ∧ ∀ a : K, a • f 1 ≠ f 0
-- Mathlib/NumberTheory/NumberField/House.lean
private theorem ξ_mulVec_eq_0 : a *ᵥ ξ K x = 0
-- Mathlib/CategoryTheory/Sites/NonabelianCohomology/H1.lean
@[simp]
lemma inv_ev (γ : OneCochain G U) (i j : I) {T : C} (a : T ⟶ U i) (b : T ⟶ U j) :
    (γ⁻¹).ev i j a b = (γ.ev i j a b)⁻¹
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
/-- The square with `0 : 0 ⟶ 0` on the right and `𝟙 X` on the left is a pullback square. -/
@[simp]
theorem zero_right (X : C) : IsPullback (0 : X ⟶ 0) (𝟙 X) (0 : (0 : C) ⟶ 0) (0 : X ⟶ 0)
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
protected theorem mul_div_assoc (a : Int) : ∀ {b c : Int}, c ∣ b → (a * b).div c = a * (b.div c)
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem eval₂_multiset_prod (s : Multiset R[X]) (x : S) :
    eval₂ f x s.prod = (s.map (eval₂ f x)).prod
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
theorem C_injective : Function.Injective (C : R → HahnSeries Γ R)
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
theorem inv_smul' (k : αˣ) (h : IsUnit A.det) : (k • A)⁻¹ = k⁻¹ • A⁻¹
-- Mathlib/Data/ENNReal/Basic.lean
theorem ofReal_eq_coe_nnreal {x : ℝ} (h : 0 ≤ x) :
    ENNReal.ofReal x = ofNNReal ⟨x, h⟩
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem IsCycle.support_pow_of_pos_of_lt_orderOf (hf : IsCycle f) {n : ℕ} (npos : 0 < n)
    (hn : n < orderOf f) : (f ^ n).support = f.support
-- Mathlib/Topology/Sets/Closeds.lean
/-- The complement of a closed set as an open set. -/
@[simps]
def Closeds.compl (s : Closeds α) : Opens α
-- Mathlib/RingTheory/Binomial.lean
/-- Pochhammer version of Chu-Vandermonde identity -/
theorem descPochhammer_smeval_add [Ring R] {r s : R} (k : ℕ) (h: Commute r s) :
    (descPochhammer ℤ k).smeval (r + s) = ∑ ij ∈ antidiagonal k,
    Nat.choose k ij.1 * ((descPochhammer ℤ ij.1).smeval r * (descPochhammer ℤ ij.2).smeval s)
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
lemma isIso_homologyπ : IsIso (K.homologyπ j)
-- Mathlib/LinearAlgebra/TensorProduct/Graded/Internal.lean
theorem tmul_coe_mul_one_tmul {j₁ : ι} (a₁ : A) (b₁ : ℬ j₁) (b₂ : B) :
    (a₁ ᵍ⊗ₜ[R] (b₁ : B) * (1 : A) ᵍ⊗ₜ[R] b₂ : 𝒜 ᵍ⊗[R] ℬ) = (a₁ : A) ᵍ⊗ₜ (b₁ * b₂ : B)
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem fmod_def (a b : Int) : a.fmod b = a - b * a.fdiv b
-- Mathlib/Topology/Instances/TrivSqZeroExt.lean
nonrec theorem uniformContinuous_fst : UniformContinuous (fst : tsze R M → R)
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
protected theorem IsCycle.orderOf (hf : IsCycle f) : orderOf f = f.support.card
-- Mathlib/Topology/PartialHomeomorph.lean
theorem isImage_source_target : e.IsImage e.source e.target
-- Mathlib/CategoryTheory/Preadditive/Opposite.lean
/-- `op` induces morphisms of monoids on hom groups of a preadditive category -/
@[simps!]
def opHom (X Y : C) : (X ⟶ Y) →+ (Opposite.op Y ⟶ Opposite.op X)
-- Mathlib/Order/WithBot.lean
@[simp] lemma map₂_top_left (f : α → β → γ) (b) : map₂ f ⊤ b = ⊤
-- Mathlib/Topology/Instances/EReal.lean
theorem continuousAt_add_coe_coe (a b : ℝ) :
    ContinuousAt (fun p : EReal × EReal => p.1 + p.2) (a, b)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/SOM.lean
theorem Mon.append_denote (ctx : Context) (m₁ m₂ : Mon) : (m₁ ++ m₂).denote ctx = m₁.denote ctx * m₂.denote ctx
-- Mathlib/Order/RelIso/Basic.lean
protected theorem injective (e : r ≃r s) : Injective e
-- Mathlib/Data/Set/Prod.lean
theorem offDiag_eq_sep_prod : s.offDiag = { x ∈ s ×ˢ s | x.1 ≠ x.2 }
-- Mathlib/FieldTheory/IsAlgClosed/Basic.lean
theorem exists_eval₂_eq_zero_of_injective {R : Type*} [Ring R] [IsAlgClosed k] (f : R →+* k)
    (hf : Function.Injective f) (p : R[X]) (hp : p.degree ≠ 0) : ∃ x, p.eval₂ f x = 0
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
@[simp] theorem sum_nil : sum ([] : IntList) = 0
-- Mathlib/Data/PEquiv.lean
theorem single_trans_of_eq_none (a : α) {b : β} {f : β ≃. δ} (h : f b = none) :
    (single a b).trans f = ⊥
-- Mathlib/Data/Set/Function.lean
@[deprecated mapsTo_range_iff (since := "2023-12-25")]
theorem maps_range_to (f : α → β) (g : γ → α) (s : Set β) :
    MapsTo f (range g) s ↔ MapsTo (f ∘ g) univ s
-- Mathlib/Data/Finsupp/Multiset.lean
theorem sum_id_lt_of_lt (m n : ι →₀ ℕ) (h : m < n) : (m.sum fun _ => id) < n.sum fun _ => id
-- Mathlib/Data/Ordmap/Ordset.lean
theorem dual_insert [Preorder α] [IsTotal α (· ≤ ·)] [@DecidableRel α (· ≤ ·)] (x : α) :
    ∀ t : Ordnode α, dual (Ordnode.insert x t) = @Ordnode.insert αᵒᵈ _ _ x (dual t)
-- Mathlib/GroupTheory/HNNExtension.lean
@[simp]
theorem prod_smul_empty (w : NormalWord d) :
    (w.prod φ) • empty = w
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem associated_left_inverse (h : B₁.IsSymm) : associatedHom S B₁.toQuadraticMap = B₁
-- Mathlib/GroupTheory/Sylow.lean
/-- **Frattini's Argument**: If `N` is a normal subgroup of `G`, and if `P` is a Sylow `p`-subgroup
  of `N`, then `N_G(P) ⊔ N = G`. -/
theorem Sylow.normalizer_sup_eq_top {p : ℕ} [Fact p.Prime] {N : Subgroup G} [N.Normal]
    [Finite (Sylow p N)] (P : Sylow p N) :
    ((↑P : Subgroup N).map N.subtype).normalizer ⊔ N = ⊤
-- Mathlib/Topology/Instances/RatLemmas.lean
theorem not_countably_generated_cocompact : ¬IsCountablyGenerated (cocompact ℚ)
-- Mathlib/CategoryTheory/Monoidal/Mon_.lean
@[simp]
theorem tensor_mul (M N : Mon_ C) : (M ⊗ N).mul =
    tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)
-- Mathlib/Algebra/Squarefree/Basic.lean
theorem squarefree_iff_irreducible_sq_not_dvd_of_exists_irreducible {r : R}
    (hr : ∃ x : R, Irreducible x) : Squarefree r ↔ ∀ x : R, Irreducible x → ¬x * x ∣ r
-- Mathlib/CategoryTheory/Sites/Sieves.lean
@[ext]
protected theorem ext {R S : Sieve X} (h : ∀ ⦃Y⦄ (f : Y ⟶ X), R f ↔ S f) : R = S
-- Mathlib/Topology/Instances/ENNReal.lean
protected theorem Tendsto.const_div {f : Filter α} {m : α → ℝ≥0∞} {a b : ℝ≥0∞}
    (hm : Tendsto m f (𝓝 b)) (hb : b ≠ ∞ ∨ a ≠ ∞) : Tendsto (fun b => a / m b) f (𝓝 (a / b))
-- Mathlib/Analysis/InnerProductSpace/LinearPMap.lean
theorem isSelfAdjoint_def : IsSelfAdjoint A ↔ A† = A
-- Mathlib/RingTheory/Valuation/Integers.lean
theorem le_of_dvd (hv : Integers v O) {x y : O} (h : x ∣ y) :
    v (algebraMap O R y) ≤ v (algebraMap O R x)
-- Mathlib/SetTheory/Game/Birthday.lean
@[simp]
theorem toPGame_birthday (o : Ordinal) : o.toPGame.birthday = o
-- Mathlib/LinearAlgebra/DFinsupp.lean
/-- Combining `DFinsupp.lsum` with `LinearMap.toSpanSingleton` is the same as `Finsupp.total` -/
theorem lsum_comp_mapRange_toSpanSingleton [∀ m : R, Decidable (m ≠ 0)] (p : ι → Submodule R N)
    {v : ι → N} (hv : ∀ i : ι, v i ∈ p i) :
    (lsum ℕ (M := fun i ↦ ↥(p i)) fun i => (p i).subtype : _ →ₗ[R] _).comp
        ((mapRange.linearMap fun i => LinearMap.toSpanSingleton R (↥(p i)) ⟨v i, hv i⟩ :
              _ →ₗ[R] _).comp
          (finsuppLequivDFinsupp R : (ι →₀ R) ≃ₗ[R] _).toLinearMap) =
      Finsupp.total ι N R v
-- Mathlib/Algebra/Lie/UniversalEnveloping.lean
theorem lift_unique (g : UniversalEnvelopingAlgebra R L →ₐ[R] A) : g ∘ ι R = f ↔ g = lift R f
-- Mathlib/Topology/Filter.lean
protected nonrec theorem Continuous.nhds (h : Continuous f) : Continuous (𝓝 ∘ f)
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
/-- If two ring homomorphisms from `k[G]` are equal on all `single a 1`
and `single 0 b`, then they are equal. -/
theorem ringHom_ext {R} [Semiring k] [AddMonoid G] [Semiring R] {f g : k[G] →+* R}
    (h₀ : ∀ b, f (single 0 b) = g (single 0 b)) (h_of : ∀ a, f (single a 1) = g (single a 1)) :
    f = g
-- Mathlib/Data/Set/Card.lean
theorem encard_pair {x y : α} (hne : x ≠ y) : ({x, y} : Set α).encard = 2
-- Mathlib/Data/Real/ENatENNReal.lean
@[simp, norm_cast]
theorem toENNReal_top : ((⊤ : ℕ∞) : ℝ≥0∞) = ⊤
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- The sum of two `C^n` functions on a domain is `C^n`. -/
theorem ContDiffOn.add {s : Set E} {f g : E → F} (hf : ContDiffOn 𝕜 n f s)
    (hg : ContDiffOn 𝕜 n g s) : ContDiffOn 𝕜 n (fun x => f x + g x) s
-- Mathlib/Data/DFinsupp/Order.lean
theorem tsub_apply (f g : Π₀ i, α i) (i : ι) : (f - g) i = f i - g i
-- Mathlib/Data/Real/Hyperreal.lean
theorem isSt_of_tendsto {f : ℕ → ℝ} {r : ℝ} (hf : Tendsto f atTop (𝓝 r)) : IsSt (ofSeq f) r
-- Mathlib/Topology/QuasiSeparated.lean
theorem IsQuasiSeparated.of_quasiSeparatedSpace (s : Set α) [QuasiSeparatedSpace α] :
    IsQuasiSeparated s
-- Mathlib/Algebra/Category/BialgebraCat/Basic.lean
@[simp]
theorem forget₂_coalgebra_map (X Y : BialgebraCat R) (f : X ⟶ Y) :
    (forget₂ (BialgebraCat R) (CoalgebraCat R)).map f = CoalgebraCat.ofHom f.toBialgHom
-- Mathlib/Algebra/Category/ModuleCat/Sheaf/Quasicoherent.lean
/-- A sheaf of modules is quasi-coherent if it is locally the cokernel of a
morphism between coproducts of copies of the sheaf of rings. -/
class IsQuasicoherent : Prop where
  nonempty_quasicoherentData : Nonempty M.QuasicoherentData
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
theorem norm_smul (c : ℝ) (x : E K) :
    mixedEmbedding.norm (c • x) = |c| ^ finrank ℚ K * (mixedEmbedding.norm x)
-- Mathlib/Topology/LocalAtTarget.lean
theorem isClosedMap_iff_isClosedMap_of_iSup_eq_top :
    IsClosedMap f ↔ ∀ i, IsClosedMap ((U i).1.restrictPreimage f)
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem coeFn_toLp [NormedField 𝕜] [NormedSpace 𝕜 E] (f : C(α, E)) :
    toLp (E := E) p μ 𝕜 f =ᵐ[μ] f
-- Mathlib/RingTheory/WittVector/Verschiebung.lean
@[simp]
theorem verschiebung_coeff_zero (x : 𝕎 R) : (verschiebung x).coeff 0 = 0
-- Mathlib/Data/Int/ModEq.lean
theorem modEq_iff_dvd : a ≡ b [ZMOD n] ↔ n ∣ b - a
-- Mathlib/GroupTheory/Perm/Closure.lean
theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.Coprime n (Fintype.card α))
    (h1 : IsCycle σ) (h2 : σ.support = Finset.univ) (x : α) :
    closure ({σ, swap x ((σ ^ n) x)} : Set (Perm α)) = ⊤
-- Mathlib/Algebra/Field/Subfield.lean
theorem not_mem_of_not_mem_closure {s : Set K} {P : K} (hP : P ∉ closure s) : P ∉ s