ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
/-- A subalgebra is a sub(semi)ring that includes the range of `algebraMap`. -/
structure Subalgebra (R : Type u) (A : Type v) [CommSemiring R] [Semiring A] [Algebra R A] extends
  Subsemiring A : Type v where
  /-- The image of `algebraMap` is contained in the underlying set of the subalgebra -/
  algebraMap_mem' : ∀ r, algebraMap R A r ∈ carrier
  zero_mem' := (algebraMap R A).map_zero ▸ algebraMap_mem' 0
  one_mem' := (algebraMap R A).map_one ▸ algebraMap_mem' 1
-- Mathlib/Data/ENNReal/Real.lean
theorem toReal_ofReal_mul (c : ℝ) (a : ℝ≥0∞) (h : 0 ≤ c) :
    ENNReal.toReal (ENNReal.ofReal c * a) = c * ENNReal.toReal a
-- Mathlib/MeasureTheory/Function/LpSeminorm/CompareExp.lean
theorem Memℒp.smul_of_top_right {p : ℝ≥0∞} {f : α → E} {φ : α → 𝕜} (hf : Memℒp f p μ)
    (hφ : Memℒp φ ∞ μ) : Memℒp (φ • f) p μ
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
theorem ne_cast_int (h : LiouvilleWith p x) (hp : 1 < p) (m : ℤ) : x ≠ m
-- Mathlib/Data/Real/Pi/Bounds.lean
theorem pi_gt_31415 : 3.1415 < π
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[nontriviality]
lemma coeffs_eq_empty_of_subsingleton [Subsingleton R] (p : MvPolynomial σ R) : p.coeffs = ∅
-- Mathlib/Algebra/Group/Submonoid/Units.lean
@[to_additive]
lemma mk_inv_mul_mk_eq_one (S : Submonoid M) {x : Mˣ} (h : x ∈ S.units) :
    (⟨_, h.2⟩ : S) * ⟨_, h.1⟩ = 1
