ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/BigOperators/Ring.lean
lemma sum_pow (f : ι → α) (n : ℕ) : (∑ a, f a) ^ n = ∑ p : Fin n → ι, ∏ i, f (p i)
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem smul_finset_card_le : (a • s).card ≤ s.card
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem toNonUnitalSubsemiring_injective :
    Function.Injective (toNonUnitalSubsemiring : NonUnitalSubring R → NonUnitalSubsemiring R)
-- Mathlib/CategoryTheory/Comma/Presheaf.lean
/-- Given `F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v`, this is the presheaf that is given by
    `YonedaCollection F X` on objects. -/
@[simps]
def yonedaCollectionPresheaf (A : Cᵒᵖ ⥤ Type v) (F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v) :
    Cᵒᵖ ⥤ Type v
-- Mathlib/Data/Holor.lean
theorem mul_right_distrib [Distrib α] (x : Holor α ds₁) (y : Holor α ds₁) (z : Holor α ds₂) :
    (x + y) ⊗ z = x ⊗ z + y ⊗ z
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[simp] theorem zero_shiftLeft : ∀ n, 0 <<< n = 0
-- Mathlib/Data/Matroid/Constructions.lean
@[simp] theorem loopyOn_base_iff : (loopyOn E).Base B ↔ B = ∅
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem mk_le_mk {f g : α → β} {hf hg} : mk f hf ≤ mk g hg ↔ f ≤ g
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
@[simp] theorem Matrix.vecMulLinear_transpose [Fintype n] (M : Matrix m n R) :
    Mᵀ.vecMulLinear = M.mulVecLin
