ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/NumberTheory/PrimesCongruentOne.lean
theorem frequently_atTop_modEq_one {k : ℕ} (hk0 : k ≠ 0) :
    ∃ᶠ p in atTop, Nat.Prime p ∧ p ≡ 1 [MOD k]
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Basic.lean
theorem bitwise_rec_lemma {n : Nat} (hNe : n ≠ 0) : n / 2 < n
-- Mathlib/Algebra/Algebra/Pi.lean
@[simp]
theorem algebraMap_apply {_ : CommSemiring R} [_s : ∀ i, Semiring (f i)] [∀ i, Algebra R (f i)]
    (a : R) (i : I) : algebraMap R (∀ i, f i) a i = algebraMap R (f i) a
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
theorem HasFDerivAtFilter.add (hf : HasFDerivAtFilter f f' x L)
    (hg : HasFDerivAtFilter g g' x L) : HasFDerivAtFilter (fun y => f y + g y) (f' + g') x L
-- Mathlib/RingTheory/FractionalIdeal/Norm.lean
theorem coeIdeal_absNorm (I₀ : Ideal R) :
    absNorm (I₀ : FractionalIdeal R⁰ K) = Ideal.absNorm I₀
-- Mathlib/AlgebraicGeometry/EllipticCurve/Projective.lean
lemma equation_zero (Y : R) : W.Equation ![0, Y, 0]
-- Mathlib/Data/Option/Basic.lean
@[simp]
lemma bnot_comp_isSome : (! ·) ∘ @Option.isSome α = Option.isNone
-- Mathlib/Analysis/Normed/Group/Pointwise.lean
@[to_additive]
theorem IsCompact.mul_closedBall_one (hs : IsCompact s) (hδ : 0 ≤ δ) :
    s * closedBall (1 : E) δ = cthickening δ s
-- Mathlib/Algebra/MvPolynomial/Variables.lean
@[simp]
theorem vars_C : (C r : MvPolynomial σ R).vars = ∅
-- Mathlib/Probability/ProbabilityMassFunction/Constructions.lean
theorem ofFinset_apply_of_not_mem {a : α} (ha : a ∉ s) : ofFinset f s h h' a = 0
-- Mathlib/Data/Set/Finite.lean
protected theorem infinite_or_finite (s : Set α) : s.Infinite ∨ s.Finite
-- Mathlib/MeasureTheory/Group/Action.lean
@[to_additive (attr := simp)]
theorem map_smul : map (c • ·) μ = μ
-- Mathlib/Combinatorics/Additive/FreimanHom.lean
@[to_additive] lemma IsMulFreimanHom.subset (hA : A₁ ⊆ A₂) (hf : IsMulFreimanHom n A₂ B₂ f)
    (hf' : MapsTo f A₁ B₁) : IsMulFreimanHom n A₁ B₁ f
-- Mathlib/Topology/PartialHomeomorph.lean
@[simp, mfld_simps]
theorem map_source {x : X} (h : x ∈ e.source) : e x ∈ e.target
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
theorem _root_.Zspan.isZlattice {E ι : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [Finite ι] (b : Basis ι ℝ E) :
    IsZlattice ℝ (span ℤ (Set.range b)).toAddSubgroup
-- Mathlib/GroupTheory/GroupAction/ConjAct.lean
/-- The stabilizer of `Mˣ` acting on itself by conjugation at `x : Mˣ` is exactly the
units of the centralizer of `x : M`. -/
@[simps! apply_coe_val symm_apply_val_coe]
def unitsCentralizerEquiv (x : Mˣ) :
    (Submonoid.centralizer ({↑x} : Set M))ˣ ≃* MulAction.stabilizer (ConjAct Mˣ) x
-- Mathlib/CategoryTheory/Preadditive/ProjectiveResolution.lean
theorem complex_d_succ_comp (n : ℕ) :
    P.complex.d n (n + 1) ≫ P.complex.d (n + 1) (n + 2) = 0
-- Mathlib/Algebra/Category/ModuleCat/Monoidal/Basic.lean
@[simps (config := .lemmasOnly)]
instance instMonoidalCategoryStruct : MonoidalCategoryStruct (ModuleCat.{u} R)
-- Mathlib/Algebra/Module/Submodule/RestrictScalars.lean
/-- `restrictScalars S` is an embedding of the lattice of `R`-submodules into
the lattice of `S`-submodules. -/
@[simps]
def restrictScalarsEmbedding : Submodule R M ↪o Submodule S M
-- Mathlib/AlgebraicGeometry/Pullbacks.lean
theorem cocycle (i j k : 𝒰.J) : t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j = 𝟙 _
-- Mathlib/Order/Disjoint.lean
theorem Disjoint.sup_right (hb : Disjoint a b) (hc : Disjoint a c) : Disjoint a (b ⊔ c)
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Restrict.lean
/-- Given a `ContinuousFunctionalCalculus S q`. If we form the predicate `p` for `a : A`
characterized by: `q a` and the spectrum of `a` restricts to the scalar subring `R` via
`f : C(S, R)`, then we can get a restricted functional calculus
`ContinuousFunctionalCalculus R p`. -/
protected theorem cfc (f : C(S, R)) (halg : UniformEmbedding (algebraMap R S)) (h0 : p 0)
    (h : ∀ a, p a ↔ q a ∧ SpectrumRestricts a f) (h_cpct : ∀ a, q a → CompactSpace (spectrum S a)) :
    ContinuousFunctionalCalculus R p
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem inter_smul_union_subset_union [DecidableEq α] : (s₁ ∩ s₂) • (t₁ ∪ t₂) ⊆ s₁ • t₁ ∪ s₂ • t₂
-- Mathlib/Topology/Algebra/InfiniteSum/Ring.lean
theorem Summable.mul_left (a) (hf : Summable f) : Summable fun i ↦ a * f i
-- Mathlib/Topology/Homeomorph.lean
protected theorem secondCountableTopology [SecondCountableTopology Y]
    (h : X ≃ₜ Y) : SecondCountableTopology X
-- Mathlib/RingTheory/JacobsonIdeal.lean
/-- An ideal `I` is local iff its Jacobson radical is maximal. -/
class IsLocal (I : Ideal R) : Prop where
  /-- A ring `R` is local if and only if its jacobson radical is maximal -/
  out : IsMaximal (jacobson I)
-- Mathlib/Data/Real/Irrational.lean
theorem of_add_nat (m : ℕ) (h : Irrational (x + m)) : Irrational x
-- Mathlib/Algebra/RingQuot.lean
theorem Rel.neg {R : Type uR} [Ring R] {r : R → R → Prop} ⦃a b : R⦄ (h : Rel r a b) :
    Rel r (-a) (-b)
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_div [Div β] (f g : α →ₛ β) : ⇑(f / g) = ⇑f / ⇑g
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
@[simp]
theorem unitCoeff_coe {x : ℤ_[p]} (hx : x ≠ 0) :
    (unitCoeff hx : ℚ_[p]) = x * (p : ℚ_[p]) ^ (-x.valuation)
-- Mathlib/Combinatorics/Quiver/Covering.lean
theorem Prefunctor.isCovering_of_bijective_star (h : ∀ u, Bijective (φ.star u)) : φ.IsCovering
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
theorem comp (hg : MeasurableEmbedding g) (hf : MeasurableEmbedding f) :
    MeasurableEmbedding (g ∘ f)
-- Mathlib/SetTheory/Cardinal/Finite.lean
lemma card_le_card_of_surjective {α : Type u} {β : Type v} [Finite α] (f : α → β)
    (hf : Surjective f) : Nat.card β ≤ Nat.card α
-- Mathlib/Algebra/Order/Monoid/Unbundled/Defs.lean
/-- Dual of `Monotone.covariant_of_const` -/
theorem Antitone.covariant_of_const [CovariantClass M N μ (· ≤ ·)] (hf : Antitone f) (m : M) :
    Antitone (f <| μ m ·)
-- Mathlib/RingTheory/Kaehler/Polynomial.lean
lemma KaehlerDifferential.mvPolynomialBasis_repr_comp_D (σ) :
    (mvPolynomialBasis R σ).repr.toLinearMap.compDer (D _ _) =
      MvPolynomial.mkDerivation _ (Finsupp.single · 1)
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem HasMFDerivAt.congr_mfderiv (h : HasMFDerivAt I I' f x f') (h' : f' = f₁') :
    HasMFDerivAt I I' f x f₁'
-- Mathlib/Algebra/Star/StarAlgHom.lean
@[simp]
theorem coe_id : ⇑(StarAlgHom.id R A) = id
-- Mathlib/Data/Quot.lean
theorem Quotient.out_injective {s : Setoid α} : Function.Injective (@Quotient.out α s)
-- Mathlib/Topology/Basic.lean
nonrec theorem DenseRange.nonempty_iff (hf : DenseRange f) : Nonempty α ↔ Nonempty X
-- Mathlib/Computability/PartrecCode.lean
/-- Recursion on `Nat.Partrec.Code` is computable. -/
theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c)
    {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l)
    {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr)
    {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ}
    (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) :
    let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg)
    let CO (a) cf cg hf hg := co a (cf, cg, hf, hg)
    let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg)
    let RF (a) cf hf := rf a (cf, hf)
    let F (a : α) (c : Code) : σ :=
      Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a)
    Computable fun a => F a (c a)
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
/-- Uniform integrability is preserved by restriction of the measure to a set. -/
protected theorem restrict (hf : UnifIntegrable f p μ) (E : Set α) :
    UnifIntegrable f p (μ.restrict E)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- Bessel's inequality. -/
theorem Orthonormal.tsum_inner_products_le (hv : Orthonormal 𝕜 v) :
    ∑' i, ‖⟪v i, x⟫‖ ^ 2 ≤ ‖x‖ ^ 2
-- Mathlib/Logic/Basic.lean
theorem Or.elim3 {c d : Prop} (h : a ∨ b ∨ c) (ha : a → d) (hb : b → d) (hc : c → d) : d
-- Mathlib/Data/Fintype/Card.lean
protected theorem nonempty (α : Type*) [Infinite α] : Nonempty α
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
@[simp] theorem sign_sign : sign (sign x) = sign x
-- Mathlib/Order/Atoms.lean
theorem isAtom_iff {f : ∀ i, π i} [∀ i, PartialOrder (π i)] [∀ i, OrderBot (π i)] :
    IsAtom f ↔ ∃ i, IsAtom (f i) ∧ ∀ j, j ≠ i → f j = ⊥
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive]
theorem mul_left_cancel'' [ContravariantClass α α (· * ·) (· ≤ ·)] {a b c : α} (h : a * b = a * c) :
    b = c