-- Mathlib/Topology/ContinuousFunction/CompactlySupported.lean
@[simp]
theorem coe_zero [Zero β] : ⇑(0 : C_c(α, β)) = 0
-- Mathlib/Data/Int/Defs.lean
lemma sub_one_lt_iff : m - 1 < n ↔ m ≤ n
-- Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean
/-- See Note [no_index around OfNat.ofNat] -/
lemma cpow_ofNat_mul (x : ℂ) (n : ℕ) [n.AtLeastTwo] (y : ℂ) :
    x ^ (no_index (OfNat.ofNat n) * y) = (x ^ y) ^ (OfNat.ofNat n : ℕ)
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem HasStrictFDerivAt.mul_const (hc : HasStrictFDerivAt c c' x) (d : 𝔸') :
    HasStrictFDerivAt (fun y => c y * d) (d • c') x
-- Mathlib/RingTheory/Ideal/Maps.lean
@[simp]
theorem ker_equiv {F' : Type*} [EquivLike F' R S] [RingEquivClass F' R S] (f : F') : ker f = ⊥
-- Mathlib/Data/Sym/Card.lean
theorem card_subtype_not_diag [Fintype α] :
    card { a : Sym2 α // ¬a.IsDiag } = (card α).choose 2
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem map_span (f : F) (s : Set R) : map f (span s) = span (f '' s)
-- Mathlib/GroupTheory/GroupAction/Hom.lean
@[ext]
theorem ext {f g : A →ₑ+[φ] B} : (∀ x, f x = g x) → f = g
-- Mathlib/Analysis/Calculus/FDeriv/Linear.lean
@[fun_prop]
protected theorem ContinuousLinearMap.hasFDerivAt : HasFDerivAt e e x
-- Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean
theorem integral_mul_cexp_neg_mul_sq {b : ℂ} (hb : 0 < b.re) :
    ∫ r : ℝ in Ioi 0, (r : ℂ) * cexp (-b * (r : ℂ) ^ 2) = (2 * b)⁻¹
-- Mathlib/Data/Int/Cast/Lemmas.lean
theorem Sum.elim_intCast_intCast {α β γ : Type*} [IntCast γ] (n : ℤ) :
    Sum.elim (n : α → γ) (n : β → γ) = n
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem dedup_eq_self [DecidableEq α] (s : Finset α) : dedup s.1 = s.1
-- Mathlib/Order/Minimal.lean
theorem IsGreatest.mem_maximals [Preorder α] (h : IsGreatest s a) : a ∈ maximals (· ≤ ·) s
-- Mathlib/Order/Interval/Set/Image.lean
lemma StrictAntiOn.mapsTo_Ico (h : StrictAntiOn f (Icc a b)) :
    MapsTo f (Ico a b) (Ioc (f b) (f a))
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem symm_constVSub (p : P) :
    (constVSub 𝕜 p).symm =
      (LinearIsometryEquiv.neg 𝕜).toAffineIsometryEquiv.trans (vaddConst 𝕜 p)
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
theorem toCone_pt (c : BinaryBicone P Q) : c.toCone.pt = c.pt
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
/-- When the second map `S.g` is zero, this is the left homology data on `S` given
by any colimit cokernel cofork of `S.f` -/
@[simps]
def ofIsColimitCokernelCofork (hg : S.g = 0) (c : CokernelCofork S.f) (hc : IsColimit c) :
    S.LeftHomologyData
-- Mathlib/CategoryTheory/ComposableArrows.lean
@[simp]
lemma homMk₅_app_three :
    (homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app ⟨3, by valid⟩ = app₃
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
/-- An extensionality for measures. It is `ext_of_generateFrom_of_iUnion` formulated in terms of
`FiniteSpanningSetsIn`. -/
protected theorem ext {ν : Measure α} {C : Set (Set α)} (hA : ‹_› = generateFrom C)
    (hC : IsPiSystem C) (h : μ.FiniteSpanningSetsIn C) (h_eq : ∀ s ∈ C, μ s = ν s) : μ = ν
-- Mathlib/Analysis/Convex/Star.lean
theorem StarConvex.add_left (hs : StarConvex 𝕜 x s) (z : E) :
    StarConvex 𝕜 (z + x) ((fun x => z + x) '' s)
-- Mathlib/Topology/LocallyClosed.lean
lemma closure_inter_coborder :
    closure s ∩ coborder s = s
-- Mathlib/CategoryTheory/Comma/Over.lean
@[simp]
theorem map_obj_left : ((map f).obj U).left = U.left
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- If the oriented angle between two vectors is `π / 2`, the inner product of those vectors
is zero. -/
theorem inner_eq_zero_of_oangle_eq_pi_div_two {x y : V} (h : o.oangle x y = (π / 2 : ℝ)) :
    ⟪x, y⟫ = 0
-- Mathlib/Algebra/Field/Defs.lean
lemma cast_def (q : ℚ) : (q : K) = q.num / q.den
-- Mathlib/Data/Set/Sups.lean
theorem sups_comm : s ⊻ t = t ⊻ s
-- Mathlib/Data/Fin/Basic.lean
/-- `a ≤ b` as natural numbers if and only if `a ≤ b` in `Fin n`. -/
@[norm_cast, simp]
theorem val_fin_le {n : ℕ} {a b : Fin n} : (a : ℕ) ≤ (b : ℕ) ↔ a ≤ b
-- Mathlib/Algebra/MvPolynomial/Basic.lean
/-- `MvPolynomial.coeff m` but promoted to a `LinearMap`. -/
@[simps]
def lcoeff (m : σ →₀ ℕ) : MvPolynomial σ R →ₗ[R] R
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_sub_le (f g : α → ℝ≥0∞) (hf : Measurable f) :
    ∫⁻ x, g x ∂μ - ∫⁻ x, f x ∂μ ≤ ∫⁻ x, g x - f x ∂μ
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem ContMDiff.prod_mk_space {f : M → E'} {g : M → F'} (hf : ContMDiff I 𝓘(𝕜, E') n f)
    (hg : ContMDiff I 𝓘(𝕜, F') n g) : ContMDiff I 𝓘(𝕜, E' × F') n fun x => (f x, g x)
-- Mathlib/CategoryTheory/Sites/DenseSubsite.lean
@[simp]
theorem appHom_restrict {X : D} {Y : C} (f : op X ⟶ op (G.obj Y)) (x) :
    ℱ'.val.map f (appHom α X x) = α.app (op Y) (ℱ.map f x)
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
@[simp]
theorem mem_ofWithBot {boxes : Finset (WithBot (Box ι))} {h₁ h₂} :
    J ∈ (ofWithBot boxes h₁ h₂ : Prepartition I) ↔ (J : WithBot (Box ι)) ∈ boxes
-- Mathlib/Order/CompleteLatticeIntervals.lean
@[simp]
theorem subset_sInf_def [Inhabited s] :
    @sInf s _ = fun t =>
      if ht : t.Nonempty ∧ BddBelow t ∧ sInf ((↑) '' t : Set α) ∈ s
      then ⟨sInf ((↑) '' t : Set α), ht.2.2⟩ else
      default
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem comapDomain'_smul [Monoid γ] [∀ i, AddMonoid (β i)] [∀ i, DistribMulAction γ (β i)]
    (h : κ → ι) {h' : ι → κ} (hh' : Function.LeftInverse h' h) (r : γ) (f : Π₀ i, β i) :
    comapDomain' h hh' (r • f) = r • comapDomain' h hh' f
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[deprecated shiftLeft_add (since := "2024-06-02")]
theorem shiftLeft_shiftLeft (m n : Nat) : ∀ k, (m <<< n) <<< k = m <<< (n + k)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigO.eq_zero_imp (h : f'' =O[l] g'') : ∀ᶠ x in l, g'' x = 0 → f'' x = 0
-- Mathlib/Topology/UniformSpace/Completion.lean
theorem basis_uniformity {ι : Sort*} {p : ι → Prop} {s : ι → Set (α × α)} (h : (𝓤 α).HasBasis p s) :
    (𝓤 (CauchyFilter α)).HasBasis p (gen ∘ s)
-- Mathlib/Data/Finset/Sups.lean
theorem disjSups_subset_right (hs : s₁ ⊆ s₂) : s₁ ○ t ⊆ s₂ ○ t
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
@[simp]
theorem equivariantOfLinearOfComm_apply (v : V) : (equivariantOfLinearOfComm f h) v = f v
-- Mathlib/MeasureTheory/Group/Prod.lean
/-- The map `(x, y) ↦ (x / y, y)` preserves the measure `μ × ν`. -/
@[to_additive measurePreserving_sub_prod
" The map `(x, y) ↦ (x - y, y)` preserves the measure `μ × ν`. "]
theorem measurePreserving_div_prod [IsMulRightInvariant μ] :
    MeasurePreserving (fun z : G × G => (z.1 / z.2, z.2)) (μ.prod ν) (μ.prod ν)
-- Mathlib/GroupTheory/Congruence/Basic.lean
/-- The infimum of two congruence relations equals the infimum of the underlying binary
    operations. -/
@[to_additive (attr := simp, norm_cast)
  "The infimum of two additive congruence relations equals the infimum of the underlying binary
  operations."]
theorem coe_inf {c d : Con M} : ⇑(c ⊓ d) = ⇑c ⊓ ⇑d
-- Mathlib/Analysis/Complex/Basic.lean
theorem isometry_conj : Isometry (conj : ℂ → ℂ)
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
theorem generateFrom_le_iff {s : Set (Set α)} (m : MeasurableSpace α) :
    generateFrom s ≤ m ↔ s ⊆ { t | MeasurableSet[m] t }
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions/Fractions.lean
lemma snd (h : LeftFraction₂Rel z₁ z₂) : LeftFractionRel z₁.snd z₂.snd
-- Mathlib/MeasureTheory/Function/AEEqOfIntegral.lean
theorem ae_const_le_iff_forall_lt_measure_zero {β} [LinearOrder β] [TopologicalSpace β]
    [OrderTopology β] [FirstCountableTopology β] (f : α → β) (c : β) :
    (∀ᵐ x ∂μ, c ≤ f x) ↔ ∀ b < c, μ {x | f x ≤ b} = 0
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
@[simp] theorem map_eq (e : α ≃ᵐ β) : MeasurableSpace.map e ‹_› = ‹_›
-- Mathlib/Data/Set/Lattice.lean
theorem union_distrib_iInter₂_right (s : ∀ i, κ i → Set α) (t : Set α) :
    (⋂ (i) (j), s i j) ∪ t = ⋂ (i) (j), s i j ∪ t
-- Mathlib/Order/Hom/Order.lean
theorem iSup_apply {ι : Sort*} [CompleteLattice β] (f : ι → α →o β) (x : α) :
    (⨆ i, f i) x = ⨆ i, f i x
-- Mathlib/RingTheory/FreeCommRing.lean
@[simp]
theorem lift_comp_of (f : FreeCommRing α →+* R) : lift (f ∘ of) = f
-- Mathlib/Data/Set/Countable.lean
theorem subset_range_enumerate {s : Set α} (h : s.Countable) (default : α) :
    s ⊆ range (enumerateCountable h default)
-- Mathlib/Order/Fin/Basic.lean
/-- `Fin.cast` as an `OrderIso`.

`castOrderIso eq i` embeds `i` into an equal `Fin` type. -/
@[simps]
def castOrderIso (eq : n = m) : Fin n ≃o Fin m
-- Mathlib/Data/Set/Function.lean
protected lemma InvOn.extendDomain (h : InvOn g₁ g₂ s t) :
    InvOn (g₁.extendDomain f) (g₂.extendDomain f) ((↑) ∘ f '' s) ((↑) ∘ f '' t)
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem cons_and_cons (x y : BitVec w) (a b : Bool) :
    (cons a x) &&& (cons b y) = cons (a && b) (x &&& y)
-- Mathlib/Topology/Algebra/Monoid.lean
theorem Filter.TendstoNhdsWithinIoi.const_mul [PosMulStrictMono 𝕜] [PosMulReflectLT 𝕜]
    (h : Tendsto f l (𝓝[>] c)) : Tendsto (fun a => b * f a) l (𝓝[>] (b * c))
-- Mathlib/GroupTheory/GroupAction/Period.lean
/-- For any non-zero `n` less than the period of `m` on `a`, `a` is moved by `m ^ n`. -/
@[to_additive "For any non-zero `n` less than the period of `m` on `a`, `a` is moved by `n • m`."]
theorem pow_smul_ne_of_lt_period {m : M} {a : α} {n : ℕ} (n_pos : 0 < n)
    (n_lt_period : n < period m a) : m ^ n • a ≠ a
-- Mathlib/Data/Set/NAry.lean
theorem Nonempty.of_image2_left (h : (Set.image2 f s t).Nonempty) : s.Nonempty
-- Mathlib/Data/List/Perm.lean
lemma subperm_cons_self : l <+~ a :: l
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_mul_const_Icc (a b : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Icc a b = Icc (a / c) (b / c)
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem msb_append {x : BitVec w} {y : BitVec v} :
    (x ++ y).msb = bif (w == 0) then (y.msb) else (x.msb)
-- Mathlib/Algebra/Lie/Abelian.lean
@[simp]
theorem coe_linearMap_maxTrivLinearMapEquivLieModuleHom (f : maxTrivSubmodule R L (M →ₗ[R] N)) :
    (maxTrivLinearMapEquivLieModuleHom f : M →ₗ[R] N) = (f : M →ₗ[R] N)
-- Mathlib/NumberTheory/MulChar/Basic.lean
lemma equivToUnitHom_mul_apply (χ₁ χ₂ : MulChar R R') (a : Rˣ) :
    equivToUnitHom (χ₁ * χ₂) a = equivToUnitHom χ₁ a * equivToUnitHom χ₂ a
-- Mathlib/Topology/ContinuousFunction/ContinuousMapZero.lean
@[ext]
lemma ext {f g : C(X, R)₀} (h : ∀ x, f x = g x) : f = g
-- Mathlib/Topology/MetricSpace/Closeds.lean
/-- The edistance to a closed set depends continuously on the point and the set -/
theorem continuous_infEdist_hausdorffEdist :
    Continuous fun p : α × Closeds α => infEdist p.1 p.2
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem sub_sub (a b c : Ordinal) : a - b - c = a - (b + c)
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem cof_eq_sInf_lsub (o : Ordinal.{u}) : cof o =
    sInf { a : Cardinal | ∃ (ι : Type u) (f : ι → Ordinal), lsub.{u, u} f = o ∧ #ι = a }
-- Mathlib/LinearAlgebra/FiniteDimensional/Defs.lean
/-- On a finite-dimensional space, an injective linear map is surjective. -/
theorem surjective_of_injective [FiniteDimensional K V] {f : V →ₗ[K] V} (hinj : Injective f) :
    Surjective f
-- Mathlib/RingTheory/Localization/Basic.lean
theorem mk_one_eq_algebraMap (x) : mk x 1 = algebraMap R (Localization M) x
-- Mathlib/LinearAlgebra/SymplecticGroup.lean
theorem mem_iff {A : Matrix (l ⊕ l) (l ⊕ l) R} :
    A ∈ symplecticGroup l R ↔ A * J l R * Aᵀ = J l R
-- Mathlib/GroupTheory/Index.lean
@[to_additive]
theorem relindex_dvd_index_of_normal [H.Normal] : H.relindex K ∣ H.index
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem IsCoprime.of_add_mul_right_left (h : IsCoprime (x + z * y) y) : IsCoprime x y
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem eval₂_list_prod (l : List R[X]) (x : S) : eval₂ f x l.prod = (l.map (eval₂ f x)).prod
-- Mathlib/LinearAlgebra/BilinearForm/Basic.lean
@[simp]
theorem sub_apply (x y : M₁) : (B₁ - D₁) x y = B₁ x y - D₁ x y
-- Mathlib/Data/Set/Basic.lean
theorem compl_singleton_eq (a : α) : ({a} : Set α)ᶜ = { x | x ≠ a }
-- Mathlib/Data/Matrix/Notation.lean
theorem natCast_fin_two (n : ℕ) : (n : Matrix (Fin 2) (Fin 2) α) = !![↑n, 0; 0, ↑n]
-- Mathlib/Data/Set/Basic.lean
theorem mem_iff_nonempty {α : Type*} [Subsingleton α] {s : Set α} {x : α} : x ∈ s ↔ s.Nonempty
-- Mathlib/Order/Ideal.lean
lemma mem_principal_self : x ∈ principal x
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙ_comp_neg (hf : ContinuousOn f ((- ·) '' (σₙ R a)) := by cfc_cont_tac)
    (h0 : f 0 = 0 := by cfc_zero_tac) (ha : p a := by cfc_tac) :
    cfcₙ (f <| - ·) a = cfcₙ f (-a)
-- Mathlib/LinearAlgebra/Projection.lean
@[simp]
theorem coe_isComplEquivProj_apply (q : { q // IsCompl p q }) :
    (p.isComplEquivProj q : E →ₗ[R] p) = linearProjOfIsCompl p q q.2
-- Mathlib/Data/Part.lean
@[simp]
theorem toOption_eq_some_iff {o : Part α} [Decidable o.Dom] {a : α} :
    toOption o = Option.some a ↔ a ∈ o
-- Mathlib/Topology/StoneCech.lean
/-- Every ultrafilter `u` on `Ultrafilter α` converges to a unique
  point of `Ultrafilter α`, namely `joinM u`. -/
theorem ultrafilter_converges_iff {u : Ultrafilter (Ultrafilter α)} {x : Ultrafilter α} :
    ↑u ≤ 𝓝 x ↔ x = joinM u
-- Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
theorem log_le_log_iff (h : 0 < x) (h₁ : 0 < y) : log x ≤ log y ↔ x ≤ y
-- Mathlib/Order/Interval/Set/ProjIcc.lean
theorem projIcc_surjOn : SurjOn (projIcc a b h) (Icc a b) univ
-- Mathlib/SetTheory/Ordinal/Exponential.lean
theorem log_def {b : Ordinal} (h : 1 < b) (x : Ordinal) :
    log b x = pred (sInf { o | x < b ^ o })
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem IsSwap.mul_mem_closure_three_cycles {σ τ : Perm α} (hσ : IsSwap σ) (hτ : IsSwap τ) :
    σ * τ ∈ closure { σ : Perm α | IsThreeCycle σ }
-- Mathlib/CategoryTheory/Sites/Pretopology.lean
theorem le_def {K₁ K₂ : Pretopology C} : K₁ ≤ K₂ ↔ (K₁ : ∀ X : C, Set (Presieve X)) ≤ K₂
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
@[simp]
theorem cliqueFree_two : G.CliqueFree 2 ↔ G = ⊥
-- .lake/packages/lean4/src/lean/Lean/Data/PersistentHashMap.lean
private theorem size_set {ks : Array α} {vs : Array β} (h : ks.size = vs.size) (i : Fin ks.size) (j : Fin vs.size) (k : α) (v : β)
                           : (ks.set i k).size = (vs.set j v).size
-- Mathlib/Analysis/SpecialFunctions/CompareExp.lean
/-- If `l : Filter ℂ` is an "exponential comparison filter", then $\log |z| =o(ℜ z)$ along `l`.
This is the main lemma in the proof of `Complex.IsExpCmpFilter.isLittleO_cpow_exp` below.
-/
theorem isLittleO_log_abs_re (hl : IsExpCmpFilter l) : (fun z => Real.log (abs z)) =o[l] re
-- Mathlib/RingTheory/RootsOfUnity/Minpoly.lean
/-- Let `P` be the minimal polynomial of a root of unity `μ` and `Q` be the minimal polynomial of
`μ ^ p`, where `p` is a natural number that does not divide `n`. Then `P` divides `expand ℤ p Q`. -/
theorem minpoly_dvd_expand {p : ℕ} (hdiv : ¬p ∣ n) :
    minpoly ℤ μ ∣ expand ℤ p (minpoly ℤ (μ ^ p))
-- Mathlib/Algebra/Homology/HomotopyCofiber.lean
lemma ext_to_X' (i : ι) (hi : ¬ c.Rel i (c.next i)) {A : C} {f g : A ⟶ X φ i}
    (h : f ≫ sndX φ i = g ≫ sndX φ i) : f = g
-- Mathlib/GroupTheory/SchurZassenhaus.lean
/-- Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` -/
private theorem step5 {P : Sylow (Nat.card N).minFac N} : P.1 ≠ ⊥
-- Mathlib/Topology/Order/LeftRightLim.lean
/-- An antitone function is continuous to the right at a point if and only if its right limit
coincides with the value of the function. -/
theorem continuousWithinAt_Ioi_iff_rightLim_eq :
    ContinuousWithinAt f (Ioi x) x ↔ rightLim f x = f x
-- Mathlib/Order/CompleteSublattice.lean
protected lemma isCompl_iff {a b : L} :
    IsCompl a b ↔ IsCompl (a : α) (b : α)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp]
theorem range_subset {m n : Nat} : range m ⊆ range n ↔ m ≤ n
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem nil_prefix (l : List α) : [] <+: l
-- Mathlib/Probability/Martingale/Centering.lean
theorem adapted_predictablePart' : Adapted ℱ fun n => predictablePart f ℱ μ n
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
@[simp]
theorem comap_top (f : F) : comap f (⊤ : NonUnitalSubsemiring S) = (⊤ : NonUnitalSubsemiring R)
-- Mathlib/Algebra/Star/Order.lean
@[simp]
lemma star_le_star_iff {x y : R} : star x ≤ star y ↔ x ≤ y
-- Mathlib/Algebra/Module/FinitePresentation.lean
/--
A module is finitely presented if it is finitely generated by some set `s`
and the kernel of the presentation `Rˢ → M` is also finitely generated.
-/
class Module.FinitePresentation : Prop where
  out : ∃ (s : Finset M), Submodule.span R (s : Set M) = ⊤ ∧
    (LinearMap.ker (Finsupp.total s M R Subtype.val)).FG
-- Mathlib/Algebra/Algebra/Spectrum.lean
theorem sub_singleton_eq (a : A) (r : R) : σ a - {r} = σ (a - ↑ₐ r)
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem le_csInf_iff' (hs : s.Nonempty) : b ≤ sInf s ↔ b ∈ lowerBounds s
-- Mathlib/CategoryTheory/Balanced.lean
theorem isIso_iff_mono_and_epi [Balanced C] {X Y : C} (f : X ⟶ Y) : IsIso f ↔ Mono f ∧ Epi f
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- Rotation by π / 2 is the "right-angle-rotation" map `J`. -/
theorem rotation_pi_div_two : o.rotation (π / 2 : ℝ) = J
-- Mathlib/MeasureTheory/Integral/TorusIntegral.lean
/-- Constant functions are torus integrable -/
theorem torusIntegrable_const (a : E) (c : ℂⁿ) (R : ℝⁿ) : TorusIntegrable (fun _ => a) c R
-- Mathlib/Topology/Instances/ENNReal.lean
protected theorem Tendsto.mul {f : Filter α} {ma : α → ℝ≥0∞} {mb : α → ℝ≥0∞} {a b : ℝ≥0∞}
    (hma : Tendsto ma f (𝓝 a)) (ha : a ≠ 0 ∨ b ≠ ∞) (hmb : Tendsto mb f (𝓝 b))
    (hb : b ≠ 0 ∨ a ≠ ∞) : Tendsto (fun a => ma a * mb a) f (𝓝 (a * b))
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem unitsModPrincipalUnitsEquivResidueFieldUnits_comp_quotientGroup_mk :
    A.unitsModPrincipalUnitsEquivResidueFieldUnits.toMonoidHom.comp (QuotientGroup.mk' _) =
      A.unitGroupToResidueFieldUnits
-- Mathlib/Algebra/Ring/CentroidHom.lean
theorem toFun_eq_coe {f : CentroidHom α} : f.toFun = f
-- Mathlib/Order/RelIso/Basic.lean
protected theorem isAntisymm : ∀ (_ : r ↪r s) [IsAntisymm β s], IsAntisymm α r
-- Mathlib/Order/WellFoundedSet.lean
@[simp]
theorem wellFoundedOn_image {s : Set β} : (f '' s).WellFoundedOn r ↔ s.WellFoundedOn (r on f)
-- Mathlib/Algebra/Exact.lean
lemma exact_of_comp_eq_zero_of_ker_le_range
    (h1 : g ∘ₗ f = 0) (h2 : ker g ≤ range f) : Exact f g
-- Mathlib/Data/Int/ModEq.lean
theorem mod_mul_left_mod (a b c : ℤ) : a % (b * c) % c = a % c
-- Mathlib/Data/Option/NAry.lean
theorem mem_map₂_iff {c : γ} : c ∈ map₂ f a b ↔ ∃ a' b', a' ∈ a ∧ b' ∈ b ∧ f a' b' = c
-- Mathlib/GroupTheory/Solvable.lean
theorem isSolvable_of_top_eq_bot (h : (⊤ : Subgroup G) = ⊥) : IsSolvable G
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
theorem dTwo_comp_dOne : dTwo A ∘ₗ dOne A = 0
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem neg_dotProduct : -v ⬝ᵥ w = -(v ⬝ᵥ w)
-- Mathlib/Computability/Reduce.lean
theorem reflexive_manyOneReducible {α} [Primcodable α] : Reflexive (@ManyOneReducible α α _ _)
-- Mathlib/Algebra/Star/StarRingHom.lean
@[simp]
theorem coe_one : ((1 : A →⋆ₙ+* A) : A → A) = id
-- Mathlib/Dynamics/PeriodicPts.lean
@[simp] theorem minimalPeriod_id : minimalPeriod id x = 1
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
theorem star_eq_adjoint (A : E →ₗ[𝕜] E) : star A = LinearMap.adjoint A
-- Mathlib/Topology/UniformSpace/Separation.lean
theorem eq_of_clusterPt_uniformity [T0Space α] {x y : α} (h : ClusterPt (x, y) (𝓤 α)) : x = y
-- Mathlib/Algebra/Field/Subfield.lean
@[simp, norm_cast] lemma coe_ratCast (s : S) (x : ℚ) : ((x : s) : K) = x
-- Mathlib/Data/Set/Basic.lean
theorem inclusion_right (h : s ⊆ t) (x : t) (m : (x : α) ∈ s) : inclusion h ⟨x, m⟩ = x
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem not_and_self_iff (a : Prop) : ¬a ∧ a ↔ False
-- Mathlib/GroupTheory/Coxeter/Length.lean
@[simp]
theorem length_simple (i : B) : ℓ (s i) = 1
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
theorem locallyIntegrable_finset_sum' {ι} (s : Finset ι) {f : ι → X → E}
    (hf : ∀ i ∈ s, LocallyIntegrable (f i) μ) : LocallyIntegrable (∑ i ∈ s, f i) μ
-- Mathlib/MeasureTheory/Measure/Count.lean
@[simp]
theorem count_apply_finset' {s : Finset α} (s_mble : MeasurableSet (s : Set α)) :
    count (↑s : Set α) = s.card
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
theorem deleteVerts_verts : (G'.deleteVerts s).verts = G'.verts \ s
-- Mathlib/LinearAlgebra/BilinearForm/Basic.lean
theorem sub_left (x y z : M₁) : B₁ (x - y) z = B₁ x z - B₁ y z
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
protected theorem nsmul_mem {x : R} (hx : x ∈ s) (n : ℕ) : n • x ∈ s
-- Mathlib/Topology/Algebra/Algebra.lean
/-- Any two continuous `R`-algebra morphisms from `R` are equal -/
@[ext]
theorem ext_ring [TopologicalSpace R] {f g : R →A[R] A} : f = g
-- Mathlib/ModelTheory/Quotients.lean
theorem relMap_quotient_mk' {n : ℕ} (r : L.Relations n) (x : Fin n → M) :
    (RelMap r fun i => (⟦x i⟧ : Quotient s)) ↔ @RelMap _ _ ps.toStructure _ r x
-- Mathlib/GroupTheory/Index.lean
@[to_additive relindex_mul_index]
theorem relindex_mul_index (h : H ≤ K) : H.relindex K * K.index = H.index
-- Mathlib/Analysis/Convex/Segment.lean
lemma segment_inter_eq_endpoint_of_linearIndependent_of_ne [OrderedCommRing 𝕜] [NoZeroDivisors 𝕜]
    [AddCommGroup E] [Module 𝕜 E]
    {x y : E} (h : LinearIndependent 𝕜 ![x, y]) {s t : 𝕜} (hs : s ≠ t) (c : E) :
    [c + x -[𝕜] c + t • y] ∩ [c + x -[𝕜] c + s • y] = {c + x}
-- Mathlib/Data/Set/Prod.lean
theorem piCongrLeft_symm_preimage_pi (f : ι' ≃ ι) (s : Set ι') (t : ∀ i, Set (α i)) :
    (f.piCongrLeft α).symm ⁻¹' s.pi (fun i' => t <| f i') = (f '' s).pi t
-- Mathlib/Analysis/Convex/Star.lean
/-- The translation of a star-convex set is also star-convex. -/
theorem StarConvex.preimage_add_left (hs : StarConvex 𝕜 (x + z) s) :
    StarConvex 𝕜 x ((fun x => x + z) ⁻¹' s)
-- Mathlib/Data/Finset/Fold.lean
@[simp]
theorem fold_empty : (∅ : Finset α).fold op b f = b
-- Mathlib/Data/Finset/Lattice.lean
theorem min_mem_image_coe {s : Finset α} (hs : s.Nonempty) :
    s.min ∈ (s.image (↑) : Finset (WithTop α))
-- Mathlib/Data/Rat/Defs.lean
@[simp] lemma inv_divInt' (a b : ℤ) : (a /. b)⁻¹ = b /. a
-- Mathlib/Order/WithBot.lean
@[simp, norm_cast]
theorem coe_le_coe : (a : WithBot α) ≤ b ↔ a ≤ b
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem compl_compl_compl (a : α) : aᶜᶜᶜ = aᶜ
-- Mathlib/MeasureTheory/Measure/Content.lean
theorem sup_disjoint (K₁ K₂ : Compacts G) (h : Disjoint (K₁ : Set G) K₂)
    (h₁ : IsClosed (K₁ : Set G)) (h₂ : IsClosed (K₂ : Set G)) :
    μ (K₁ ⊔ K₂) = μ K₁ + μ K₂
-- Mathlib/AlgebraicTopology/DoldKan/EquivalencePseudoabelian.lean
@[simp]
lemma N₂_map_isoΓ₀_hom_app_f (X : ChainComplex C ℕ) :
    (N₂.map (isoΓ₀.hom.app X)).f = PInfty