ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/BigOperators/Finsupp.lean
lemma indicator_eq_sum_attach_single [AddCommMonoid M] {s : Finset α} (f : ∀ a ∈ s, M) :
    indicator s f = ∑ x ∈ s.attach, single ↑x (f x x.2)
-- Mathlib/GroupTheory/Perm/Fin.lean
@[simp]
theorem Equiv.Perm.decomposeFin_symm_apply_succ {n : ℕ} (e : Perm (Fin n)) (p : Fin (n + 1))
    (x : Fin n) : Equiv.Perm.decomposeFin.symm (p, e) x.succ = swap 0 p (e x).succ
-- Mathlib/FieldTheory/Adjoin.lean
theorem isSplittingField_iff {p : F[X]} {K : IntermediateField F E} :
    p.IsSplittingField F K ↔ p.Splits (algebraMap F K) ∧ K = adjoin F (p.rootSet E)
-- Mathlib/Algebra/Algebra/Rat.lean
@[simp] theorem algebraMap_rat_rat : algebraMap ℚ ℚ = RingHom.id ℚ
-- Mathlib/LinearAlgebra/Projection.lean
@[simp]
theorem ofIsCompl_right_apply (h : IsCompl p q) {φ : p →ₗ[R] F} {ψ : q →ₗ[R] F} (v : q) :
    ofIsCompl h φ ψ (v : E) = ψ v
-- Mathlib/Data/Set/Equitable.lean
theorem equitableOn_iff :
    EquitableOn (s : Set α) f ↔
      ∀ a ∈ s, f a = (∑ i ∈ s, f i) / s.card ∨ f a = (∑ i ∈ s, f i) / s.card + 1
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma coyoneda_exact₂ {X : C} (f : X ⟶ T.obj₂) (hf : f ≫ T.mor₂ = 0) :
    ∃ (g : X ⟶ T.obj₁), f = g ≫ T.mor₁
-- Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean
/-- An upper estimate on the complex distance between two points in terms of the hyperbolic distance
and the imaginary part of one of the points. -/
theorem dist_coe_le (z w : ℍ) : dist (z : ℂ) w ≤ w.im * (Real.exp (dist z w) - 1)
-- Mathlib/Topology/Constructions.lean
theorem Continuous.comp₂ {g : X × Y → Z} (hg : Continuous g) {e : W → X} (he : Continuous e)
    {f : W → Y} (hf : Continuous f) : Continuous fun w => g (e w, f w)
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
@[simp]
theorem norm_neg (x : ℤ√d) : (-x).norm = x.norm
-- Mathlib/Topology/Inseparable.lean
theorem Specializes.map (h : x ⤳ y) (hf : Continuous f) : f x ⤳ f y
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem map_eq_bot_iff {f : G →* N} : H.map f = ⊥ ↔ H ≤ f.ker
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem comp_id (f : sInfHom α β) : f.comp (sInfHom.id α) = f
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem get_extract_loop_lt_aux (as bs : Array α) (size start : Nat) (hlt : i < bs.size) :
    i < (extract.loop as size start bs).size
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
theorem finStronglyMeasurable_mk (hf : AEFinStronglyMeasurable f μ) :
    FinStronglyMeasurable (hf.mk f) μ
-- Mathlib/Topology/Bornology/Absorbs.lean
lemma mono_right (h : Absorbs M s t₁) (ht : t₂ ⊆ t₁) : Absorbs M s t₂
-- Mathlib/Algebra/TrivSqZeroExt.lean
protected theorem inv_inl (r : R) :
    (inl r)⁻¹ = (inl (r⁻¹ : R) : tsze R M)
-- Mathlib/Data/String/Basic.lean
theorem toList_asString (l : List Char) : l.asString.toList = l
-- Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean
theorem Measure.toOuterMeasure_injective [MeasurableSpace α] :
    Injective (toOuterMeasure : Measure α → OuterMeasure α)
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, norm_cast, rclike_simps]
theorem real_smul_ofReal (r x : ℝ) : r • (x : K) = (r : K) * (x : K)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma map_negPolynomial :
    (W.map f).toAffine.negPolynomial = W.negPolynomial.map (mapRingHom f)