-- Mathlib/Algebra/Order/Floor/Div.lean
lemma gc_smul_ceilDiv (ha : 0 < a) : GaloisConnection (· ⌈/⌉ a) (a • · : β → β)
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive]
theorem mulEquivOfQuotient_monoidOf (x) :
    mulEquivOfQuotient f ((monoidOf S).toMap x) = f.toMap x
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
/-- The preimage of a set `s` under a continuous linear equiv `f` has measure
equal to `μ s` times the absolute value of the inverse of the determinant of `f`. -/
@[simp]
theorem addHaar_preimage_continuousLinearEquiv (f : E ≃L[ℝ] E) (s : Set E) :
    μ (f ⁻¹' s) = ENNReal.ofReal |LinearMap.det (f.symm : E →ₗ[ℝ] E)| * μ s
-- Mathlib/Algebra/Polynomial/Smeval.lean
theorem smeval_pow : ∀ (n : ℕ), (p^n).smeval x = (p.smeval x)^n
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem le_principal_iff {s : Set α} {f : Filter α} : f ≤ 𝓟 s ↔ s ∈ f
-- Mathlib/GroupTheory/SpecificGroups/Cyclic.lean
@[to_additive]
theorem CommGroup.is_simple_iff_isCyclic_and_prime_card [Fintype α] [CommGroup α] :
    IsSimpleGroup α ↔ IsCyclic α ∧ (Fintype.card α).Prime
-- Mathlib/GroupTheory/Index.lean
@[to_additive (attr := simp) card_mul_index]
theorem card_mul_index : Nat.card H * H.index = Nat.card G
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem Integrable.sup {β} [NormedLatticeAddCommGroup β] {f g : α → β} (hf : Integrable f μ)
    (hg : Integrable g μ) : Integrable (f ⊔ g) μ
-- Mathlib/Topology/Homotopy/Path.lean
/-- Suppose `F : Homotopy p q`. Then we have a `Homotopy p.symm q.symm` by reversing the second
argument.
-/
@[simps]
def symm₂ {p q : Path x₀ x₁} (F : p.Homotopy q) : p.symm.Homotopy q.symm
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/InverseDeriv.lean
theorem differentiableWithinAt_arcsin_Ici {x : ℝ} :
    DifferentiableWithinAt ℝ arcsin (Ici x) x ↔ x ≠ -1
-- Mathlib/Data/Matrix/Block.lean
theorem toBlock_mul_eq_mul {m n k : Type*} [Fintype n] (p : m → Prop) (q : k → Prop)
    (A : Matrix m n R) (B : Matrix n k R) :
    (A * B).toBlock p q = A.toBlock p ⊤ * B.toBlock ⊤ q
-- Mathlib/Order/SuccPred/Basic.lean
@[simp]
theorem lt_succ_iff : a < succ b ↔ a ≤ b
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem exists_aleph {c : Cardinal} : ℵ₀ ≤ c ↔ ∃ o, c = aleph o
-- Mathlib/Order/Filter/Basic.lean
theorem tendsto_id' {x y : Filter α} : Tendsto id x y ↔ x ≤ y
-- Mathlib/CategoryTheory/Sites/Plus.lean
/-- The diagram whose colimit defines the values of `plus`. -/
@[simps]
def diagram (X : C) : (J.Cover X)ᵒᵖ ⥤ D
-- Mathlib/Tactic/NormNum/Basic.lean
theorem isInt_eq_true [Ring α] : {a b : α} → {z : ℤ} → IsInt a z → IsInt b z → a = b
-- Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean
theorem map_succ (a : Fin (n + 1) → ℕ) :
    map d a = a 0 + (∑ x : Fin n, a x.succ * d ^ (x : ℕ)) * d
-- Mathlib/FieldTheory/Adjoin.lean
@[simp]
theorem mem_inf {S T : IntermediateField F E} {x : E} : x ∈ S ⊓ T ↔ x ∈ S ∧ x ∈ T
-- Mathlib/Data/Finsupp/NeLocus.lean
theorem neLocus_comm : f.neLocus g = g.neLocus f
-- Mathlib/Algebra/Ring/Divisibility/Basic.lean
/-- An element a divides the sum b + a if and only if a divides b. -/
@[simp]
theorem dvd_add_self_right {a b : α} : a ∣ b + a ↔ a ∣ b
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Mul.lean
@[simp]
theorem opNorm_mul_apply_le (x : 𝕜') : ‖mul 𝕜 𝕜' x‖ ≤ ‖x‖
-- Mathlib/Algebra/Lie/TraceForm.lean
lemma traceForm_eq_sum_weightSpaceOf [IsTriangularizable R L M] (z : L) :
    traceForm R L M =
    ∑ χ ∈ (finite_weightSpaceOf_ne_bot R L M z).toFinset, traceForm R L (weightSpaceOf M χ z)
-- Mathlib/Order/Interval/Set/Basic.lean
theorem not_mem_Iic : c ∉ Iic b ↔ b < c
-- Mathlib/Algebra/Ring/CentroidHom.lean
@[simp, norm_cast]
theorem coe_id : ⇑(CentroidHom.id α) = id
-- Mathlib/Topology/Algebra/UniformGroup.lean
@[to_additive UniformContinuous.const_zsmul]
theorem UniformContinuous.zpow_const [UniformSpace β] {f : β → α} (hf : UniformContinuous f) :
    ∀ n : ℤ, UniformContinuous fun x => f x ^ n
-- Mathlib/Analysis/Convolution.lean
theorem convolution_precompR_apply {g : G → E'' →L[𝕜] E'} (hf : LocallyIntegrable f μ)
    (hcg : HasCompactSupport g) (hg : Continuous g) (x₀ : G) (x : E'') :
    (f ⋆[L.precompR E'', μ] g) x₀ x = (f ⋆[L, μ] fun a => g a x) x₀
-- Mathlib/Order/Filter/Basic.lean
protected theorem Tendsto.if {l₁ : Filter α} {l₂ : Filter β} {f g : α → β} {p : α → Prop}
    [∀ x, Decidable (p x)] (h₀ : Tendsto f (l₁ ⊓ 𝓟 { x | p x }) l₂)
    (h₁ : Tendsto g (l₁ ⊓ 𝓟 { x | ¬p x }) l₂) :
    Tendsto (fun x => if p x then f x else g x) l₁ l₂
-- Mathlib/RingTheory/Localization/LocalizationLocalization.lean
/--
Given a submodule `M ⊆ R` and a prime ideal `p` of `S = M⁻¹R`, with `f : R →+* S` the localization
map, then `T = Sₚ` is the localization of `R` at `f⁻¹(p)`.
-/
theorem isLocalization_isLocalization_atPrime_isLocalization (p : Ideal S) [Hp : p.IsPrime]
    [IsLocalization.AtPrime T p] : IsLocalization.AtPrime T (p.comap (algebraMap R S))
-- Mathlib/Algebra/Group/Hom/Defs.lean
@[to_additive]
theorem MonoidHom.toMulHom_injective [MulOneClass M] [MulOneClass N] :
    Function.Injective (MonoidHom.toMulHom : (M →* N) → M →ₙ* N)
-- Mathlib/Data/Nat/Nth.lean
@[simp]
theorem nth_count {n : ℕ} (hpn : p n) : nth p (count p n) = n
-- Mathlib/CategoryTheory/Iso.lean
theorem of_isIso_fac_right {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} {h : X ⟶ Z} [IsIso g]
    [hh : IsIso h] (w : f ≫ g = h) : IsIso f
-- Mathlib/MeasureTheory/OuterMeasure/AE.lean
theorem inter_ae_eq_right_of_ae_eq_univ (h : s =ᵐ[μ] univ) : (s ∩ t : Set α) =ᵐ[μ] t
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
theorem hasCoequalizer_epi_comp [HasCoequalizer f g] {W : C} (h : W ⟶ X) [Epi h] :
    HasCoequalizer (h ≫ f) (h ≫ g)
-- Mathlib/Algebra/Tropical/Basic.lean
@[simp]
theorem add_eq_left ⦃x y : Tropical R⦄ (h : x ≤ y) : x + y = x
-- Mathlib/Combinatorics/Additive/FreimanHom.lean
@[to_additive] lemma IsMulFreimanHom.superset (hB : B₁ ⊆ B₂) (hf : IsMulFreimanHom n A B₁ f) :
    IsMulFreimanHom n A B₂ f
-- Mathlib/Order/Defs.lean
theorem le_or_gt : ∀ a b : α, a ≤ b ∨ a > b
-- Mathlib/Algebra/Homology/ShortComplex/QuasiIso.lean
lemma quasiIso_opMap (φ : S₁ ⟶ S₂) [QuasiIso φ] :
    QuasiIso (opMap φ)
-- Mathlib/Topology/Constructions.lean
theorem nhds_toAdd (x : Multiplicative X) : 𝓝 (toAdd x) = map toAdd (𝓝 x)
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem IsCoprime.of_mul_right_left (H : IsCoprime x (y * z)) : IsCoprime x y
-- Mathlib/Topology/Sets/Closeds.lean
@[simp, norm_cast]
theorem coe_top : (↑(⊤ : Closeds α) : Set α) = univ
-- Mathlib/MeasureTheory/Function/L1Space.lean
@[simp]
theorem integrable_zero : Integrable (fun _ => (0 : β)) μ
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
@[simp]
theorem coe_det_isEmpty [IsEmpty n] : (det : Matrix n n R → R) = Function.const _ 1
-- Mathlib/Data/Nat/Defs.lean
lemma sqrt_le_self (n : ℕ) : sqrt n ≤ n
-- Mathlib/Order/Disjoint.lean
theorem Codisjoint.sup_right' (h : Codisjoint a b) : Codisjoint a (c ⊔ b)
-- Mathlib/Data/Complex/Module.lean
@[simp]
lemma realPart_ofReal (r : ℝ) : (ℜ (r : ℂ) : ℂ) = r
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Mod.lean
theorem mod_mul_right_div_self (m n k : Nat) : m % (n * k) / n = m / n % k
-- Mathlib/Order/RelClasses.lean
theorem antisymm_iff [IsRefl α r] [IsAntisymm α r] {a b : α} : r a b ∧ r b a ↔ a = b
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
theorem ite_cond_eq_false {α : Sort u} {c : Prop} {_ : Decidable c} (a b : α) (h : c = False) : (if c then a else b) = b
-- Mathlib/Order/Interval/Set/Image.lean
@[simp]
lemma image_subtype_val_Ici_Ici {a : α} (b : Ici a) : Subtype.val '' Ici b = Ici b.1
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_nonneg_of_ae {f : α → ℝ} (hf : 0 ≤ᵐ[μ] f) : 0 ≤ ∫ a, f a ∂μ
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive]
lemma le_stabilizer_smul_right [SMul α β] [SMulCommClass G α β] (a : α) (b : β) :
    stabilizer G b ≤ stabilizer G (a • b)
-- Mathlib/Topology/Inseparable.lean
theorem Specializes.not_disjoint (h : x ⤳ y) : ¬Disjoint (𝓝 x) (𝓝 y)
-- Mathlib/GroupTheory/DoubleCoset.lean
theorem eq_of_not_disjoint {H K : Subgroup G} {a b : G}
    (h : ¬Disjoint (doset a H K) (doset b H K)) : doset a H K = doset b H K
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
@[simp]
lemma linearDeriv_apply : f.linearDeriv x y = ∑ i, f (Function.update x i (y i))
-- Mathlib/Topology/Instances/ENNReal.lean
theorem iInf_mul_right {ι} [Nonempty ι] {f : ι → ℝ≥0∞} {a : ℝ≥0∞}
    (h : a = ∞ → ⨅ i, f i = 0 → ∃ i, f i = 0) : ⨅ i, f i * a = (⨅ i, f i) * a
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc (attr := simp)]
theorem tensor_inv_hom_id {V W X Y Z : C} (f : V ≅ W) (g : X ⟶ Y) (h : Y ⟶ Z) :
    (g ⊗ f.inv) ≫ (h ⊗ f.hom) = (g ⊗ 𝟙 W) ≫ (h ⊗ 𝟙 W)
-- Mathlib/MeasureTheory/PiSystem.lean
theorem generateHas_def {C : Set (Set α)} : (generate C).Has = GenerateHas C
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem comap_bot_le_of_injective (hf : Function.Injective f) : comap f ⊥ ≤ I
-- Mathlib/Data/Nat/Totient.lean
theorem Ico_filter_coprime_le {a : ℕ} (k n : ℕ) (a_pos : 0 < a) :
    ((Ico k (k + n)).filter (Coprime a)).card ≤ totient a * (n / a + 1)
-- Mathlib/AlgebraicTopology/FundamentalGroupoid/Product.lean
/--
The map taking the product of two fundamental groupoids to the fundamental groupoid of the product
of the two topological spaces. This is in fact an isomorphism (see `prodIso`).
-/
@[simps obj]
def prodToProdTop : πₓ A × πₓ B ⥤ πₓ (TopCat.of (A × B))
-- Mathlib/Data/Vector/Basic.lean
theorem insertNth_comm (a b : α) (i j : Fin (n + 1)) (h : i ≤ j) :
    ∀ v : Vector α n,
      (v.insertNth a i).insertNth b j.succ = (v.insertNth b j).insertNth a (Fin.castSucc i)
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
@[simp, norm_cast]
theorem intCast_dvd_intCast (a b : ℤ) : (a : ℤ√d) ∣ b ↔ a ∣ b
-- Mathlib/Analysis/InnerProductSpace/OfNorm.lean
theorem inner_.conj_symm (x y : E) : conj (inner_ 𝕜 y x) = inner_ 𝕜 x y
-- Mathlib/Data/List/Chain.lean
/--
If there is an `r`-chain starting from `a` and ending at `b`, then `a` and `b` are related by the
reflexive transitive closure of `r`. The converse of `exists_chain_of_relationReflTransGen`.
-/
theorem relationReflTransGen_of_exists_chain (l : List α) (hl₁ : Chain r a l)
    (hl₂ : getLast (a :: l) (cons_ne_nil _ _) = b) : Relation.ReflTransGen r a b
-- Mathlib/CategoryTheory/Skeletal.lean
/-- If `C` is thin and skeletal, then any naturally isomorphic functors to `C` are equal. -/
theorem Functor.eq_of_iso {F₁ F₂ : D ⥤ C} [Quiver.IsThin C] (hC : Skeletal C) (hF : F₁ ≅ F₂) :
    F₁ = F₂
-- Mathlib/Algebra/Order/Interval/Set/Instances.lean
@[simp, norm_cast]
theorem coe_mul (x y : Icc (0 : α) 1) : ↑(x * y) = (x * y : α)
-- Mathlib/Data/Set/Basic.lean
@[gcongr]
theorem union_subset_union_right (s) {t₁ t₂ : Set α} (h : t₁ ⊆ t₂) : s ∪ t₁ ⊆ s ∪ t₂
-- Mathlib/Data/PNat/Basic.lean
theorem lt_succ_self (a : ℕ+) : a < succPNat a
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
@[simp, mfld_simps]
theorem mfderiv_id : mfderiv I I (@id M) x = ContinuousLinearMap.id 𝕜 (TangentSpace I x)
-- Mathlib/GroupTheory/Coset.lean
@[to_additive (attr := elab_as_elim)]
theorem induction_on {C : α ⧸ s → Prop} (x : α ⧸ s) (H : ∀ z, C (QuotientGroup.mk z)) : C x
-- .lake/packages/batteries/Batteries/Data/RBMap/Alter.lean
theorem find?_eq_zoom : ∀ {t : RBNode α} (p := .root), t.find? cut = (t.zoom cut p).1.root?
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem mem_bind {f : α → List β} {b} {l : List α} : b ∈ l.bind f ↔ ∃ a, a ∈ l ∧ b ∈ f a
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem self_trans_symm : e.trans e.symm = refl 𝕜 P
-- Mathlib/LinearAlgebra/Lagrange.lean
theorem eq_interpolate {f : F[X]} (hvs : Set.InjOn v s) (degree_f_lt : f.degree < s.card) :
    f = interpolate s v fun i => f.eval (v i)
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma smul_neg_of_neg_of_pos [SMulPosStrictMono α β] (ha : a < 0) (hb : 0 < b) : a • b < 0
-- Mathlib/Algebra/Lie/Subalgebra.lean
@[simp]
theorem coe_bracket_of_module (x : L') (m : M) : ⁅x, m⁆ = ⁅(x : L), m⁆
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
@[to_additive]
theorem pairwise_aedisjoint_of_ac {ν} (h : IsFundamentalDomain G s μ) (hν : ν ≪ μ) :
    Pairwise fun g₁ g₂ : G => AEDisjoint ν (g₁ • s) (g₂ • s)
-- Mathlib/Data/Nat/PrimeFin.lean
lemma primeFactors_mono (hmn : m ∣ n) (hn : n ≠ 0) : primeFactors m ⊆ primeFactors n
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigO_of_le (hfg : ∀ x, ‖f x‖ ≤ ‖g x‖) : f =O[l] g
-- Mathlib/Analysis/Convex/Basic.lean
theorem convex_sInter {S : Set (Set E)} (h : ∀ s ∈ S, Convex 𝕜 s) : Convex 𝕜 (⋂₀ S)
-- Mathlib/FieldTheory/Finite/Basic.lean
theorem even_card_of_char_two (hF : ringChar F = 2) : Fintype.card F % 2 = 0
-- Mathlib/Topology/Algebra/MulAction.lean
@[to_additive]
theorem Filter.Tendsto.smul_const {f : α → M} {l : Filter α} {c : M} (hf : Tendsto f l (𝓝 c))
    (a : X) : Tendsto (fun x => f x • a) l (𝓝 (c • a))
-- Mathlib/Algebra/MvPolynomial/Monad.lean
@[simp]
theorem bind₂_comp_C (f : R →+* MvPolynomial σ S) : (bind₂ f).comp C = f
-- Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
theorem objSupIsoProdEqLocus_hom_snd {X : TopCat} (F : X.Sheaf CommRingCat) (U V : Opens X) (x) :
    ((F.objSupIsoProdEqLocus U V).hom x).1.snd = F.1.map (homOfLE le_sup_right).op x
-- Mathlib/FieldTheory/IsPerfectClosure.lean
@[simp]
theorem liftEquiv_trans :
    (liftEquiv M i p).trans (liftEquiv M g p) = liftEquiv M (g.comp i) p
-- Mathlib/GroupTheory/Submonoid/Inverses.lean
@[to_additive]
theorem leftInvEquiv_mul (x : S.leftInv) : (S.leftInvEquiv hS x : M) * x = 1
-- Mathlib/Topology/Algebra/InfiniteSum/Order.lean
@[to_additive]
theorem hasProd_le (h : ∀ i, f i ≤ g i) (hf : HasProd f a₁) (hg : HasProd g a₂) : a₁ ≤ a₂
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem contMDiff_diffeomorph_comp_iff {m} (h : M ≃ₘ^n⟮I, J⟯ N) {f : M' → M} (hm : m ≤ n) :
    ContMDiff I' J m (h ∘ f) ↔ ContMDiff I' I m f
-- Mathlib/CategoryTheory/Sites/Sheaf.lean
theorem isSheaf_iff_multifork :
    IsSheaf J P ↔ ∀ (X : C) (S : J.Cover X), Nonempty (IsLimit (S.multifork P))
-- Mathlib/Algebra/Module/Equiv/Basic.lean
@[simp]
theorem conj_id (e : M ≃ₗ[R] M₂) : e.conj LinearMap.id = LinearMap.id
-- Mathlib/Order/Filter/AtTopBot.lean
lemma atTop_eq_generate_of_not_bddAbove [LinearOrder α] {s : Set α} (hs : ¬ BddAbove s) :
    (atTop : Filter α) = generate (Ici '' s)
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem mul_inv_cancel_iff_isUnit {I : FractionalIdeal R₁⁰ K} : I * I⁻¹ = 1 ↔ IsUnit I
-- Mathlib/CategoryTheory/Yoneda.lean
@[ext]
lemma coyonedaPairingExt {X : C × (C ⥤ Type v₁)} {x y : (coyonedaPairing C).obj X}
    (w : ∀ Y, x.app Y = y.app Y) : x = y
-- Mathlib/Analysis/Convex/Exposed.lean
protected theorem isClosed [OrderClosedTopology 𝕜] {A B : Set E} (hAB : IsExposed 𝕜 A B)
    (hA : IsClosed A) : IsClosed B
-- Mathlib/CategoryTheory/Abelian/Exact.lean
theorem exact_iff_exact_coimage_π :
    S.Exact ↔ (ShortComplex.mk S.f (Abelian.coimage.π S.g)
      (Abelian.comp_coimage_π_eq_zero S.zero)).Exact
-- Mathlib/Algebra/Group/Opposite.lean
@[to_additive (attr := simp, nolint simpComm)]
theorem semiconjBy_unop [Mul α] {a x y : αᵐᵒᵖ} :
    SemiconjBy (unop a) (unop y) (unop x) ↔ SemiconjBy a x y
-- Mathlib/AlgebraicTopology/DoldKan/EquivalencePseudoabelian.lean
theorem hε :
    Compatibility.υ (isoN₁) =
      (Γ₂N₁ : (toKaroubiEquivalence _).functor ≅
          (N₁ : SimplicialObject C ⥤ _) ⋙ Preadditive.DoldKan.equivalence.inverse)
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioo_inter_Iio : Ioo a b ∩ Iio c = Ioo a (min b c)
-- Mathlib/Algebra/GroupWithZero/Defs.lean
@[simp] lemma mul_div_cancel_left₀ (b : M₀) (ha : a ≠ 0) : a * b / a = b
-- Mathlib/Data/DFinsupp/Order.lean
theorem orderEmbeddingToFun_apply {f : Π₀ i, α i} {i : ι} :
    (@orderEmbeddingToFun ι α _ _ f) i = f i
-- Mathlib/Algebra/Group/Action/Defs.lean
lemma smul_inv (g : G) (a : H) : (g • a)⁻¹ = g⁻¹ • a⁻¹
-- Mathlib/Tactic/Ring/Basic.lean
theorem mul_pf_right (b₁ : R) (b₂) (_ : a * b₃ = c) :
    a * (b₁ ^ b₂ * b₃) = b₁ ^ b₂ * c
-- Mathlib/RingTheory/Localization/Submodule.lean
theorem mem_span_map {x : S} {a : Set R} :
    x ∈ Ideal.span (algebraMap R S '' a) ↔ ∃ y ∈ Ideal.span a, ∃ z : M, x = mk' S y z
-- Mathlib/Logic/Relation.lean
theorem symmetric_join : Symmetric (Join r)
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
theorem biproduct.isoProduct_inv {f : J → C} [HasBiproduct f] :
    (biproduct.isoProduct f).inv = biproduct.lift (Pi.π f)
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
/-- Two subalgebras that are equal are also equivalent as algebras.

This is the `Subalgebra` version of `LinearEquiv.ofEq` and `Equiv.Set.ofEq`. -/
@[simps apply]
def equivOfEq (S T : Subalgebra R A) (h : S = T) : S ≃ₐ[R] T
-- Mathlib/Data/List/Infix.lean
theorem prefix_take_le_iff {L : List (List (Option α))} (hm : m < L.length) :
    L.take m <+: L.take n ↔ m ≤ n
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive (attr := simp)]
lemma stabilizer_smul_eq_left [SMul α β] [IsScalarTower G α β] (a : α) (b : β)
    (h : Injective (· • b : α → β)) : stabilizer G (a • b) = stabilizer G a
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem exists_lt_of_lt_csSup' {s : Set α} {a : α} (h : a < sSup s) : ∃ b ∈ s, a < b
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem pred_lt : ∀ {n : Nat}, n ≠ 0 → pred n < n
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
@[simp]
theorem vadd_re : (x +ᵥ z).re = x + z.re
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem mul_add_left_right_iff {x y z : R} : IsRelPrime x (x * z + y) ↔ IsRelPrime x y
-- Mathlib/RingTheory/Flat/Basic.lean
/--
Define the character module of `M` to be `M →+ ℚ ⧸ ℤ`.
The character module of `M` is an injective module if and only if
 `L ⊗ 𝟙 M` is injective for any linear map `L` in the same universe as `M`.
-/
lemma injective_characterModule_iff_rTensor_preserves_injective_linearMap :
    Module.Injective R (CharacterModule M) ↔
    ∀ ⦃N N' : Type v⦄ [AddCommGroup N] [AddCommGroup N'] [Module R N] [Module R N']
      (L : N →ₗ[R] N'), Function.Injective L → Function.Injective (L.rTensor M)
-- Mathlib/Data/Finset/Sups.lean
theorem sups_subset_left : t₁ ⊆ t₂ → s ⊻ t₁ ⊆ s ⊻ t₂
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem negPart_toSimpleFunc (f : α →₁ₛ[μ] ℝ) :
    toSimpleFunc (negPart f) =ᵐ[μ] (toSimpleFunc f).negPart
-- Mathlib/Analysis/Calculus/Deriv/ZPow.lean
theorem iter_deriv_inv (k : ℕ) (x : 𝕜) :
    deriv^[k] Inv.inv x = (∏ i ∈ Finset.range k, (-1 - i : 𝕜)) * x ^ (-1 - k : ℤ)
-- Mathlib/MeasureTheory/Function/LpOrder.lean
theorem _root_.MeasureTheory.Memℒp.abs {f : α → E} (hf : Memℒp f p μ) : Memℒp |f| p μ
-- Mathlib/NumberTheory/Harmonic/Defs.lean
@[simp]
lemma harmonic_zero : harmonic 0 = 0
-- Mathlib/Combinatorics/SetFamily/Shatter.lean
@[simp] lemma mem_shatterer : s ∈ 𝒜.shatterer ↔ 𝒜.Shatters s
-- Mathlib/Algebra/Group/Submonoid/Basic.lean
@[to_additive]
theorem eq_of_eqOn_denseM {s : Set M} (hs : closure s = ⊤) {f g : M →* N} (h : s.EqOn f g) :
    f = g
-- Mathlib/Analysis/Complex/ReImTopology.lean
@[simp]
theorem closure_setOf_lt_im (a : ℝ) : closure { z : ℂ | a < z.im } = { z | a ≤ z.im }
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
/-- The homotopy between morphisms in `ShortComplex C` that is induced by a homotopy
between morphisms in `ShortComplex Cᵒᵖ`. -/
@[simps]
def unop {S₁ S₂ : ShortComplex Cᵒᵖ} {φ₁ φ₂ : S₁ ⟶ S₂}  (h : Homotopy φ₁ φ₂) :
    Homotopy (unopMap φ₁) (unopMap φ₂)
-- Mathlib/Topology/PartitionOfUnity.lean
theorem exists_finset_nhd_support_subset {U : ι → Set X} (hso : f.IsSubordinate U)
    (ho : ∀ i, IsOpen (U i)) (x : X) :
    ∃ is : Finset ι, ∃ n ∈ 𝓝 x, n ⊆ ⋂ i ∈ is, U i ∧ ∀ z ∈ n, (support (f · z)) ⊆ is
-- Mathlib/Algebra/Order/Monovary.lean
@[to_additive (attr := simp)]
lemma antivaryOn_inv_left : AntivaryOn f⁻¹ g s ↔ MonovaryOn f g s
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
@[to_additive]
theorem mem_sSup_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
    (hS : DirectedOn (· ≤ ·) S) {x : M} : x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s
-- Mathlib/CategoryTheory/Limits/Shapes/Reflexive.lean
/-- If `f,g` is a kernel pair for some morphism `q`, then it is reflexive. -/
theorem IsKernelPair.isReflexivePair {R : C} {f g : R ⟶ A} {q : A ⟶ B} (h : IsKernelPair q f g) :
    IsReflexivePair f g
-- Mathlib/Order/SupIndep.lean
theorem SupIndep.subset (ht : t.SupIndep f) (h : s ⊆ t) : s.SupIndep f
-- Mathlib/GroupTheory/Perm/Option.lean
theorem Equiv.Perm.decomposeOption_symm_sign {α : Type*} [DecidableEq α] [Fintype α] (e : Perm α) :
    Perm.sign (Equiv.Perm.decomposeOption.symm (none, e)) = Perm.sign e
-- Mathlib/Topology/UniformSpace/Basic.lean
/-- See also `comp_open_symm_mem_uniformity_sets`. -/
theorem comp_symm_mem_uniformity_sets {s : Set (α × α)} (hs : s ∈ 𝓤 α) :
    ∃ t ∈ 𝓤 α, SymmetricRel t ∧ t ○ t ⊆ s
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
@[simp]
theorem Matrix.toLinearMap₂_toMatrix₂ (B : M₁ →ₗ[R] M₂ →ₗ[R] N₂) :
    Matrix.toLinearMap₂ b₁ b₂ (LinearMap.toMatrix₂ b₁ b₂ B) = B
-- Mathlib/SetTheory/Surreal/Multiplication.lean
lemma numeric_mul_option (ih : ∀ a, ArgsRel a (Args.P1 x y) → P124 a) (h : IsOption y' y) :
    (x * y').Numeric
-- Mathlib/Algebra/Category/ModuleCat/Basic.lean
@[simp]
theorem coe_comp (f : M ⟶ N) (g : N ⟶ U) : (f ≫ g : M → U) = g ∘ f
-- Mathlib/Algebra/Order/Group/Defs.lean
@[to_additive (attr := simp)]
theorem le_inv_self_iff : a ≤ a⁻¹ ↔ a ≤ 1
-- Mathlib/RepresentationTheory/Action/Concrete.lean
/-- The `G`-set `Gⁿ`, acting on itself by left multiplication. -/
@[simps!]
def diagonal (G : Type u) [Monoid G] (n : ℕ) : Action (Type u) (MonCat.of G)
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
theorem toContinuousMultilinearMap_injective :
    Injective (ContinuousAlternatingMap.toContinuousMultilinearMap :
      M [⋀^ι]→L[R] N → ContinuousMultilinearMap R (fun _ : ι => M) N)
-- Mathlib/Data/List/MinMax.lean
theorem le_maximum_of_mem' (ha : a ∈ l) : (a : WithBot α) ≤ maximum l
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
/-- If ∠BCD = π, then ∠ABC = ∠ABD. -/
theorem angle_eq_angle_of_angle_eq_pi (p1 : P) {p2 p3 p4 : P} (h : ∠ p2 p3 p4 = π) :
    ∠ p1 p2 p3 = ∠ p1 p2 p4
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem set_cons_succ (x : α) (xs : List α) (n : Nat) (a : α) :
  (x :: xs).set (n + 1) a = x :: xs.set n a
-- Mathlib/Analysis/Normed/Group/Seminorm.lean
@[to_additive]
theorem comp_mono (hp : p ≤ q) : p.comp f ≤ q.comp f
-- Mathlib/Logic/Equiv/Pairwise.lean
lemma EquivLike.pairwise_comp_iff {X : Type*} {Y : Type*} {F} [EquivLike F Y X]
    (f : F) (p : X → X → Prop) : Pairwise (p on f) ↔ Pairwise p
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem CC_comp_zero : ∀ y, (Linear_CC' C hsC ho) ((πs C o) y) = 0
-- Mathlib/LinearAlgebra/Span.lean
theorem map_span [RingHomSurjective σ₁₂] (f : F) (s : Set M) :
    (span R s).map f = span R₂ (f '' s)