ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Group/Units/Hom.lean
@[to_additive]
lemma map_injective {f : M →* N} (hf : Function.Injective f) :
    Function.Injective (map f)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Gcd.lean
@[simp] theorem neg_gcd {a b : Int} : gcd (-a) b = gcd a b
-- Mathlib/Analysis/Complex/Basic.lean
@[simp] lemma one_mem_slitPlane : 1 ∈ slitPlane
-- Mathlib/Data/Set/Image.lean
theorem image_compl_eq {f : α → β} {s : Set α} (H : Bijective f) : f '' sᶜ = (f '' s)ᶜ
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
/-- When the first map `S.f` is zero, this is the homology data on `S` given
by the chosen `kernel S.g` -/
@[simps]
noncomputable def ofHasKernel (hf : S.f = 0) [HasKernel S.g] :
    S.HomologyData
-- Mathlib/RingTheory/Finiteness.lean
theorem fg_finset_sup {ι : Type*} (s : Finset ι) (N : ι → Submodule R M) (h : ∀ i ∈ s, (N i).FG) :
    (s.sup N).FG
-- Mathlib/RingTheory/Generators.lean
/-- Given two families of generators `S[X] → T` and `R[Y] → S`,
we may constuct the family of generators `R[X, Y] → T`. -/
@[simps val, simps (config := .lemmasOnly) vars σ]
noncomputable
def comp (Q : Generators S T) (P : Generators R S) : Generators R T
-- Mathlib/Order/UpperLower/Hom.lean
@[simp]
theorem iicsInfHom_apply (a : α) : iicsInfHom a = Iic a
-- Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean
@[simp]
theorem volume_Ioo {a b : ℝ} : volume (Ioo a b) = ofReal (b - a)
-- Mathlib/SetTheory/Game/Ordinal.lean
@[simp]
theorem toPGame_equiv_iff {a b : Ordinal} : (a.toPGame ≈ b.toPGame) ↔ a = b
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem continuousOn_symm {s} : ContinuousOn I.symm s
-- Mathlib/RingTheory/PowerSeries/WellKnown.lean
@[simp]
theorem constantCoeff_exp : constantCoeff A (exp A) = 1
-- Mathlib/Topology/Order/NhdsSet.lean
theorem Ioc_mem_nhdsSet_Icc (h : a < b) (h' : c < d) : Ioc a d ∈ 𝓝ˢ (Icc b c)
-- Mathlib/Topology/Basic.lean
theorem ClusterPt.of_nhds_le {f : Filter X} (H : 𝓝 x ≤ f) : ClusterPt x f
-- Mathlib/RingTheory/PrincipalIdealDomain.lean
theorem mem_iff_generator_dvd (S : Ideal R) [S.IsPrincipal] {x : R} : x ∈ S ↔ generator S ∣ x
-- Mathlib/RingTheory/Jacobson.lean
theorem isJacobson_of_surjective [H : IsJacobson R] :
    (∃ f : R →+* S, Function.Surjective ↑f) → IsJacobson S
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
@[to_additive sum_le_sum_of_subset]
theorem prod_le_prod_of_subset' (h : s ⊆ t) : ∏ x ∈ s, f x ≤ ∏ x ∈ t, f x
-- Mathlib/Order/Filter/EventuallyConst.lean
theorem eventuallyConst_preimage {s : Set β} {f : α → β} :
    EventuallyConst (f ⁻¹' s) l ↔ EventuallyConst s (map f l)
-- Mathlib/CategoryTheory/Whiskering.lean
@[simp]
theorem whiskerLeft_id' (F : C ⥤ D) {G : D ⥤ E} : whiskerLeft F (𝟙 G) = 𝟙 (F.comp G)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.add_isBigO (h₁ : f₁ =o[l] g) (h₂ : f₂ =O[l] g) : (fun x => f₁ x + f₂ x) =O[l] g
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
theorem infEdist_le_edist_add_infEdist : infEdist x s ≤ edist x y + infEdist y s
-- Mathlib/Analysis/BoxIntegral/Partition/Filter.lean
theorem gp_le : GP ≤ l
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem ofRelIsoLT_apply {α β} [PartialOrder α] [PartialOrder β]
    (e : ((· < ·) : α → α → Prop) ≃r ((· < ·) : β → β → Prop)) (x : α) : ofRelIsoLT e x = e x
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
@[to_additive sum_lt_sum_of_nonempty]
theorem prod_lt_prod_of_nonempty' (hs : s.Nonempty) (hlt : ∀ i ∈ s, f i < g i) :
    ∏ i ∈ s, f i < ∏ i ∈ s, g i
-- Mathlib/Algebra/Group/Equiv/Basic.lean
@[to_additive (attr := simp)]
theorem MulHom.toMulEquiv_symm_apply [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M)
    (h₁ : g.comp f = MulHom.id _) (h₂ : f.comp g = MulHom.id _) :
    (MulEquiv.symm (MulHom.toMulEquiv f g h₁ h₂) : N → M) = ↑g
-- Mathlib/Topology/Algebra/Group/Basic.lean
/-- A subgroup `S` of a topological group `G` acts on `G` properly discontinuously on the left, if
it is discrete in the sense that `S ∩ K` is finite for all compact `K`. (See also
`DiscreteTopology`.) -/
@[to_additive
  "A subgroup `S` of an additive topological group `G` acts on `G` properly
  discontinuously on the left, if it is discrete in the sense that `S ∩ K` is finite for all compact
  `K`. (See also `DiscreteTopology`."]
theorem Subgroup.properlyDiscontinuousSMul_of_tendsto_cofinite (S : Subgroup G)
    (hS : Tendsto S.subtype cofinite (cocompact G)) : ProperlyDiscontinuousSMul S G
-- Mathlib/Data/Finset/Basic.lean
@[simp] lemma union_eq_left : s ∪ t = s ↔ t ⊆ s
-- Mathlib/Analysis/Normed/Group/Pointwise.lean
@[to_additive (attr := simp)]
theorem ball_mul : ball x δ * s = x • thickening δ s
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive (attr := simp)]
theorem inl_apply (x) : inl M N x = (x, 1)
-- Mathlib/MeasureTheory/OuterMeasure/Caratheodory.lean
theorem isCaratheodory_iff_le' {s : Set α} :
    IsCaratheodory m s ↔ ∀ t, m (t ∩ s) + m (t \ s) ≤ m t
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
@[simp] protected theorem neg_zero : -(0:Int) = 0
-- Mathlib/RingTheory/TensorProduct/Basic.lean
theorem endTensorEndAlgHom_apply (f : End A M) (g : End R N) :
    endTensorEndAlgHom (R := R) (S := S) (A := A) (M := M) (N := N) (f ⊗ₜ[R] g)
      = AlgebraTensorModule.map f g
-- Mathlib/Data/Matroid/Map.lean
lemma restrictSubtype_base_iff {B : Set X} : (M.restrictSubtype X).Base B ↔ M.Basis' B X
-- Mathlib/LinearAlgebra/Pi.lean
/-- Linear map between the function spaces `I → M₂` and `I → M₃`, induced by a linear map `f`
between `M₂` and `M₃`. -/
@[simps]
protected def compLeft (f : M₂ →ₗ[R] M₃) (I : Type*) : (I → M₂) →ₗ[R] I → M₃
-- Mathlib/Order/Filter/Ultrafilter.lean
@[simp]
theorem Iic_pure (a : α) : Iic (pure a : Filter α) = {⊥, pure a}
-- Mathlib/Topology/Connected/PathConnected.lean
theorem isPathConnected_range [PathConnectedSpace X] {f : X → Y} (hf : Continuous f) :
    IsPathConnected (range f)
-- Mathlib/RingTheory/FreeRing.lean
@[simp]
theorem lift_of (x : α) : lift f (of x) = f x
-- Mathlib/Analysis/NormedSpace/MatrixExponential.lean
theorem exp_blockDiagonal (v : m → Matrix n n 𝔸) :
    exp 𝕂 (blockDiagonal v) = blockDiagonal (exp 𝕂 v)
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_apply_ite {s : Finset α} {p : α → Prop} {_hp : DecidablePred p} (f g : α → γ)
    (h : γ → β) :
    (∏ x ∈ s, h (if p x then f x else g x)) =
      (∏ x ∈ s.filter p, h (f x)) * ∏ x ∈ s.filter fun x => ¬p x, h (g x)
-- .lake/packages/lean4/src/lean/Init/GetElem.lean
@[simp] theorem getElem!_fin [GetElem? Cont Nat Elem Dom] (a : Cont) (i : Fin n)
    [Decidable (Dom a i)] [Inhabited Elem] : a[i]! = a[i.1]!
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
theorem fderiv_fst : fderiv 𝕜 Prod.fst p = fst 𝕜 E F
-- Mathlib/Computability/Primrec.lean
theorem of_equiv {β} {e : β ≃ α} :
    haveI := Primcodable.ofEquiv α e
    Primrec e
-- Mathlib/MeasureTheory/Measure/Haar/InnerProductSpace.lean
theorem OrthonormalBasis.measurePreserving_repr (b : OrthonormalBasis ι ℝ F) :
    MeasurePreserving b.repr volume volume
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- A weighted sum over `s.subtype pred` equals one over `s.filter pred`. -/
theorem weightedVSub_subtype_eq_filter (w : ι → k) (p : ι → P) (pred : ι → Prop)
    [DecidablePred pred] :
    ((s.subtype pred).weightedVSub (fun i => p i) fun i => w i) =
      (s.filter pred).weightedVSub p w
-- Mathlib/Deprecated/Group.lean
/-- Predicate for additive monoid homomorphisms
(deprecated -- use the bundled `MonoidHom` version). -/
structure IsAddMonoidHom [AddZeroClass α] [AddZeroClass β] (f : α → β) extends IsAddHom f :
  Prop where
  /-- The proposition that `f` preserves the additive identity. -/
  map_zero : f 0 = 0
-- Mathlib/Algebra/Group/Support.lean
@[to_additive]
theorem image_inter_mulSupport_eq {s : Set β} {g : β → α} :
    g '' s ∩ mulSupport f = g '' (s ∩ mulSupport (f ∘ g))
-- Mathlib/Topology/Gluing.lean
theorem preimage_image_eq_image (i j : D.J) (U : Set (𝖣.U i)) :
    𝖣.ι j ⁻¹' (𝖣.ι i '' U) = D.f _ _ '' ((D.t j i ≫ D.f _ _) ⁻¹' U)
-- Mathlib/Data/PNat/Basic.lean
theorem div_add_mod' (m k : ℕ+) : (div m k * k + mod m k : ℕ) = m
-- Mathlib/Algebra/Module/Submodule/Basic.lean
protected theorem nonempty : (p : Set M).Nonempty
-- Mathlib/Order/JordanHolder.lean
theorem toList_nodup (s : CompositionSeries X) : s.toList.Nodup
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
theorem Ideal.homogeneousCore'_eq_sSup :
    I.homogeneousCore' 𝒜 = sSup { J : Ideal A | J.IsHomogeneous 𝒜 ∧ J ≤ I }
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma smul_neg_iff_of_neg_left (ha : a < 0) : a • b < 0 ↔ 0 < b
-- Mathlib/Order/Filter/Basic.lean
theorem inter_eventuallyEq_right {s t : Set α} {l : Filter α} :
    (s ∩ t : Set α) =ᶠ[l] t ↔ ∀ᶠ x in l, x ∈ t → x ∈ s
-- Mathlib/Algebra/DualQuaternion.lean
@[simp]
theorem imK_fst_dualNumberEquiv (q : Quaternion (DualNumber R)) :
    (dualNumberEquiv q).fst.imK = q.imK.fst
-- Mathlib/Data/Nat/Log.lean
@[simp]
theorem log_one_right (b : ℕ) : log b 1 = 0
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem zero_inter (s : Multiset α) : 0 ∩ s = 0
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem transpose_one [DecidableEq n] [Zero α] [One α] : (1 : Matrix n n α)ᵀ = 1
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
theorem choice_isSome_iff_nonempty {α : Type _} : (choice α).isSome ↔ Nonempty α
-- Mathlib/GroupTheory/Submonoid/Inverses.lean
@[to_additive (attr := simp)]
theorem leftInvEquiv_symm_eq_inv (x : S) : ((S.leftInvEquiv hS).symm x : M) = (x : M)⁻¹
-- Mathlib/MeasureTheory/Function/LpSpace.lean
@[simp]
lemma indicatorConstLp_univ :
    indicatorConstLp p .univ (measure_ne_top μ _) c = Lp.const p μ c
-- Mathlib/Topology/Bases.lean
theorem IsTopologicalBasis.inf_induced {γ} [s : TopologicalSpace β] {B₁ : Set (Set α)}
    {B₂ : Set (Set β)} (h₁ : IsTopologicalBasis B₁) (h₂ : IsTopologicalBasis B₂) (f₁ : γ → α)
    (f₂ : γ → β) :
    IsTopologicalBasis (t := induced f₁ t ⊓ induced f₂ s) (image2 (f₁ ⁻¹' · ∩ f₂ ⁻¹' ·) B₁ B₂)
-- Mathlib/Algebra/Module/Submodule/Basic.lean
theorem toAddSubgroup_injective : Injective (toAddSubgroup : Submodule R M → AddSubgroup M)
-- .lake/packages/lean4/src/lean/Init/Core.lean
protected theorem Subsingleton.helim {α β : Sort u} [h₁ : Subsingleton α] (h₂ : α = β) (a : α) (b : β) : HEq a b
-- Mathlib/Computability/Primrec.lean
theorem ofNat_iff {α β σ} [Denumerable α] [Denumerable β] [Primcodable σ] {f : α → β → σ} :
    Primrec₂ f ↔ Primrec₂ fun m n : ℕ => f (ofNat α m) (ofNat β n)
-- Mathlib/Topology/Sheaves/Functors.lean
lemma pullback_eq (f : X ⟶ Y) :
    pullback A f = forget A Y ⋙ Presheaf.pullback A f ⋙ presheafToSheaf _ _
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem union_val (s t : Finset α) : (s ∪ t).1 = s.1 ∪ t.1
-- Mathlib/CategoryTheory/Opposites.lean
@[simp]
theorem removeUnop_id (F : Cᵒᵖ ⥤ Dᵒᵖ) : NatTrans.removeUnop (𝟙 F.unop) = 𝟙 F
-- Mathlib/RingTheory/Localization/AsSubring.lean
theorem map_isUnit_of_le (hS : S ≤ A⁰) (s : S) : IsUnit (algebraMap A K s)
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
@[simp]
theorem factors_le {a b : Associates α} : a.factors ≤ b.factors ↔ a ≤ b
-- Mathlib/Order/Filter/Bases.lean
theorem HasAntitoneBasis.hasBasis_ge [Preorder ι] [IsDirected ι (· ≤ ·)] {l : Filter α}
    {s : ι → Set α} (hs : l.HasAntitoneBasis s) (i : ι) : l.HasBasis (fun j => i ≤ j) s
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
/-- One can prove `QuotientMeasureEqMeasurePreimage` by checking behavior with respect to a single
fundamental domain. -/
@[to_additive]
lemma IsFundamentalDomain.quotientMeasureEqMeasurePreimage {μ : Measure (Quotient α_mod_G)}
    {s : Set α} (fund_dom_s : IsFundamentalDomain G s ν) (h : μ = (ν.restrict s).map π) :
    QuotientMeasureEqMeasurePreimage ν μ
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem center_le_centralizer {R} [Semiring R] (s) : center R ≤ centralizer s
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem sub_min_sub_right : ∀ (a b c : Nat), min (a - c) (b - c) = min a b - c
-- Mathlib/Topology/Sheaves/Stalks.lean
theorem app_injective_of_stalkFunctor_map_injective {F : Sheaf C X} {G : Presheaf C X} (f : F.1 ⟶ G)
    (U : Opens X) (h : ∀ x : U, Function.Injective ((stalkFunctor C x.val).map f)) :
    Function.Injective (f.app (op U))
-- Mathlib/Order/Hom/Basic.lean
/-- A strictly monotone function with a right inverse is an order isomorphism. -/
@[simps (config := .asFn)]
def orderIsoOfRightInverse (g : β → α) (hg : Function.RightInverse g f) : α ≃o β
-- Mathlib/Order/Filter/Basic.lean
theorem Tendsto.neBot {f : α → β} {x : Filter α} {y : Filter β} (h : Tendsto f x y) [hx : NeBot x] :
    NeBot y
-- Mathlib/Algebra/Order/Invertible.lean
@[simp]
theorem invOf_nonneg [Invertible a] : 0 ≤ ⅟ a ↔ 0 ≤ a
-- Mathlib/Order/Minimal.lean
theorem IsLeast.minimals_eq [PartialOrder α] (h : IsLeast s a) : minimals (· ≤ ·) s = {a}
-- Mathlib/Data/Finset/Lattice.lean
theorem sup'_product_right {t : Finset γ} (h : (s ×ˢ t).Nonempty) (f : β × γ → α) :
    (s ×ˢ t).sup' h f = t.sup' h.snd fun i' => s.sup' h.fst fun i => f ⟨i, i'⟩
-- Mathlib/Init/Order/LinearOrder.lean
theorem eq_max {a b c : α} (h₁ : a ≤ c) (h₂ : b ≤ c) (h₃ : ∀ {d}, a ≤ d → b ≤ d → c ≤ d) :
    c = max a b
-- Mathlib/LinearAlgebra/UnitaryGroup.lean
@[simp] theorem inv_val : ↑A⁻¹ = (star A : Matrix n n α)
-- Mathlib/Topology/ContinuousFunction/LocallyConstant.lean
/-- The inclusion of locally-constant functions into continuous functions as a linear map. -/
@[simps]
def toContinuousMapLinearMap (R : Type*) [Semiring R] [AddCommMonoid Y] [Module R Y]
    [ContinuousAdd Y] [ContinuousConstSMul R Y] : LocallyConstant X Y →ₗ[R] C(X, Y)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
theorem Expr.of_cancel_lt (ctx : Context) (a b c d : Expr) (h : Poly.cancel a.inc.toNormPoly b.toNormPoly = (c.inc.toPoly, d.toPoly)) : (a.denote ctx < b.denote ctx) = (c.denote ctx < d.denote ctx)
-- Mathlib/Algebra/Polynomial/Taylor.lean
@[simp]
theorem natDegree_taylor (p : R[X]) (r : R) : natDegree (taylor r p) = natDegree p
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
/-- Simplification of the integral of `sin x ^ m * cos x ^ n`, case `m` and `n` are both even. -/
theorem integral_sin_pow_even_mul_cos_pow_even (m n : ℕ) :
    (∫ x in a..b, sin x ^ (2 * m) * cos x ^ (2 * n)) =
      ∫ x in a..b, ((1 - cos (2 * x)) / 2) ^ m * ((1 + cos (2 * x)) / 2) ^ n
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
@[fun_prop]
theorem hasFDerivAt_of_subsingleton [h : Subsingleton E] (f : E → F) (x : E) :
    HasFDerivAt f (0 : E →L[𝕜] F) x
-- Mathlib/Topology/Order.lean
theorem setOf_isOpen_injective : Injective fun t : TopologicalSpace α => { s | IsOpen[t] s }
-- Mathlib/Topology/Algebra/UniformConvergence.lean
@[to_additive]
protected theorem UniformFun.hasBasis_nhds_one :
    (𝓝 1 : Filter (α →ᵤ G)).HasBasis (fun V : Set G => V ∈ (𝓝 1 : Filter G)) fun V =>
      { f : α → G | ∀ x, f x ∈ V }
-- Mathlib/Logic/Function/Basic.lean
/-- A symmetric relation `r : α → α → Prop` is "function-like"
(for each `a` there exists a unique `b` such that `r a b`)
if and only if it is `(f · = ·)` for some involutive function `f`. -/
protected lemma Symmetric.forall_existsUnique_iff {r : α → α → Prop} (hr : Symmetric r) :
    (∀ a, ∃! b, r a b) ↔ ∃ f : α → α, Involutive f ∧ ∀ {a b}, r a b ↔ f a = b
-- Mathlib/Topology/Order/OrderClosed.lean
theorem le_of_tendsto_of_tendsto {f g : β → α} {b : Filter β} {a₁ a₂ : α} [NeBot b]
    (hf : Tendsto f b (𝓝 a₁)) (hg : Tendsto g b (𝓝 a₂)) (h : f ≤ᶠ[b] g) : a₁ ≤ a₂
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem lTensor_tmul (m : M) (n : N) : f.lTensor M (m ⊗ₜ n) = m ⊗ₜ f n
-- Mathlib/CategoryTheory/EpiMono.lean
@[reassoc (attr := simp)]
theorem IsSplitEpi.id {X Y : C} (f : X ⟶ Y) [hf : IsSplitEpi f] : section_ f ≫ f = 𝟙 Y
-- Mathlib/Algebra/Polynomial/Reverse.lean
/-- We prefer to use the bundled `revAt` over unbundled `revAtFun`. -/
@[simp]
theorem revAtFun_eq (N i : ℕ) : revAtFun N i = revAt N i
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
/-- The obvious homotopy between two equal morphisms of short complexes. -/
@[simps]
def ofEq (h : φ₁ = φ₂) : Homotopy φ₁ φ₂
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem LinearIndependent.units_smul {v : ι → M} (hv : LinearIndependent R v) (w : ι → Rˣ) :
    LinearIndependent R (w • v)
-- Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean
theorem nnnorm_symm_pos [RingHomIsometric σ₁₂] [Nontrivial E] (e : E ≃SL[σ₁₂] F) :
    0 < ‖(e.symm : F →SL[σ₂₁] E)‖₊
-- Mathlib/Data/Matrix/Kronecker.lean
theorem kroneckerMap_map (f : α → β → γ) (g : γ → γ') (A : Matrix l m α) (B : Matrix n p β) :
    (kroneckerMap f A B).map g = kroneckerMap (fun a b => g (f a b)) A B
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_re_symm (x y : F) : re ⟪x, y⟫ = re ⟪y, x⟫
-- Mathlib/Order/Interval/Set/Pi.lean
theorem image_update_Ioo_left (f : ∀ i, α i) (i : ι) (a : α i) :
    update f i '' Ioo a (f i) = Ioo (update f i a) f
-- Mathlib/Deprecated/Subgroup.lean
@[to_additive]
theorem Subgroup.of_normal [Group G] (s : Set G) (h : IsSubgroup s) (n : IsNormalSubgroup s) :
    Subgroup.Normal (Subgroup.of h)
-- Mathlib/Data/Option/Basic.lean
@[simp]
theorem orElse_eq_none (o o' : Option α) : (o <|> o') = none ↔ o = none ∧ o' = none
-- Mathlib/Algebra/Order/Interval/Basic.lean
@[to_additive]
theorem inv_mem_inv (ha : a ∈ s) : a⁻¹ ∈ s⁻¹
-- Mathlib/Data/Rat/Cast/Order.lean
@[simp, norm_cast] lemma cast_max (p q : ℚ≥0) : (↑(max p q) : K) = max (p : K) (q : K)
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
/-- Lebesgue dominated convergence theorem for filters with a countable basis -/
theorem tendsto_setToFun_filter_of_dominated_convergence (hT : DominatedFinMeasAdditive μ T C) {ι}
    {l : Filter ι} [l.IsCountablyGenerated] {fs : ι → α → E} {f : α → E} (bound : α → ℝ)
    (hfs_meas : ∀ᶠ n in l, AEStronglyMeasurable (fs n) μ)
    (h_bound : ∀ᶠ n in l, ∀ᵐ a ∂μ, ‖fs n a‖ ≤ bound a) (bound_integrable : Integrable bound μ)
    (h_lim : ∀ᵐ a ∂μ, Tendsto (fun n => fs n a) l (𝓝 (f a))) :
    Tendsto (fun n => setToFun μ T hT (fs n)) l (𝓝 <| setToFun μ T hT f)
-- Mathlib/Algebra/MvPolynomial/Variables.lean
theorem vars_rename [DecidableEq τ] (f : σ → τ) (φ : MvPolynomial σ R) :
    (rename f φ).vars ⊆ φ.vars.image f
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
@[to_additive]
lemma Multipliable.of_finite [Finite β] {f : β → α} : Multipliable f
-- Mathlib/Tactic/Ring/Basic.lean
theorem add_pf_add_zero (a : R) : a + 0 = a
-- Mathlib/Data/Multiset/Basic.lean
theorem map_comp_cons (f : α → β) (t) : map f ∘ cons t = cons (f t) ∘ map f
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem mod_self (a : Ordinal) : a % a = 0
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
@[to_additive]
theorem multipliable_one : Multipliable (fun _ ↦ 1 : β → α)
-- Mathlib/Analysis/Convex/Quasiconvex.lean
theorem QuasiconvexOn.sup [SemilatticeSup β] (hf : QuasiconvexOn 𝕜 s f)
    (hg : QuasiconvexOn 𝕜 s g) : QuasiconvexOn 𝕜 s (f ⊔ g)
-- Mathlib/Data/Matroid/Basic.lean
theorem Dep.not_indep (hD : M.Dep D) : ¬ M.Indep D
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
@[simp]
theorem det_nonsing_inv : A⁻¹.det = Ring.inverse A.det
-- Mathlib/Algebra/TrivSqZeroExt.lean
protected theorem mul_inv_rev (a b : tsze R M) :
    (a * b)⁻¹ = b⁻¹ * a⁻¹
-- Mathlib/NumberTheory/EulerProduct/DirichletLSeries.lean
/-- The Euler product for the Riemann ζ function, valid for `s.re > 1`.
This version is stated in terms of `tprod`. -/
theorem riemannZeta_eulerProduct_tprod (hs : 1 < s.re) :
    ∏' p : Primes, (1 - (p : ℂ) ^ (-s))⁻¹ = riemannZeta s
-- Mathlib/Logic/Equiv/Defs.lean
/-- The equivalence `(∀ i, β i) ≃ β ⋆` when the domain of `β` only contains `⋆` -/
@[simps (config := .asFn)]
def piUnique [Unique α] (β : α → Sort*) : (∀ i, β i) ≃ β default
-- Mathlib/FieldTheory/SeparableDegree.lean
/-- If `K / E / F` is an extension tower such that `E / F` is separable,
`x : K` is separable over `E`, then it's also separable over `F`. -/
theorem IsSeparable.of_algebra_isSeparable_of_isSeparable [Algebra E K] [IsScalarTower F E K]
    [Algebra.IsSeparable F E] {x : K} (hsep : IsSeparable E x) : IsSeparable F x
-- Mathlib/Deprecated/Subgroup.lean
@[to_additive]
theorem isNormalSubgroup_of_commGroup [CommGroup G] {s : Set G} (hs : IsSubgroup s) :
    IsNormalSubgroup s
-- Mathlib/Data/Matrix/Rank.lean
theorem rank_mul_le_right [StrongRankCondition R] (A : Matrix m n R) (B : Matrix n o R) :
    (A * B).rank ≤ B.rank
-- Mathlib/Order/Filter/Cofinite.lean
@[simp]
theorem cofinite_eq_bot_iff : @cofinite α = ⊥ ↔ Finite α
-- Mathlib/RingTheory/Localization/Basic.lean
theorem IsLocalization.lift_algebraMap_eq_algebraMap :
    IsLocalization.lift (M := M) (IsLocalization.map_units_map_submonoid S Sₘ) =
      algebraMap Rₘ Sₘ
-- Mathlib/CategoryTheory/Monoidal/Comon_.lean
/--
The contravariant functor turning comonoid objects into monoid objects in the opposite category.
-/
@[simps] def Comon_ToMon_OpOp : Comon_ C ⥤ (Mon_ (Cᵒᵖ))ᵒᵖ
-- Mathlib/NumberTheory/DirichletCharacter/Basic.lean
lemma Even.eval_neg (x : ZMod m) (hψ : ψ.Even) : ψ (- x) = ψ x
-- Mathlib/Computability/PartrecCode.lean
theorem encode_lt_comp (cf cg) :
    encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg)
-- Mathlib/LinearAlgebra/Span.lean
theorem span_range_eq_iSup {ι : Sort*} {v : ι → M} : span R (range v) = ⨆ i, R ∙ v i
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem lift.principalSeg_coe :
    (lift.principalSeg.{u, v} : Ordinal → Ordinal) = lift.{max (u + 1) v}
-- Mathlib/RingTheory/Ideal/Over.lean
theorem IntegralClosure.comap_ne_bot [Nontrivial R] {I : Ideal (integralClosure R S)}
    (I_ne_bot : I ≠ ⊥) : I.comap (algebraMap R (integralClosure R S)) ≠ ⊥
-- Mathlib/Algebra/BigOperators/Group/List.lean
@[to_additive]
theorem prod_hom (l : List M) {F : Type*} [FunLike F M N] [MonoidHomClass F M N] (f : F) :
    (l.map f).prod = f l.prod
-- Mathlib/Data/Matroid/Dual.lean
@[aesop unsafe 10% (rule_sets := [Matroid])]
theorem Coindep.subset_ground (hX : M.Coindep X) : X ⊆ M.E
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp]
theorem map_id : map (LinearMap.id : M →ₗ[R'] M) = AlgHom.id R' _
-- Mathlib/Order/Filter/Extr.lean
theorem isMinOn_iff : IsMinOn f s a ↔ ∀ x ∈ s, f a ≤ f x
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem congr_symm_apply (f : A ≃ₐ[S] B) (g : C ≃ₐ[R] D) (x) :
    (congr f g).symm x = (map (f.symm : B →ₐ[S] A) (g.symm : D →ₐ[R] C)) x
-- Mathlib/Topology/Algebra/FilterBasis.lean
/-- A `RingFilterBasis` on a ring is a `FilterBasis` satisfying some additional axioms.
  Example : if `R` is a topological ring then the neighbourhoods of the identity are a
  `RingFilterBasis`. Conversely given a `RingFilterBasis` on a ring `R`, one can define a
  topology on `R` which is compatible with the ring structure. -/
class RingFilterBasis (R : Type u) [Ring R] extends AddGroupFilterBasis R where
  mul' : ∀ {U}, U ∈ sets → ∃ V ∈ sets, V * V ⊆ U
  mul_left' : ∀ (x₀ : R) {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x ↦ x₀ * x) ⁻¹' U
  mul_right' : ∀ (x₀ : R) {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x ↦ x * x₀) ⁻¹' U
-- Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean
theorem reverse_involute :
    ∀ a : CliffordAlgebra Q, reverse (involute a) = involute (reverse a)
-- Mathlib/Algebra/Module/Equiv/Defs.lean
theorem coe_injective : @Injective (M ≃ₛₗ[σ] M₂) (M → M₂) CoeFun.coe
-- Mathlib/RingTheory/Localization/Algebra.lean
lemma mapₐ_surjective_of_surjective (f : A →ₐ[R] B) (hf : Function.Surjective f) :
    Function.Surjective (mapₐ M Rₚ Aₚ Bₚ f)
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
@[to_additive]
theorem Multipliable.map_tprod [CommMonoid γ] [TopologicalSpace γ] [T2Space γ] (hf : Multipliable f)
    {G} [FunLike G α γ] [MonoidHomClass G α γ] (g : G) (hg : Continuous g) :
    g (∏' i, f i) = ∏' i, g (f i)
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem refl_trans (e : α ≃o β) : (refl α).trans e = e
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem cancel_right {g₁ g₂ : SupHom β γ} {f : SupHom α β} (hf : Surjective f) :
    g₁.comp f = g₂.comp f ↔ g₁ = g₂
-- Mathlib/Order/SupClosed.lean
lemma finsetInf'_mem_infClosure {ι : Type*} {t : Finset ι} (ht : t.Nonempty) {f : ι → α}
    (hf : ∀ i ∈ t, f i ∈ s) : t.inf' ht f ∈ infClosure s