-- Mathlib/CategoryTheory/Triangulated/Functor.lean
lemma isTriangulated_of_iso {F₁ F₂ : C ⥤ D} (e : F₁ ≅ F₂) [F₁.CommShift ℤ] [F₂.CommShift ℤ]
    [NatTrans.CommShift e.hom ℤ] [F₁.IsTriangulated] : F₂.IsTriangulated
-- Mathlib/Geometry/RingedSpace/PresheafedSpace/Gluing.lean
/-- The red and the blue arrows in ![this diagram](https://i.imgur.com/mBzV1Rx.png) commute. -/
theorem opensImagePreimageMap_app (i j k : D.J) (U : Opens (D.U i).carrier) :
    D.opensImagePreimageMap i j U ≫ (D.f j k).c.app _ =
      ((π₁ j, i, k) ≫ D.t j i ≫ D.f i j).c.app (op U) ≫
        (π₂⁻¹ j, i, k) (unop _) ≫
          (D.V (j, k)).presheaf.map (eqToHom (opensImagePreimageMap_app' D i j k U).choose)
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem oadd_mul_nfBelow {e₁ n₁ a₁ b₁} (h₁ : NFBelow (oadd e₁ n₁ a₁) b₁) :
    ∀ {o₂ b₂}, NFBelow o₂ b₂ → NFBelow (oadd e₁ n₁ a₁ * o₂) (repr e₁ + b₂)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem replicate_sublist_replicate {m n} (a : α) :
    replicate m a <+ replicate n a ↔ m ≤ n
-- Mathlib/Data/Set/Subsingleton.lean
@[simp]
theorem subsingleton_univ_iff : (univ : Set α).Subsingleton ↔ Subsingleton α
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIocMod_le_right (a b : α) : toIocMod hp a b ≤ a + p
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem pi_div_two_pos : 0 < π / 2
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem countable_iff_lt_aleph_one {α : Type*} (s : Set α) : s.Countable ↔ #s < aleph 1
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma exact_iff_isZero_homology [S.HasHomology] :
    S.Exact ↔ IsZero S.homology
-- Mathlib/Order/ConditionallyCompleteLattice/Finset.lean
theorem Finset.Nonempty.csInf_eq_min' {s : Finset α} (h : s.Nonempty) : sInf ↑s = s.min' h
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp, norm_cast]
lemma coe_algebraMap (r : R) : (algebraMap R s r : A) = algebraMap R A r
-- Mathlib/GroupTheory/Commensurable.lean
theorem commensurable_conj {H K : Subgroup G} (g : ConjAct G) :
    Commensurable H K ↔ Commensurable (g • H) (g • K)
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
theorem smul_re (a : ℤ) (b : ℤ√d) : (↑a * b).re = a * b.re
-- Mathlib/Analysis/SpecialFunctions/PolarCoord.lean
protected theorem polarCoord_apply (a : ℂ) :
    Complex.polarCoord a = (Complex.abs a, Complex.arg a)
-- Mathlib/LinearAlgebra/Matrix/Basis.lean
theorem toMatrix_transpose_apply : (e.toMatrix v)ᵀ j = e.repr (v j)
-- Mathlib/RingTheory/Algebraic.lean
/-- Bijection between algebra equivalences and algebra homomorphisms -/
@[simps]
noncomputable def algEquivEquivAlgHom [Algebra.IsAlgebraic K L] :
    (L ≃ₐ[K] L) ≃* (L →ₐ[K] L)
-- Mathlib/Deprecated/Ring.lean
/-- A semiring homomorphism is a monoid homomorphism. -/
theorem to_isMonoidHom (hf : IsSemiringHom f) : IsMonoidHom f
-- Mathlib/Analysis/InnerProductSpace/l2Space.lean
theorem _root_.Orthonormal.linearIsometryEquiv_symm_apply_single_one (h i) :
    (hv.isHilbertSum h).linearIsometryEquiv.symm (lp.single 2 i 1) = v i
-- Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean
theorem threeAPFree_image_sphere :
    ThreeAPFree ((sphere n d k).image (map (2 * d - 1)) : Set ℕ)
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp] theorem coe_rTensor : rTensor M f = (f : N →ₗ[R] P).rTensor M
-- Mathlib/Algebra/Star/StarAlgHom.lean
@[simp]
theorem symm_mk (f f') (h₁ h₂ h₃ h₄ h₅ h₆) :
    (⟨⟨⟨f, f', h₁, h₂⟩, h₃, h₄⟩, h₅, h₆⟩ : A ≃⋆ₐ[R] B).symm =
      { symm_mk.aux f f' h₁ h₂ h₃ h₄ h₅ h₆ with
        toFun := f'
        invFun := f }
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
protected theorem coe_add (x y : S) : (↑(x + y) : A) = ↑x + ↑y
-- Mathlib/CategoryTheory/Monoidal/NaturalTransformation.lean
@[simp]
theorem ofComponents.hom_app (app : ∀ X : C, F.obj X ≅ G.obj X) (naturality) (unit) (tensor) (X) :
    (ofComponents app naturality unit tensor).hom.app X = (app X).hom
-- Mathlib/Topology/Algebra/Module/LinearPMap.lean
theorem isClosable_iff_exists_closed_extension {f : E →ₗ.[R] F} :
    f.IsClosable ↔ ∃ g : E →ₗ.[R] F, g.IsClosed ∧ f ≤ g
-- Mathlib/Algebra/Associated/Basic.lean
theorem associated_map_mk {f : Associates α →* α} (hinv : Function.RightInverse f Associates.mk)
    (a : α) : a ~ᵤ f (Associates.mk a)
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
@[simp]
theorem mem_genEigenspace (f : End R M) (μ : R) (k : ℕ) (m : M) :
    m ∈ f.genEigenspace μ k ↔ ((f - μ • (1 : End R M)) ^ k) m = 0
-- Mathlib/Order/Atoms.lean
theorem isCoatom_of_map_top_of_image [OrderTop α] [OrderTop β] (f : β ↪o α) (htop : f ⊤ = ⊤)
    {b : β} (hb : IsCoatom (f b)) : IsCoatom b
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem comp_one : p.comp 1 = C (p.eval 1)
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma isZero₂_of_isIso₃ (h : IsIso T.mor₃) : IsZero T.obj₂
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
protected theorem le_add_right (h : μ ≤ ν) : μ ≤ ν + ν'
-- Mathlib/RingTheory/Ideal/Basic.lean
theorem IsPrime.mem_or_mem {I : Ideal α} (hI : I.IsPrime) {x y : α} : x * y ∈ I → x ∈ I ∨ y ∈ I
-- Mathlib/Algebra/Group/Pi/Basic.lean
@[to_additive (attr := simp)]
theorem comp_one [One β] (x : β → γ) : x ∘ (1 : α → β) = const α (x 1)
-- Mathlib/Data/Rel.lean
theorem core_mono : Monotone r.core
-- Mathlib/Algebra/Algebra/Basic.lean
@[simp]
lemma LinearEquiv.extendScalarsOfSurjective_symm (f : M ≃ₗ[R] N) :
    (f.extendScalarsOfSurjective h).symm = f.symm.extendScalarsOfSurjective h
-- Mathlib/Data/Nat/PartENat.lean
@[simp]
theorem toWithTop_lt {x y : PartENat} [Decidable x.Dom] [Decidable y.Dom] :
    toWithTop x < toWithTop y ↔ x < y
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
@[simp]
theorem cof_eq_one_iff_is_succ {o} : cof.{u} o = 1 ↔ ∃ a, o = succ a
-- Mathlib/Analysis/Calculus/Deriv/Inv.lean
theorem derivWithin_inv (x_ne_zero : x ≠ 0) (hxs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin (fun x => x⁻¹) s x = -(x ^ 2)⁻¹
-- Mathlib/RingTheory/DiscreteValuationRing/Basic.lean
theorem addVal_mul {a b : R} :
    addVal R (a * b) = addVal R a + addVal R b
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
theorem IsIntegral.map_of_comp_eq {R S T U : Type*} [CommRing R] [Ring S]
    [CommRing T] [Ring U] [Algebra R S] [Algebra T U] (φ : R →+* T) (ψ : S →+* U)
    (h : (algebraMap T U).comp φ = ψ.comp (algebraMap R S)) {a : S} (ha : IsIntegral R a) :
    IsIntegral T (ψ a)
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem ext_iff : Q = Q' ↔ ∀ x, Q x = Q' x
-- Mathlib/Order/Monotone/Monovary.lean
theorem Antivary.dual_right : Antivary f g → Monovary f (toDual ∘ g)
-- Mathlib/Order/IsWellOrderLimitElement.lean
lemma wellOrderSucc_le {a b : α} (ha : a < b) : wellOrderSucc a ≤ b
-- Mathlib/Data/ZMod/Units.lean
lemma unitsMap_comp {d : ℕ} (hm : n ∣ m) (hd : m ∣ d) :
    (unitsMap hm).comp (unitsMap hd) = unitsMap (dvd_trans hm hd)
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
@[simp]
theorem map_subtype_coe_factors' {a : α} :
    (factors' a).map (↑) = (factors a).map Associates.mk
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem mem_or_inv_mem (x : K) : x ∈ A ∨ x⁻¹ ∈ A
-- Mathlib/Probability/Variance.lean
theorem evariance_eq_lintegral_ofReal (X : Ω → ℝ) (μ : Measure Ω) :
    evariance X μ = ∫⁻ ω, ENNReal.ofReal ((X ω - μ[X]) ^ 2) ∂μ
-- Mathlib/Data/PFun.lean
@[simp]
theorem prodMap_comp_comp (f₁ : α →. β) (f₂ : β →. γ) (g₁ : δ →. ε) (g₂ : ε →. ι) :
    (f₂.comp f₁).prodMap (g₂.comp g₁) = (f₂.prodMap g₂).comp (f₁.prodMap g₁)
-- Mathlib/Order/CompactlyGenerated/Basic.lean
/-- A complete lattice is said to be compactly generated if any
element is the `sSup` of compact elements. -/
class IsCompactlyGenerated (α : Type*) [CompleteLattice α] : Prop where
  /-- In a compactly generated complete lattice,
    every element is the `sSup` of some set of compact elements. -/
  exists_sSup_eq : ∀ x : α, ∃ s : Set α, (∀ x ∈ s, CompleteLattice.IsCompactElement x) ∧ sSup s = x
-- Mathlib/MeasureTheory/Function/L1Space.lean
/-- A non-quantitative version of Markov inequality for integrable functions: the measure of points
where `‖f x‖ ≥ ε` is finite for all positive `ε`. -/
theorem Integrable.measure_norm_ge_lt_top {f : α → β} (hf : Integrable f μ) {ε : ℝ} (hε : 0 < ε) :
    μ { x | ε ≤ ‖f x‖ } < ∞
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToL1S_add (T : Set α → E →L[ℝ] F) (h_zero : ∀ s, MeasurableSet s → μ s = 0 → T s = 0)
    (h_add : FinMeasAdditive μ T) (f g : α →₁ₛ[μ] E) :
    setToL1S T (f + g) = setToL1S T f + setToL1S T g
-- Mathlib/Data/Set/Sigma.lean
theorem insert_sigma : (insert i s).sigma t = Sigma.mk i '' t i ∪ s.sigma t
-- Mathlib/Order/Filter/Extr.lean
theorem IsMaxFilter.min (hf : IsMaxFilter f l a) (hg : IsMaxFilter g l a) :
    IsMaxFilter (fun x => min (f x) (g x)) l a
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem one_le_two_pow : 1 ≤ 2 ^ n
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
protected theorem sub_mul (a b c : Int) : (a - b) * c = a * c - b * c
-- Mathlib/NumberTheory/SumTwoSquares.lean
/-- The set of sums of two squares is closed under multiplication in any commutative ring.
See also `sq_add_sq_mul_sq_add_sq`. -/
theorem sq_add_sq_mul {R} [CommRing R] {a b x y u v : R} (ha : a = x ^ 2 + y ^ 2)
    (hb : b = u ^ 2 + v ^ 2) : ∃ r s : R, a * b = r ^ 2 + s ^ 2
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If `f` tends to negative infinity along a nontrivial filter `l`, then
`fun x ↦ r * f x` tends to negative infinity if and only if `0 < r. `-/
theorem tendsto_const_mul_atBot_iff_pos [NeBot l] (h : Tendsto f l atBot) :
    Tendsto (fun x => r * f x) l atBot ↔ 0 < r
-- Mathlib/Data/List/Basic.lean
@[simp] theorem cons_injective {a : α} : Injective (cons a)
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem getLast?_cons_cons (a b : α) (l : List α) :
    getLast? (a :: b :: l) = getLast? (b :: l)
-- Mathlib/Geometry/Manifold/IntegralCurve.lean
/-- A global integral curve is injective xor periodic with positive period. -/
lemma IsIntegralCurve.periodic_xor_injective [BoundarylessManifold I M]
    (hγ : IsIntegralCurve γ v)
    (hv : ContMDiff I I.tangent 1 (fun x => (⟨x, v x⟩ : TangentBundle I M))) :
    Xor' (∃ T > 0, Periodic γ T) (Injective γ)
-- Mathlib/RingTheory/Polynomial/Basic.lean
@[simp]
theorem support_restriction (p : R[X]) : support (restriction p) = support p
-- Mathlib/Topology/Algebra/Module/Basic.lean
/-- Coerce continuous linear maps to functions. -/
--instance toFun' : CoeFun (M₁ →SL[σ₁₂] M₂) fun _ => M₁ → M₂ := ⟨DFunLike.coe⟩

-- porting note (#10618): was `simp`, now `simp only` proves it
theorem coe_mk (f : M₁ →ₛₗ[σ₁₂] M₂) (h) : (mk f h : M₁ →ₛₗ[σ₁₂] M₂) = f
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
/-- The `d`th coefficient of a power of a multivariate power series
is the sum, indexed by `finsuppAntidiag (Finset.range n) d`, of products of coefficients  -/
theorem coeff_pow [DecidableEq σ] (f : MvPowerSeries σ R) {n : ℕ} (d : σ →₀ ℕ) :
    coeff R d (f ^ n) =
      ∑ l in finsuppAntidiag (Finset.range n) d,
        ∏ i in Finset.range n, coeff R (l i) f
-- Mathlib/NumberTheory/LegendreSymbol/Basic.lean
/-- `legendreSym p a = -1` iff `a` is a nonsquare mod `p`. -/
theorem eq_neg_one_iff {a : ℤ} : legendreSym p a = -1 ↔ ¬IsSquare (a : ZMod p)
-- Mathlib/Topology/Order/LeftRightNhds.lean
/-- If `S` is order-connected and contains two points `x < y`, then `S` is a punctured right
neighbourhood of `x`. -/
lemma mem_nhdsWithin_Ioi [NoMaxOrder α] {S : Set α} (hS : OrdConnected S)
    {x y : α} (hx : x ∈ S) (hy : y ∈ S) (hxy : x < y) :
    S ∈ 𝓝[>] x
-- Mathlib/Topology/Algebra/WithZeroTopology.lean
theorem nhds_eq_update : (𝓝 : Γ₀ → Filter Γ₀) = update pure 0 (⨅ γ ≠ 0, 𝓟 (Iio γ))
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
theorem derivWithin_div_const (hc : DifferentiableWithinAt 𝕜 c s x)
    (d : 𝕜') (hxs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin (fun x => c x / d) s x = derivWithin c s x / d
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem NF.snd {e n a} (h : NF (oadd e n a)) : NF a
-- Mathlib/Data/Finset/Basic.lean
theorem sdiff_ssubset (h : t ⊆ s) (ht : t.Nonempty) : s \ t ⊂ s
-- Mathlib/Analysis/SpecialFunctions/Gaussian/FourierTransform.lean
theorem integral_cexp_neg_mul_sum_add {ι : Type*} [Fintype ι] (hb : 0 < b.re) (c : ι → ℂ) :
    ∫ v : ι → ℝ, cexp (- b * ∑ i, (v i : ℂ) ^ 2 + ∑ i, c i * v i)
      = (π / b) ^ (Fintype.card ι / 2 : ℂ) * cexp ((∑ i, c i ^ 2) / (4 * b))
-- Mathlib/Order/Bounds/Basic.lean
/-- The image under a monotone function of a set which is bounded above is bounded above. See also
`BddAbove.image2`. -/
theorem map_bddAbove : BddAbove s → BddAbove (f '' s)
-- Mathlib/Logic/UnivLE.lean
theorem Small.trans_univLE.{u, v} (α : Type w) [hα : Small.{u} α] [h : UnivLE.{u, v}] :
    Small.{v} α
-- Mathlib/Computability/TMToPartrec.lean
theorem K'.elim_main (a b c d) : K'.elim a b c d K'.main = a
-- Mathlib/Order/PartialSups.lean
@[simp]
lemma disjoint_partialSups_left [DistribLattice α] [OrderBot α] {f : ℕ → α} {n : ℕ} {x : α} :
    Disjoint (partialSups f n) x ↔ ∀ k ≤ n, Disjoint (f k) x
-- Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean
/-- The function `z ^ w` is continuous in `(z, w)` provided that `z` does not belong to the interval
`(-∞, 0]` on the real line. See also `Complex.continuousAt_cpow_zero_of_re_pos` for a version that
works for `z = 0` but assumes `0 < re w`. -/
theorem continuousAt_cpow {p : ℂ × ℂ} (hp_fst : p.fst ∈ slitPlane) :
    ContinuousAt (fun x : ℂ × ℂ => x.1 ^ x.2) p
-- Mathlib/Analysis/BoxIntegral/Box/Basic.lean
theorem dist_le_distortion_mul (I : Box ι) (i : ι) :
    dist I.lower I.upper ≤ I.distortion * (I.upper i - I.lower i)
-- Mathlib/Algebra/Lie/Nilpotent.lean
/-- See also `LieModule.isNilpotent_iff_exists_ucs_eq_top`. -/
theorem isNilpotent_iff : IsNilpotent R L M ↔ ∃ k, lowerCentralSeries R L M k = ⊥
-- Mathlib/Algebra/Category/Ring/Constructions.lean
@[simp]
theorem pushoutCocone_inl :
    (pushoutCocone R A B).inl = Algebra.TensorProduct.includeLeftRingHom (A := A)
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem monotone_map : Monotone (MeasurableSpace.map f)
-- Mathlib/Analysis/Convex/Segment.lean
@[simp]
theorem vadd_openSegment [AddTorsor G E] [VAddCommClass G E E] (a : G) (b c : E) :
    a +ᵥ openSegment 𝕜 b c = openSegment 𝕜 (a +ᵥ b) (a +ᵥ c)
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Basic.lean
theorem exists_iff {p : Fin n → Prop} : (Exists fun i => p i) ↔ Exists fun i => Exists fun h => p ⟨i, h⟩
-- Mathlib/Tactic/NormNum/BigOperators.lean
lemma Finset.range_succ' {n nn n' : ℕ} (pn : NormNum.IsNat n nn) (pn' : nn = Nat.succ n') :
    Finset.range n = Finset.cons n' (Finset.range n') Finset.not_mem_range_self
-- Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
theorem weightedHomogeneousComponent_eq_zero_of_not_mem [DecidableEq M]
    (φ : MvPolynomial σ R) (i : M) (hi : i ∉ Finset.image (weight w) φ.support) :
    weightedHomogeneousComponent w i φ = 0
-- Mathlib/FieldTheory/Separable.lean
theorem separable_def (f : R[X]) : f.Separable ↔ IsCoprime f (derivative f)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
@[simp] protected theorem sub_zero (n : Nat) : n - 0 = n
-- Mathlib/Topology/EMetricSpace/Basic.lean
@[simp]
theorem ULift.edist_up_up (x y : α) : edist (ULift.up x) (ULift.up y) = edist x y
-- Mathlib/AlgebraicGeometry/OpenImmersion.lean
@[reassoc, elementwise]
lemma map_ΓIso_inv {X Y : Scheme.{u}} (f : X ⟶ Y) [IsOpenImmersion f] (U : Y.Opens) :
    Y.presheaf.map (homOfLE inf_le_right).op ≫ (ΓIso f U).inv = f.app U
-- Mathlib/Data/Set/Finite.lean
protected theorem Finite.offDiag {s : Set α} (hs : s.Finite) : s.offDiag.Finite
-- Mathlib/Data/Multiset/Basic.lean
theorem eq_zero_iff_forall_not_mem {s : Multiset α} : s = 0 ↔ ∀ a, a ∉ s
-- Mathlib/Combinatorics/SimpleGraph/Trails.lean
theorem IsTrail.isEulerian_of_forall_mem {u v : V} {p : G.Walk u v} (h : p.IsTrail)
    (hc : ∀ e, e ∈ G.edgeSet → e ∈ p.edges) : p.IsEulerian
-- Mathlib/Data/Option/Defs.lean
@[simp]
theorem elim'_none (b : β) (f : α → β) : Option.elim' b f none = b
-- Mathlib/Data/Nat/Factorization/Root.lean
@[simp] lemma ceilRoot_zero_left (a : ℕ) : ceilRoot 0 a = 0
-- Mathlib/Order/Heyting/Hom.lean
@[simp]
theorem comp_assoc (f : CoheytingHom γ δ) (g : CoheytingHom β γ) (h : CoheytingHom α β) :
    (f.comp g).comp h = f.comp (g.comp h)
-- Mathlib/MeasureTheory/Function/EssSup.lean
theorem le_essInf_of_ae_le {f : α → β} (c : β) (hf : (fun _ => c) ≤ᵐ[μ] f) : c ≤ essInf f μ
-- Mathlib/Topology/ContinuousOn.lean
theorem continuousOn_fst {s : Set (α × β)} : ContinuousOn Prod.fst s
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
theorem subNatNat_of_sub_eq_succ {m n k : Nat} (h : n - m = succ k) : subNatNat m n = -[k+1]
-- Mathlib/CategoryTheory/Generator.lean
theorem isSeparator_coprod_of_isSeparator_right (G H : C) [HasBinaryCoproduct G H]
    (hH : IsSeparator H) : IsSeparator (G ⨿ H)
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem degree_of_d_eq_zero' : (⟨0, 0, 0, 0⟩ : Cubic R).toPoly.degree = ⊥
-- Mathlib/LinearAlgebra/Vandermonde.lean
@[simp]
theorem vandermonde_apply {n : ℕ} (v : Fin n → R) (i j) : vandermonde v i j = v i ^ (j : ℕ)
-- Mathlib/RingTheory/WittVector/Basic.lean
private theorem ghostFun_sub : ghostFun (x - y) = ghostFun x - ghostFun y
-- Mathlib/Topology/LocallyFinite.lean
theorem continuousOn_iUnion' {g : X → Y} (hf : LocallyFinite f)
    (hc : ∀ i x, x ∈ closure (f i) → ContinuousWithinAt g (f i) x) :
    ContinuousOn g (⋃ i, f i)
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
/-- The map from ideals of `R` dividing `I` to the ideals of `A` dividing `J` induced by
  a homomorphism `f : R/I →+* A/J` -/
@[simps] -- Porting note: use `Subtype` instead of `Set` to make linter happy
def idealFactorsFunOfQuotHom {f : R ⧸ I →+* A ⧸ J} (hf : Function.Surjective f) :
    {p : Ideal R // p ∣ I} →o {p : Ideal A // p ∣ J}
-- Mathlib/Data/Matrix/Basic.lean
/-- Permuting vectors on both sides of a dot product is a no-op. -/
@[simp]
theorem comp_equiv_dotProduct_comp_equiv (e : m ≃ n) : x ∘ e ⬝ᵥ y ∘ e = x ⬝ᵥ y
-- Mathlib/Computability/Partrec.lean
theorem sum_inr : Computable (@Sum.inr α β)
-- Mathlib/Data/PFunctor/Univariate/Basic.lean
theorem liftp_iff {α : Type u} (p : α → Prop) (x : P α) :
    Liftp p x ↔ ∃ a f, x = ⟨a, f⟩ ∧ ∀ i, p (f i)
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
@[reassoc (attr := simp)]
theorem fac_lift {F : MonoFactorisation f} (hF : IsImage F) (F' : MonoFactorisation f) :
    F.e ≫ hF.lift F' = F'.e
-- Mathlib/Data/Set/Finite.lean
protected theorem Finite.prod (hs : s.Finite) (ht : t.Finite) : (s ×ˢ t : Set (α × β)).Finite
-- Mathlib/AlgebraicTopology/DoldKan/Compatibility.lean
/-- The isomorphism `eA.functor ≅ F ⋙ e'.inverse` deduced from the
unit isomorphism of `e'` and the isomorphism `hF : eA.functor ⋙ e'.functor ≅ F`. -/
@[simps!]
def υ : eA.functor ≅ F ⋙ e'.inverse
-- Mathlib/LinearAlgebra/Eigenspace/Triangularizable.lean
theorem inf_iSup_genEigenspace [FiniteDimensional K V] (h : ∀ x ∈ p, f x ∈ p) :
    p ⊓ ⨆ μ, ⨆ k, f.genEigenspace μ k = ⨆ μ, ⨆ k, p ⊓ f.genEigenspace μ k
-- Mathlib/Analysis/Convex/Independent.lean
theorem convexIndependent_set_iff_inter_convexHull_subset {s : Set E} :
    ConvexIndependent 𝕜 ((↑) : s → E) ↔ ∀ t, t ⊆ s → s ∩ convexHull 𝕜 t ⊆ t
-- Mathlib/SetTheory/Game/Birthday.lean
@[simp]
theorem birthday_natCast : ∀ n : ℕ, birthday n = n
-- Mathlib/Data/Set/Finite.lean
theorem empty_card' {h : Fintype.{u} (∅ : Set α)} : @Fintype.card (∅ : Set α) h = 0
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem ae_smul_measure {p : α → Prop} [Monoid R] [DistribMulAction R ℝ≥0∞]
    [IsScalarTower R ℝ≥0∞ ℝ≥0∞] (h : ∀ᵐ x ∂μ, p x) (c : R) : ∀ᵐ x ∂c • μ, p x
-- Mathlib/Analysis/Normed/Algebra/Unitization.lean
lemma isometry_inr : Isometry ((↑) : A → Unitization 𝕜 A)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
@[simp] theorem zero_ne_negSucc (n : Nat) : 0 ≠ -[n+1]
-- Mathlib/Probability/Martingale/Centering.lean
theorem martingalePart_eq_sum : martingalePart f ℱ μ = fun n =>
    f 0 + ∑ i ∈ Finset.range n, (f (i + 1) - f i - μ[f (i + 1) - f i|ℱ i])
-- Mathlib/Data/Sigma/Basic.lean
@[simp]
theorem «exists» {p : (Σ'a, β a) → Prop} : (∃ x, p x) ↔ ∃ a b, p ⟨a, b⟩
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Folds.lean
theorem iunfoldr.fst_eq
    {f : Fin w → α → α × Bool} (state : Nat → α) (s : α)
    (init : s = state 0)
    (ind : ∀(i : Fin w), (f i (state i.val)).fst = state (i.val+1)) :
    (iunfoldr f s).fst = state w
-- Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean
theorem submodule_comap_mul_reverse (p q : Submodule R (CliffordAlgebra Q)) :
    (p * q).comap (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) =
      q.comap (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) *
        p.comap (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q)
-- Mathlib/CategoryTheory/Adjunction/Restrict.lean
@[simp, reassoc]
lemma map_restrictFullyFaithful_unit_app (X : C) :
    iC.map ((adj.restrictFullyFaithful hiC hiD comm1 comm2).unit.app X) =
    adj.unit.app (iC.obj X) ≫ R'.map (comm1.hom.app X) ≫ comm2.hom.app (L.obj X)