-- Mathlib/Algebra/Category/FGModuleCat/Basic.lean
private theorem evaluation_coevaluation :
    FGModuleCatCoevaluation K V ▷ V ≫
        (α_ V (FGModuleCatDual K V) V).hom ≫ V ◁ FGModuleCatEvaluation K V =
      (λ_ V).hom ≫ (ρ_ V).inv
-- Mathlib/Data/Part.lean
theorem some_sdiff_some [SDiff α] (a b : α) : some a \ some b = some (a \ b)
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem subset_union_right {s t : Set α} : t ⊆ s ∪ t
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
@[to_additive sum_pos']
theorem one_lt_prod' (h : ∀ i ∈ s, 1 ≤ f i) (hs : ∃ i ∈ s, 1 < f i) : 1 < ∏ i ∈ s, f i
-- Mathlib/CategoryTheory/Preadditive/Injective.lean
theorem projective_iff_injective_op {P : C} : Projective P ↔ Injective (op P)
-- Mathlib/Topology/Separation.lean
theorem Finset.isGδ_compl [T1Space X] (s : Finset X) : IsGδ (sᶜ : Set X)
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[arith_mult]
theorem natCast {f : ArithmeticFunction ℕ} [Semiring R] (h : f.IsMultiplicative) :
    IsMultiplicative (f : ArithmeticFunction R)
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
protected theorem list_sum_mem {L : List A} (h : ∀ x ∈ L, x ∈ S) : L.sum ∈ S
-- Mathlib/Algebra/Group/Hom/Defs.lean
/-- Composition of monoid homomorphisms is associative. -/
@[to_additive "Composition of additive monoid homomorphisms is associative."]
theorem OneHom.comp_assoc {Q : Type*} [One M] [One N] [One P] [One Q]
    (f : OneHom M N) (g : OneHom N P) (h : OneHom P Q) :
    (h.comp g).comp f = h.comp (g.comp f)
-- Mathlib/Order/Filter/AtTopBot.lean
theorem subseq_forall_of_frequently {ι : Type*} {x : ℕ → ι} {p : ι → Prop} {l : Filter ι}
    (h_tendsto : Tendsto x atTop l) (h : ∃ᶠ n in atTop, p (x n)) :
    ∃ ns : ℕ → ℕ, Tendsto (fun n => x (ns n)) atTop l ∧ ∀ n, p (x (ns n))
-- Mathlib/Topology/Instances/ENNReal.lean
protected theorem ne_top_of_tsum_ne_top (h : ∑' a, f a ≠ ∞) (a : α) : f a ≠ ∞
-- Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean
theorem ResidueField.algebraMap_eq : algebraMap R (ResidueField R) = residue R
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem map_id : map (id : M →ₗ[R] M) (id : N →ₗ[R] N) = .id
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
lemma ne_bot_iff_exists_ne_one {H : Subgroup G} : H ≠ ⊥ ↔ ∃ a : ↥H, a ≠ 1
-- Mathlib/Algebra/BigOperators/Finprod.lean
/-- The product of `f i` over `i ∈ {a, b}`, `a ≠ b`, is equal to `f a * f b`. -/
@[to_additive "The sum of `f i` over `i ∈ {a, b}`, `a ≠ b`, is equal to `f a + f b`."]
theorem finprod_mem_pair (h : a ≠ b) : (∏ᶠ i ∈ ({a, b} : Set α), f i) = f a * f b
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem compl_Ici : (Ici a)ᶜ = Iio a
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
theorem toNat_le (c : Bool) : c.toNat ≤ 1
-- Mathlib/Data/Real/Hyperreal.lean
theorem infinite_omega : Infinite ω
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem add_sub_add_right (n k m : Nat) : (n + k) - (m + k) = n - m
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem monotone_sizeUpTo : Monotone c.sizeUpTo
-- Mathlib/Topology/PartialHomeomorph.lean
protected theorem closure (h : e.IsImage s t) : e.IsImage (closure s) (closure t)
-- Mathlib/LinearAlgebra/Trace.lean
lemma isNilpotent_trace_of_isNilpotent {f : M →ₗ[R] M} (hf : IsNilpotent f) :
    IsNilpotent (trace R M f)
-- Mathlib/Analysis/CstarAlgebra/Multiplier.lean
theorem natCast_fst (n : ℕ) : (n : 𝓜(𝕜, A)).fst = n
-- Mathlib/Algebra/Module/LocalizedModule.lean
@[elab_as_elim]
theorem induction_on₂ {β : LocalizedModule S M → LocalizedModule S M → Prop}
    (h : ∀ (m m' : M) (s s' : S), β (mk m s) (mk m' s')) : ∀ x y, β x y
-- Mathlib/Algebra/FreeMonoid/Basic.lean
@[to_additive (attr := simp)]
theorem lift_eval_of (f : α → M) (x : α) : lift f (of x) = f x
-- Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean
protected theorem mdifferentiableOn {s} : MDifferentiableOn I 𝓘(𝕜, E) I s
-- Mathlib/AlgebraicGeometry/Cover/Open.lean
/-- Every open cover of a quasi-compact scheme can be refined into a finite subcover.
-/
@[simps! obj map]
def OpenCover.finiteSubcover {X : Scheme.{u}} (𝒰 : OpenCover X) [H : CompactSpace X] :
    OpenCover X
-- Mathlib/NumberTheory/DiophantineApproximation.lean
/-- Given any rational approximation `q` to the irrational real number `ξ`, there is
a good rational approximation `q'` such that `|ξ - q'| < |ξ - q|`. -/
theorem exists_rat_abs_sub_lt_and_lt_of_irrational {ξ : ℝ} (hξ : Irrational ξ) (q : ℚ) :
    ∃ q' : ℚ, |ξ - q'| < 1 / (q'.den : ℝ) ^ 2 ∧ |ξ - q'| < |ξ - q|
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- If the second of three points is weakly between the other two, the oriented angle at the
first point (reversed) is zero. -/
theorem _root_.Wbtw.oangle₃₁₂_eq_zero {p₁ p₂ p₃ : P} (h : Wbtw ℝ p₁ p₂ p₃) : ∡ p₃ p₁ p₂ = 0
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem as_sum_range' (p : R[X]) (n : ℕ) (w : p.natDegree < n) :
    p = ∑ i ∈ range n, monomial i (coeff p i)
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem toSet_sep (a : ZFSet) (p : ZFSet → Prop) :
    (ZFSet.sep p a).toSet = { x ∈ a.toSet | p x }
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
theorem isClosed_iff_zeroLocus (Z : Set (ProjectiveSpectrum 𝒜)) :
    IsClosed Z ↔ ∃ s, Z = zeroLocus 𝒜 s
-- Mathlib/Data/Set/Lattice.lean
theorem iUnion_ge_eq_iUnion_nat_add (u : ℕ → Set α) (n : ℕ) : ⋃ i ≥ n, u i = ⋃ i, u (i + n)
-- Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean
theorem IsEquivalent.congr_right {u v w : α → β} {l : Filter α} (huv : u ~[l] v) (hvw : v =ᶠ[l] w) :
    u ~[l] w
-- Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean
@[simp]
theorem prodZeroIso_hom (X : C) : (prodZeroIso X).hom = prod.fst
-- Mathlib/Data/Subtype.lean
theorem coind_surjective {α β} {f : α → β} {p : β → Prop} (h : ∀ a, p (f a)) (hf : Surjective f) :
    Surjective (coind f h)
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
/-- The (identity) equivalence between `C` and its monoidal opposite. -/
@[simps] def MonoidalOpposite.mopEquiv : C ≌ Cᴹᵒᵖ
-- Mathlib/MeasureTheory/Group/Measure.lean
/-- A measure `μ` on a measurable additive group is left invariant
  if the measure of left translations of a set are equal to the measure of the set itself. -/
class IsAddLeftInvariant [Add G] (μ : Measure G) : Prop where
  map_add_left_eq_self : ∀ g : G, map (g + ·) μ = μ
-- Mathlib/Algebra/Polynomial/Module/AEval.lean
lemma of_symm_X_smul (m : AEval R M a) :
    (of R M a).symm ((X : R[X]) • m) = a • (of R M a).symm m
-- Mathlib/Data/Num/Lemmas.lean
theorem bit1_of_bit1 : ∀ n : ZNum, n + n + 1 = n.bit1
-- Mathlib/RingTheory/PowerBasis.lean
theorem dim_ne_zero [Nontrivial S] (pb : PowerBasis R S) : pb.dim ≠ 0
-- Mathlib/LinearAlgebra/LinearDisjoint.lean
@[simp]
theorem LinearDisjoint.val_mulMap_tmul (H : M.LinearDisjoint N) (m : M) (n : N) :
    (H.mulMap (m ⊗ₜ[R] n) : S) = m.1 * n.1
-- Mathlib/Algebra/Algebra/Operations.lean
theorem le_one_toAddSubmonoid : 1 ≤ (1 : Submodule R A).toAddSubmonoid
-- Mathlib/Analysis/Complex/Isometry.lean
theorem linear_isometry_complex_aux {f : ℂ ≃ₗᵢ[ℝ] ℂ} (h : f 1 = 1) :
    f = LinearIsometryEquiv.refl ℝ ℂ ∨ f = conjLIE
-- Mathlib/Order/GaloisConnection.lean
theorem l_sInf_u_image [CompleteLattice α] [CompleteLattice β] (gi : GaloisInsertion l u)
    (s : Set β) : l (sInf (u '' s)) = sInf s
-- Mathlib/Algebra/Regular/Pow.lean
/-- Any power of a regular element is regular. -/
theorem IsRegular.pow (n : ℕ) (ra : IsRegular a) : IsRegular (a ^ n)
-- Mathlib/Algebra/DirectSum/Module.lean
/-- Coproducts in the categories of modules and additive monoids commute with the forgetful functor
from modules to additive monoids. -/
theorem coe_toModule_eq_coe_toAddMonoid :
    (toModule R ι N φ : (⨁ i, M i) → N) = toAddMonoid fun i ↦ (φ i).toAddMonoidHom
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- The composition of `C^n` functions is `C^n`. -/
theorem ContDiff.comp {g : F → G} {f : E → F} (hg : ContDiff 𝕜 n g) (hf : ContDiff 𝕜 n f) :
    ContDiff 𝕜 n (g ∘ f)
-- Mathlib/Topology/Order/PartialSups.lean
protected lemma ContinuousOn.partialSups_apply (hf : ∀ k ≤ n, ContinuousOn (f k) s) :
    ContinuousOn (fun a ↦ partialSups (f · a) n) s
-- .lake/packages/lean4/src/lean/Init/Data/Char/Lemmas.lean
@[simp] protected theorem not_le {a b : Char} : ¬ a ≤ b ↔ b < a
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem coe_comp (g : E₂ →ₛₗᵢ[σ₂₃] E₃) (f : E →ₛₗᵢ[σ₁₂] E₂) : ⇑(g.comp f) = g ∘ f
-- Mathlib/MeasureTheory/SetSemiring.lean
lemma diffFinset_subset (hC : IsSetSemiring C) (hs : s ∈ C) (ht : t ∈ C) :
    ↑(hC.diffFinset hs ht) ⊆ C
-- Mathlib/GroupTheory/Coset.lean
@[to_additive (attr := simp)]
theorem quotientiInfEmbedding_apply_mk {ι : Type*} (f : ι → Subgroup α) (g : α) (i : ι) :
    quotientiInfEmbedding f (QuotientGroup.mk g) i = QuotientGroup.mk g
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
theorem leftMulMatrix_apply (x : S) : leftMulMatrix b x = LinearMap.toMatrix b b (lmul R S x)
-- Mathlib/Topology/Order/Lattice.lean
lemma finset_inf'_nhds [SemilatticeInf L] [ContinuousInf L]
    (hne : s.Nonempty) (hs : ∀ i ∈ s, Tendsto (f i) l (𝓝 (g i))) :
    Tendsto (s.inf' hne f) l (𝓝 (s.inf' hne g))
-- Mathlib/Analysis/Normed/Group/Seminorm.lean
@[to_additive (attr := simp)]
theorem comp_zero : p.comp (1 : F →* E) = 0
-- Mathlib/Topology/MetricSpace/Thickening.lean
/-- The closure of a set equals the intersection of its closed thickenings of positive radii
accumulating at zero. -/
theorem closure_eq_iInter_cthickening' (E : Set α) (s : Set ℝ)
    (hs : ∀ ε, 0 < ε → (s ∩ Ioc 0 ε).Nonempty) : closure E = ⋂ δ ∈ s, cthickening δ E
-- Mathlib/CategoryTheory/Monoidal/Free/Basic.lean
@[simp]
theorem mk_α_hom {X Y Z : F C} : ⟦Hom.α_hom X Y Z⟧ = (α_ X Y Z).hom
-- Mathlib/Geometry/Manifold/MFDeriv/Defs.lean
theorem mdifferentiableWithinAt_iff' (f : M → M') (s : Set M) (x : M) :
    MDifferentiableWithinAt I I' f s x ↔ ContinuousWithinAt f s x ∧
    DifferentiableWithinAt 𝕜 (writtenInExtChartAt I I' x f)
      ((extChartAt I x).symm ⁻¹' s ∩ range I) ((extChartAt I x) x)
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@[simp]
theorem coe_one : ⇑(1 : P₁ ≃ᵃ[k] P₁) = id
-- Mathlib/Algebra/Order/Ring/WithTop.lean
@[simp, norm_cast] lemma coe_mul (a b : α) : (↑(a * b) : WithBot α) = a * b
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive (attr := simp)]
lemma mker_snd : mker (snd M N) = .prod ⊤ ⊥
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
protected theorem of_dist_le' {K : ℝ} (h : ∀ x ∈ s, ∀ y ∈ s, dist (f x) (f y) ≤ K * dist x y) :
    LipschitzOnWith (Real.toNNReal K) f s
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
@[simp]
theorem mem_orthogonalBilin_iff {m : M₁} : m ∈ N.orthogonalBilin B ↔ ∀ n ∈ N, B.IsOrtho n m
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem eq_of_eqOn_sdense {s : Set R} (hs : closure s = ⊤) {f g : R →+* S} (h : s.EqOn f g) :
    f = g
-- Mathlib/CategoryTheory/MorphismProperty/Composition.lean
theorem StableUnderInverse.op {P : MorphismProperty C} (h : StableUnderInverse P) :
    StableUnderInverse P.op
-- Mathlib/Data/Fin/Basic.lean
lemma natCast_def [NeZero n] (a : ℕ) : (a : Fin n) = ⟨a % n, mod_lt _ n.pos_of_neZero⟩
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
/-- A binary cofan with vertex `P` consists of the two inclusions `ι₁ : X ⟶ P` and `ι₂ : Y ⟶ P`. -/
@[simps pt]
def BinaryCofan.mk {P : C} (ι₁ : X ⟶ P) (ι₂ : Y ⟶ P) : BinaryCofan X Y
-- Mathlib/Combinatorics/Colex.lean
/-- `s < {a}` in colex iff all elements of `s` are strictly less than `a`. -/
lemma toColex_lt_singleton : toColex s < toColex {a} ↔ ∀ b ∈ s, b < a
-- Mathlib/Order/RelClasses.lean
lemma ssubset_of_eq_of_ssubset (hab : a = b) (hbc : b ⊂ c) : a ⊂ c
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
@[deprecated support_cycleOf_nonempty (since := "2024-06-16")]
theorem card_support_cycleOf_pos_iff [DecidableEq α] [Fintype α] :
    0 < card (cycleOf f x).support ↔ f x ≠ x
-- Mathlib/Data/Multiset/Basic.lean
theorem pmap_eq_map_attach {p : α → Prop} (f : ∀ a, p a → β) (s) :
    ∀ H, pmap f s H = s.attach.map fun x => f x.1 (H _ x.2)
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem mem_comp_of_mem_ball {V W : Set (β × β)} {x y z : β} (hV : SymmetricRel V)
    (hx : x ∈ ball z V) (hy : y ∈ ball z W) : (x, y) ∈ V ○ W
-- Mathlib/Data/List/Intervals.lean
theorem succ_top {n m : ℕ} (h : n ≤ m) : Ico n (m + 1) = Ico n m ++ [m]
-- Mathlib/GroupTheory/Exponent.lean
@[to_additive]
theorem pow_eq_mod_exponent {n : ℕ} (g : G) : g ^ n = g ^ (n % exponent G)
-- Mathlib/GroupTheory/CoprodI.lean
theorem equivPair_head {i : ι} {w : Word M} :
    (equivPair i w).head =
      if h : ∃ (h : w.toList ≠ []), (w.toList.head h).1 = i
      then h.snd ▸ (w.toList.head h.1).2
      else 1
-- Mathlib/CategoryTheory/Monoidal/Functor.lean
/-- The identity monoidal functor. -/
@[simps]
def id : MonoidalFunctor.{v₁, v₁} C C
-- Mathlib/Topology/Category/TopCat/Opens.lean
@[simp]
theorem map_coe (f : X ⟶ Y) (U : Opens Y) : ((map f).obj U : Set X) = f ⁻¹' (U : Set Y)
-- Mathlib/Topology/Sets/Opens.lean
@[simp]
theorem mem_iSup {ι} {x : α} {s : ι → Opens α} : x ∈ iSup s ↔ ∃ i, x ∈ s i
-- Mathlib/CategoryTheory/Monad/Algebra.lean
/-- The cofree functor from the Eilenberg-Moore category, constructing a coalgebra for any
object. -/
@[simps]
def cofree : C ⥤ Coalgebra G
-- Mathlib/Data/Stream/Init.lean
theorem interleave_eq (s₁ s₂ : Stream' α) : s₁ ⋈ s₂ = head s₁::head s₂::(tail s₁ ⋈ tail s₂)
-- Mathlib/MeasureTheory/Function/EssSup.lean
theorem essInf_congr_ae {f g : α → β} (hfg : f =ᵐ[μ] g) : essInf f μ = essInf g μ
-- Mathlib/Data/Nat/Factors.lean
theorem primeFactorsList_subset_right {n k : ℕ} (h : k ≠ 0) :
    n.primeFactorsList ⊆ (n * k).primeFactorsList
-- Mathlib/GroupTheory/GroupAction/Blocks.lean
/-- The intersection of two blocks is a block -/
theorem IsBlock.inter {B₁ B₂ : Set X} (h₁ : IsBlock G B₁) (h₂ : IsBlock G B₂) :
    IsBlock G (B₁ ∩ B₂)
-- Mathlib/CategoryTheory/Limits/Indization/IndObject.lean
theorem isFiltered (h : IsIndObject A) : IsFiltered (CostructuredArrow yoneda A)
-- Mathlib/Data/Finset/Basic.lean
theorem union_subset_right {s t u : Finset α} (h : s ∪ t ⊆ u) : t ⊆ u
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem conjTranspose_eq_natCast [DecidableEq n] [Semiring α] [StarRing α]
    {M : Matrix n n α} {d : ℕ} :
    Mᴴ = d ↔ M = d
-- Mathlib/Data/Finsupp/PWO.lean
/-- A version of **Dickson's lemma** any subset of functions `σ →₀ α` is partially well
ordered, when `σ` is `Finite` and `α` is a linear well order.
This version uses finsupps on a finite type as it is intended for use with `MVPowerSeries`.
-/
theorem Finsupp.isPWO {α σ : Type*} [Zero α] [LinearOrder α] [IsWellOrder α (· < ·)] [Finite σ]
    (S : Set (σ →₀ α)) : S.IsPWO
-- Mathlib/Order/Filter/Extr.lean
theorem IsExtrOn.elim {p : Prop} : IsExtrOn f s a → (IsMinOn f s a → p) → (IsMaxOn f s a → p) → p
-- Mathlib/Topology/Sequences.lean
protected theorem Continuous.seqContinuous {f : X → Y} (hf : Continuous f) : SeqContinuous f
-- Mathlib/Algebra/Group/Action/Opposite.lean
@[to_additive] lemma op_smul_eq_mul [Mul α] {a a' : α} : op a • a' = a' * a
-- Mathlib/CategoryTheory/Sites/CoverLifting.lean
lemma toSheafify_pullbackSheafificationCompatibility (F : Dᵒᵖ ⥤ A) :
    toSheafify J (G.op ⋙ F) ≫
    ((G.pushforwardContinuousSheafificationCompatibility A J K).hom.app F).val =
    whiskerLeft _ (toSheafify K _)
-- Mathlib/Computability/TuringMachine.lean
theorem tr_reaches {σ₁ σ₂ f₁ f₂} {tr : σ₁ → σ₂ → Prop} (H : Respects f₁ f₂ tr) {a₁ a₂}
    (aa : tr a₁ a₂) {b₁} (ab : Reaches f₁ a₁ b₁) : ∃ b₂, tr b₁ b₂ ∧ Reaches f₂ a₂ b₂
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
theorem tan_int_mul_pi_div_two (n : ℤ) : tan (n * π / 2) = 0