ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Sites/CompatiblePlus.lean
/-- The isomorphism between `P⁺ ⋙ F` and `(P ⋙ F)⁺`, functorially in `P`. -/
@[simps! hom_app inv_app]
def plusFunctorWhiskerRightIso :
    J.plusFunctor D ⋙ (whiskeringRight _ _ _).obj F ≅
      (whiskeringRight _ _ _).obj F ⋙ J.plusFunctor E
-- Mathlib/RingTheory/Polynomial/Nilpotent.lean
/-- Let `P` be a polynomial over `R`. If its constant term is a unit and its other coefficients are
nilpotent, then `P` is a unit.

See also `Polynomial.isUnit_iff_coeff_isUnit_isNilpotent`. -/
theorem isUnit_of_coeff_isUnit_isNilpotent (hunit : IsUnit (P.coeff 0))
    (hnil : ∀ i, i ≠ 0 → IsNilpotent (P.coeff i)) : IsUnit P
-- Mathlib/Algebra/Lie/Weights/RootSystem.lean
@[simp] lemma rootSystem_root_apply (α) : (rootSystem H).root α = α
-- Mathlib/Data/Nat/GCD/BigOperators.lean
theorem coprime_multiset_prod_right_iff {k : ℕ} {m : Multiset ℕ} :
    Coprime k m.prod ↔ ∀ n ∈ m, Coprime k n
-- Mathlib/Order/RelClasses.lean
/-- A version of `antisymm'` with `r` explicit.

This lemma matches the lemmas from lean core in `Init.Algebra.Classes`, but is missing there.  -/
@[elab_without_expected_type]
theorem antisymm_of' (r : α → α → Prop) [IsAntisymm α r] {a b : α} : r a b → r b a → b = a
-- Mathlib/Algebra/Homology/HomotopyCategory/DegreewiseSplit.lean
@[simp]
lemma homOfDegreewiseSplit_f (n : ℤ) :
    (homOfDegreewiseSplit S σ).f n =
      (cocycleOfDegreewiseSplit S σ).1.v n (n + 1) rfl
-- Mathlib/Data/Finset/Pointwise/Interval.lean
@[to_additive Ico_add_Icc_subset]
theorem Ico_mul_Icc_subset' [LocallyFiniteOrder α] (a b c d : α) :
    Ico a b * Icc c d ⊆ Ico (a * c) (b * d)
-- Mathlib/Topology/Constructions.lean
theorem nhds_toDual (x : X) : 𝓝 (toDual x) = map toDual (𝓝 x)
-- Mathlib/Data/Matroid/Closure.lean
@[simp] lemma closure_union_closure_left_eq (M : Matroid α) (X Y : Set α) :
    M.closure (M.closure X ∪ Y) = M.closure (X ∪ Y)
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
/-- Technical lemma to rewrite suitably the preimage of an intersection under an extended chart, to
bring it into a convenient form to apply derivative lemmas. -/
theorem extChartAt_preimage_inter_eq (x : M) :
    (extChartAt I x).symm ⁻¹' (s ∩ t) ∩ range I =
      (extChartAt I x).symm ⁻¹' s ∩ range I ∩ (extChartAt I x).symm ⁻¹' t
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Iio_union_Ici : Iio a ∪ Ici a = univ
-- Mathlib/Data/QPF/Multivariate/Constructions/Cofix.lean
theorem Cofix.abs_repr {α} (x : Cofix F α) : Quot.mk _ (Cofix.repr x) = x
-- Mathlib/Topology/Compactness/Lindelof.lean
theorem Set.Countable.isLindelof (hs : s.Countable) : IsLindelof s
-- Mathlib/GroupTheory/Nilpotent.lean
@[simp]
theorem lowerCentralSeries_one : lowerCentralSeries G 1 = commutator G
-- Mathlib/CategoryTheory/Sites/Sieves.lean
@[simp]
theorem pullback_top {f : Y ⟶ X} : (⊤ : Sieve X).pullback f = ⊤
-- Mathlib/ModelTheory/Bundled.lean
@[simp]
theorem coe_of (M : Type w) [L.Structure M] [M ⊨ T] [Nonempty M] : (of T M : Type w) = M
-- Mathlib/RingTheory/Ideal/Prod.lean
theorem isPrime_ideal_prod_top {I : Ideal R} [h : I.IsPrime] : (prod I (⊤ : Ideal S)).IsPrime
-- Mathlib/RingTheory/Ideal/Norm.lean
/-- If the `d` from `Ideal.exists_mul_add_mem_pow_succ` is unique, up to `P`,
then so are the `c`s, up to `P ^ (i + 1)`.
Inspired by [Neukirch], proposition 6.1 -/
theorem Ideal.mul_add_mem_pow_succ_inj (P : Ideal S) {i : ℕ} (a d d' e e' : S) (a_mem : a ∈ P ^ i)
    (e_mem : e ∈ P ^ (i + 1)) (e'_mem : e' ∈ P ^ (i + 1)) (h : d - d' ∈ P) :
    a * d + e - (a * d' + e') ∈ P ^ (i + 1)
-- Mathlib/CategoryTheory/Yoneda.lean
lemma isIso_of_yoneda_map_bijective {X Y : C} (f : X ⟶ Y)
    (hf : ∀ (T : C), Function.Bijective (fun (x : T ⟶ X) => x ≫ f)) :
    IsIso f
-- Mathlib/Algebra/Opposites.lean
@[to_additive (attr := simp)]
theorem op_comp_unop : (op : α → αᵐᵒᵖ) ∘ unop = id
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem extChartAt_image_nhd_mem_nhds_of_boundaryless [I.Boundaryless]
    {x : M} (hx : s ∈ 𝓝 x) : extChartAt I x '' s ∈ 𝓝 (extChartAt I x x)
-- Mathlib/RingTheory/Complex.lean
theorem Algebra.norm_complex_eq : Algebra.norm ℝ = normSq.toMonoidHom
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma PosSMulReflectLE.toPosSMulStrictMono [PosSMulReflectLE α β] : PosSMulStrictMono α β
-- .lake/packages/lean4/src/lean/Init/Grind/Norm.lean
@[grind_norm] theorem eq_true_eq (p : Prop) : (p = True) = p
-- Mathlib/GroupTheory/FreeGroup/IsFreeGroup.lean
protected lemma injective (b : FreeGroupBasis ι G) : Injective b
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
theorem nonarchimedean (q r : ℤ_[p]) : ‖q + r‖ ≤ max ‖q‖ ‖r‖
-- Mathlib/Order/CompleteBooleanAlgebra.lean
theorem iSup_iInf_eq [CompletelyDistribLattice α] {f : ∀ a, κ a → α} :
    (⨆ a, ⨅ b, f a b) = ⨅ g : ∀ a, κ a, ⨆ a, f a (g a)
-- Mathlib/Algebra/AlgebraicCard.lean
theorem aleph0_le_cardinal_mk_of_charZero (R A : Type*) [CommRing R] [IsDomain R] [Ring A]
    [Algebra R A] [CharZero A] : ℵ₀ ≤ #{ x : A // IsAlgebraic R x }
-- Mathlib/Algebra/Lie/DirectSum.lean
theorem lie_of_same [DecidableEq ι] {i : ι} (x y : L i) :
    ⁅of L i x, of L i y⁆ = of L i ⁅x, y⁆
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive (attr := simp)]
theorem div_nonempty : (s / t).Nonempty ↔ s.Nonempty ∧ t.Nonempty
-- Mathlib/Data/Int/NatPrime.lean
theorem succ_dvd_or_succ_dvd_of_succ_sum_dvd_mul {p : ℕ} (p_prime : Nat.Prime p) {m n : ℤ}
    {k l : ℕ} (hpm : ↑(p ^ k) ∣ m) (hpn : ↑(p ^ l) ∣ n) (hpmn : ↑(p ^ (k + l + 1)) ∣ m * n) :
    ↑(p ^ (k + 1)) ∣ m ∨ ↑(p ^ (l + 1)) ∣ n
-- Mathlib/CategoryTheory/Limits/Creates.lean
/-- If `F` creates colimits of shape `J`, and `D` has colimits of shape `J`, then
`C` has colimits of shape `J`.
-/
theorem hasColimitsOfShape_of_hasColimitsOfShape_createsColimitsOfShape (F : C ⥤ D)
    [HasColimitsOfShape J D] [CreatesColimitsOfShape J F] : HasColimitsOfShape J C
-- Mathlib/Algebra/Ring/Equiv.lean
theorem map_eq_neg_one_iff {x : R} : f x = -1 ↔ x = -1
-- Mathlib/GroupTheory/Sylow.lean
@[simp, norm_cast]
theorem coe_ofCard [Finite G] {p : ℕ} [Fact p.Prime] (H : Subgroup G)
    (card_eq : Nat.card H = p ^ (Nat.card G).factorization p) : ↑(ofCard H card_eq) = H
-- Mathlib/NumberTheory/Pell.lean
/-- If we multiply a positive solution with the inverse of a fundamental solution,
the `x`-coordinate stays positive. -/
theorem mul_inv_x_pos {a₁ : Solution₁ d} (h : IsFundamental a₁) {a : Solution₁ d} (hax : 1 < a.x)
    (hay : 0 < a.y) : 0 < (a * a₁⁻¹).x
-- Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean
@[simp]
theorem differentiableAt_log_iff : DifferentiableAt ℝ log x ↔ x ≠ 0
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive (attr := simp)] lemma inv_mul_cancel_comm_assoc (a b : G) : a⁻¹ * (b * a) = b
-- Mathlib/Analysis/Normed/Ring/Units.lean
/-- In a complete normed ring, an element `y` of distance less than `‖x⁻¹‖⁻¹` from `x` is a unit.
Here we construct its `Units` structure. -/
@[simps! val]
def ofNearby (x : Rˣ) (y : R) (h : ‖y - x‖ < ‖(↑x⁻¹ : R)‖⁻¹) : Rˣ
-- Mathlib/NumberTheory/Padics/PadicVal.lean
/-- `padicValNat p 1` is `0` for any `p`. -/
@[simp]
protected theorem one : padicValNat p 1 = 0
-- Mathlib/Analysis/Normed/Field/Basic.lean
@[simp]
theorem nnnorm_div (a b : α) : ‖a / b‖₊ = ‖a‖₊ / ‖b‖₊
-- Mathlib/Logic/Function/Basic.lean
theorem pred_update (P : ∀ ⦃a⦄, β a → Prop) (f : ∀ a, β a) (a' : α) (v : β a') (a : α) :
    P (update f a' v a) ↔ a = a' ∧ P v ∨ a ≠ a' ∧ P (f a)
-- Mathlib/AlgebraicGeometry/Properties.lean
theorem map_injective_of_isIntegral [IsIntegral X] {U V : X.Opens} (i : U ⟶ V)
    [H : Nonempty U] : Function.Injective (X.presheaf.map i.op)
-- Mathlib/Deprecated/Subgroup.lean
/-- `IsNormalAddSubgroup (s : Set A)` expresses the fact that `s` is a normal additive subgroup
of the additive group `A`. Important: the preferred way to say this in Lean is via bundled
subgroups `S : AddSubgroup A` and `hs : S.normal`, and not via this structure. -/
structure IsNormalAddSubgroup [AddGroup A] (s : Set A) extends IsAddSubgroup s : Prop where
  /-- The proposition that `s` is closed under (additive) conjugation. -/
  normal : ∀ n ∈ s, ∀ g : A, g + n + -g ∈ s
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
theorem RingHom.IsIntegralElem.of_mul_unit (x y : S) (r : R) (hr : f r * y = 1)
    (hx : f.IsIntegralElem (x * y)) : f.IsIntegralElem x
-- Mathlib/CategoryTheory/Bicategory/Coherence.lean
/-- The 2-isomorphism `normalizeIso p f` is natural in `f`. -/
theorem normalize_naturality {a b c : B} (p : Path a b) {f g : Hom b c} (η : f ⟶ g) :
    (preinclusion B).map ⟨p⟩ ◁ η ≫ (normalizeIso p g).hom =
      (normalizeIso p f).hom ≫
        (preinclusion B).map₂ (eqToHom (Discrete.ext _ _ (normalizeAux_congr p η)))
-- Mathlib/Control/Basic.lean
theorem map_bind (x : m α) {g : α → m β} {f : β → γ} :
    f <$> (x >>= g) = x >>= fun a => f <$> g a
-- Mathlib/Analysis/Normed/Group/Constructions.lean
/-- The $L^1$ norm is less than the $L^\infty$ norm scaled by the cardinality. -/
@[to_additive Pi.sum_nnnorm_apply_le_nnnorm "The $L^1$ norm is less than the $L^\\infty$ norm
scaled by the cardinality."]
lemma Pi.sum_nnnorm_apply_le_nnnorm' : ∑ i, ‖f i‖₊ ≤ Fintype.card ι • ‖f‖₊
-- Mathlib/Topology/Connected/Basic.lean
/-- The iUnion of connected sets indexed by a type with an archimedean successor (like `ℕ` or `ℤ`)
  such that any two neighboring sets meet is connected. -/
theorem IsConnected.iUnion_of_chain [Nonempty β] {s : β → Set α} (H : ∀ n, IsConnected (s n))
    (K : ∀ n, (s n ∩ s (succ n)).Nonempty) : IsConnected (⋃ n, s n)
-- Mathlib/Order/Bounded.lean
theorem bounded_gt_Ioc [Preorder α] (a b : α) : Bounded (· > ·) (Ioc a b)
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
@[aesop safe apply]
lemma min_bi_le {b : α → ℝ} (i : α) : b (min_bi b) ≤ b i
-- Mathlib/Algebra/Group/Submonoid/Units.lean
@[to_additive (attr := simp)]
lemma val_mem_ofUnits_iff_mem (H : Subgroup Gˣ) (x : Gˣ) : (x : G) ∈ H.ofUnits ↔ x ∈ H
-- Mathlib/Algebra/Group/Commute/Defs.lean
@[to_additive]
protected theorem all [CommMagma S] (a b : S) : Commute a b
-- Mathlib/Data/Set/Card.lean
theorem ncard_le_one_iff_subset_singleton [Nonempty α]
    (hs : s.Finite := by toFinite_tac) :
    s.ncard ≤ 1 ↔ ∃ x : α, s ⊆ {x}
-- Mathlib/Data/Matroid/Basic.lean
theorem Indep.basis_setOf_insert_basis (hI : M.Indep I) :
    M.Basis I {x | M.Basis I (insert x I)}
-- Mathlib/Logic/Function/Conjugate.lean
protected theorem comp_eq (h : Semiconj₂ f ga gb) : bicompr f ga = bicompl gb f f
-- Mathlib/Order/WithBot.lean
theorem lt_toDual_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
    a < WithBot.toDual b ↔ b < WithTop.ofDual a
-- Mathlib/Combinatorics/Quiver/Covering.lean
theorem Prefunctor.star_comp (u : U) : (φ ⋙q ψ).star u = ψ.star (φ.obj u) ∘ φ.star u
-- Mathlib/Data/Seq/Computation.lean
theorem Results.len_unique {s : Computation α} {a b m n} (h1 : Results s a m) (h2 : Results s b n) :
    m = n
-- Mathlib/Order/Filter/NAry.lean
/-- Symmetric statement to `Filter.map₂_map_left_comm`. -/
theorem map_map₂_distrib_left {n : γ → δ} {m' : α' → β → δ} {n' : α → α'}
    (h_distrib : ∀ a b, n (m a b) = m' (n' a) b) : (map₂ m f g).map n = map₂ m' (f.map n') g
-- Mathlib/Algebra/Order/Module/Pointwise.lean
lemma BddBelow.smul_of_nonneg (hs : BddBelow s) (ha : 0 ≤ a) : BddBelow (a • s)
-- Mathlib/Analysis/Convex/Body.lean
protected theorem isBounded : Bornology.IsBounded (K : Set V)
-- .lake/packages/batteries/Batteries/Classes/Order.lean
theorem cmp_congr_left (xy : cmp x y = .eq) : cmp x z = cmp y z
-- Mathlib/Algebra/Group/Center.lean
@[to_additive]
protected theorem right_comm (h : IsMulCentral c) (a b) : a * b * c = a * c * b
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToSimpleFunc_const' [Nonempty α] (T : Set α → F →L[ℝ] F') (x : F)
    {m : MeasurableSpace α} : SimpleFunc.setToSimpleFunc T (SimpleFunc.const α x) = T univ x
-- Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean
/-- Define the nontrivial quadratic character on `ZMod 4`, `χ₄`.
It corresponds to the extension `ℚ(√-1)/ℚ`. -/
@[simps]
def χ₄ : MulChar (ZMod 4) ℤ
-- Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean
theorem gradedComm_tmul_one (a : ⨁ i, 𝒜 i) : gradedComm R 𝒜 ℬ (a ⊗ₜ 1) = 1 ⊗ₜ a
-- Mathlib/Data/Finset/Piecewise.lean
lemma piecewise_mem_Icc (h : f ≤ g) : s.piecewise f g ∈ Set.Icc f g
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive top_prod]
theorem top_prod (H : Subgroup N) : (⊤ : Subgroup G).prod H = H.comap (MonoidHom.snd G N)
-- Mathlib/Algebra/Order/ToIntervalMod.lean
private theorem toIxxMod_antisymm (h₁₂₃ : toIcoMod hp a b ≤ toIocMod hp a c)
    (h₁₃₂ : toIcoMod hp a c ≤ toIocMod hp a b) :
    b ≡ a [PMOD p] ∨ c ≡ b [PMOD p] ∨ a ≡ c [PMOD p]
-- Mathlib/GroupTheory/Finiteness.lean
theorem AddMonoid.fg_def : AddMonoid.FG N ↔ (⊤ : AddSubmonoid N).FG
-- Mathlib/Topology/ContinuousFunction/Basic.lean
theorem copy_eq (f : C(α, β)) (f' : α → β) (h : f' = f) : f.copy f' h = f
-- Mathlib/Data/Seq/WSeq.lean
theorem mem_cons (s : WSeq α) (a) : a ∈ cons a s
-- Mathlib/Combinatorics/SetFamily/Compression/UV.lean
@[simp]
theorem compress_self (u a : α) : compress u u a = a
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
/-- If `f` is strictly differentiable at `x` with derivative `f'` and `K > ‖f'‖₊`, then `f` is
`K`-Lipschitz in a neighborhood of `x`. -/
theorem HasStrictFDerivAt.exists_lipschitzOnWith_of_nnnorm_lt (hf : HasStrictFDerivAt f f' x)
    (K : ℝ≥0) (hK : ‖f'‖₊ < K) : ∃ s ∈ 𝓝 x, LipschitzOnWith K f s
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem linearIndependent_fin_cons {n} {v : Fin n → V} :
    LinearIndependent K (Fin.cons x v : Fin (n + 1) → V) ↔
      LinearIndependent K v ∧ x ∉ Submodule.span K (range v)
-- Mathlib/Algebra/Ring/Semireal/Defs.lean
/--
A semireal ring is a non-trivial commutative ring (with unit) in which `-1` is *not* a sum of
squares. Note that `-1` does not make sense in a semiring. Below we define the class `isSemiReal R`
for all additive monoid `R` equipped with a multiplication, a multiplicative unit and a negation.
-/
@[mk_iff]
class isSemireal [AddMonoid R] [Mul R] [One R] [Neg R] : Prop where
  non_trivial        : (0 : R) ≠ 1
  neg_one_not_SumSq  : ¬isSumSq (-1 : R)
-- Mathlib/Analysis/Calculus/Conformal/NormedSpace.lean
theorem conformal_id : Conformal (id : X → X)
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem CauchySeq.comp_tendsto {γ} [Preorder β] [SemilatticeSup γ] [Nonempty γ] {f : β → α}
    (hf : CauchySeq f) {g : γ → β} (hg : Tendsto g atTop atTop) : CauchySeq (f ∘ g)
-- Mathlib/Algebra/Homology/ExactSequence.lean
lemma exact_iff_δlast {n : ℕ} (S : ComposableArrows C (n + 2)) :
    S.Exact ↔ S.δlast.Exact ∧ (mk₂ (S.map' n (n + 1)) (S.map' (n + 1) (n + 2))).Exact
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem cos_coe_pi : cos (π : Angle) = -1
-- Mathlib/RingTheory/Generators.lean
@[simp]
lemma Cotangent.map_id :
    Cotangent.map (.id P) = LinearMap.id
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Counting.lean
private lemma triple_eq_triple_of_mem (hst : Disjoint s t) (hsu : Disjoint s u) (htu : Disjoint t u)
    {x₁ x₂ y₁ y₂ z₁ z₂ : α} (h : ({x₁, y₁, z₁} : Finset α) = {x₂, y₂, z₂})
    (hx₁ : x₁ ∈ s) (hx₂ : x₂ ∈ s) (hy₁ : y₁ ∈ t) (hy₂ : y₂ ∈ t) (hz₁ : z₁ ∈ u) (hz₂ : z₂ ∈ u) :
    (x₁, y₁, z₁) = (x₂, y₂, z₂)
-- Mathlib/Algebra/Order/Interval/Set/Monoid.lean
theorem Ico_add_bij : BijOn (· + d) (Ico a b) (Ico (a + d) (b + d))
-- Mathlib/Data/TypeVec.lean
@[simp]
theorem lastFun_comp {α₀ α₁ α₂ : TypeVec (n + 1)} (f₀ : α₀ ⟹ α₁) (f₁ : α₁ ⟹ α₂) :
    lastFun (f₁ ⊚ f₀) = lastFun f₁ ∘ lastFun f₀
-- Mathlib/Data/Nat/Cast/Basic.lean
@[simp]
lemma powersMulHom_apply (x : α) (n : Multiplicative ℕ) : powersMulHom α x n = x ^ toAdd n
-- Mathlib/LinearAlgebra/Span.lean
@[simp]
lemma biSup_comap_subtype_eq_top {ι : Type*} (s : Set ι) (p : ι → Submodule R M) :
    ⨆ i ∈ s, (p i).comap (⨆ i ∈ s, p i).subtype = ⊤
-- Mathlib/Topology/ContinuousOn.lean
theorem mem_nhdsWithin {t : Set α} {a : α} {s : Set α} :
    t ∈ 𝓝[s] a ↔ ∃ u, IsOpen u ∧ a ∈ u ∧ u ∩ s ⊆ t
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem coeff_zero_X (i : σ) : coeff 0 (X i : MvPolynomial σ R) = 0
-- Mathlib/MeasureTheory/Decomposition/SignedHahn.lean
private theorem someExistsOneDivLT_lt (hi : ¬s ≤[i] 0) :
    (1 / (findExistsOneDivLT s i + 1) : ℝ) < s (someExistsOneDivLT s i)
-- Mathlib/Algebra/Homology/Augment.lean
@[simp]
theorem augment_d_succ_succ (C : CochainComplex V ℕ) {X : V} (f : X ⟶ C.X 0) (w : f ≫ C.d 0 1 = 0)
    (i j : ℕ) : (augment C f w).d (i + 1) (j + 1) = C.d i j
-- Mathlib/Topology/Order.lean
theorem isOpen_singleton_nhdsAdjoint {α : Type*} {a b : α} (f : Filter α) (hb : b ≠ a) :
    IsOpen[nhdsAdjoint a f] {b}
-- Mathlib/GroupTheory/Sylow.lean
theorem Sylow.coe_smul {g : G} {P : Sylow p G} : ↑(g • P) = MulAut.conj g • (P : Set G)
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem iInter_iInter_eq_or_left {b : β} {p : β → Prop} {s : ∀ x : β, x = b ∨ p x → Set α} :
    ⋂ (x) (h), s x h = s b (Or.inl rfl) ∩ ⋂ (x) (h : p x), s x (Or.inr h)
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
theorem colimit.desc_extend (F : J ⥤ C) [HasColimit F] (c : Cocone F) {X : C} (f : c.pt ⟶ X) :
    colimit.desc F (c.extend f) = colimit.desc F c ≫ f
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
lemma inv_mulVec_eq_vec {A : Matrix n n α} [Invertible A]
    {u v : n → α} (hM : u = A.mulVec v) : A⁻¹.mulVec u = v
-- Mathlib/Algebra/Homology/DerivedCategory/Ext.lean
@[simp]
lemma comp_mk₀_id (α : Ext X Y n) :
    α.comp (mk₀ (𝟙 Y)) (add_zero n) = α
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
/-- A word and its maximal reduction correspond to the same element of the free group. -/
@[to_additive "A word and its maximal reduction correspond to the same element of the additive free
  group."]
theorem reduce.self : mk (reduce L) = mk L
-- Mathlib/Analysis/Convex/Function.lean
theorem ConvexOn.sub_strictConcaveOn (hf : ConvexOn 𝕜 s f) (hg : StrictConcaveOn 𝕜 s g) :
    StrictConvexOn 𝕜 s (f - g)
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_const_mono (h : ι' → ι) : ⨅ _ : ι, a ≤ ⨅ _ : ι', a
-- Mathlib/Combinatorics/SimpleGraph/Hamiltonian.lean
/-- Hamiltonian paths are paths. -/
lemma IsHamiltonian.isPath (hp : p.IsHamiltonian) : p.IsPath
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem one_comp : comp (1 : R[X]) p = 1
-- Mathlib/Data/Finset/Basic.lean
theorem insert_val' (a : α) (s : Finset α) : (insert a s).1 = dedup (a ::ₘ s.1)
-- Mathlib/Probability/Martingale/Basic.lean
theorem smul_nonpos {f : ι → Ω → F} {c : ℝ} (hc : c ≤ 0) (hf : Supermartingale f ℱ μ) :
    Submartingale (c • f) ℱ μ
-- Mathlib/Analysis/Calculus/Deriv/Polynomial.lean
protected theorem differentiableAt : DifferentiableAt 𝕜 (fun x => p.eval x) x
-- Mathlib/Data/Nat/PSub.lean
theorem psub_eq_some {m : ℕ} : ∀ {n k}, psub m n = some k ↔ k + n = m
-- Mathlib/Order/Heyting/Basic.lean
theorem le_himp_himp : a ≤ (a ⇨ b) ⇨ b
-- Mathlib/MeasureTheory/OuterMeasure/AE.lean
theorem all_ae_of {ι : Sort*} {p : α → ι → Prop} (hp : ∀ᵐ a ∂μ, ∀ i, p a i) (i : ι) :
    ∀ᵐ a ∂μ, p a i
-- Mathlib/LinearAlgebra/Dual.lean
/-- `simp` normal form version of `total_dualBasis` -/
@[simp]
theorem total_coord [CommRing R] [AddCommGroup M] [Module R M] [Finite ι] (b : Basis ι R M)
    (f : ι →₀ R) (i : ι) : Finsupp.total ι (Dual R M) R b.coord f (b i) = f i
-- Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean
theorem cpow_sub {x : ℂ} (y z : ℂ) (hx : x ≠ 0) : x ^ (y - z) = x ^ y / x ^ z
-- Mathlib/Order/Hom/Bounded.lean
@[simp]
theorem cancel_right {g₁ g₂ : BotHom β γ} {f : BotHom α β} (hf : Surjective f) :
    g₁.comp f = g₂.comp f ↔ g₁ = g₂
-- Mathlib/FieldTheory/SeparableDegree.lean
/-- A constant polynomial has zero separable degree. -/
theorem natSepDegree_eq_zero (h : f.natDegree = 0) : f.natSepDegree = 0
-- Mathlib/CategoryTheory/Monoidal/Functor.lean
@[reassoc]
theorem map_whiskerLeft (X : C) {Y Z : C} (f : Y ⟶ Z) :
    F.map (X ◁ f) = inv (F.μ X Y) ≫ F.obj X ◁ F.map f ≫ F.μ X Z
-- Mathlib/Probability/Independence/Conditional.lean
theorem iCondIndepSet.condIndep_generateFrom_le [LinearOrder ι] {s : ι → Set Ω}
    (hsm : ∀ n, MeasurableSet (s n)) (hs : iCondIndepSet m' hm' s μ) (i : ι) {k : ι} (hk : i < k) :
    CondIndep m' (generateFrom {s k}) (generateFrom { t | ∃ j ≤ i, s j = t }) hm' μ
-- Mathlib/Algebra/Order/BigOperators/Ring/Finset.lean
lemma prod_pos (h0 : ∀ i ∈ s, 0 < f i) : 0 < ∏ i ∈ s, f i
-- Mathlib/MeasureTheory/PiSystem.lean
theorem generate_le {s : Set (Set α)} (h : ∀ t ∈ s, d.Has t) : generate s ≤ d
-- Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean
theorem exists_measurable_superset₂ (μ ν : Measure α) (s : Set α) :
    ∃ t, s ⊆ t ∧ MeasurableSet t ∧ μ t = μ s ∧ ν t = ν s
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
theorem sin_arctan (x : ℝ) : sin (arctan x) = x / √(1 + x ^ 2)
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem typein_lt_self {o : Ordinal} (i : o.out.α) :
    @typein _ (· < ·) (isWellOrder_out_lt _) i < o
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
theorem lipschitzOnWith_iff_restrict : LipschitzOnWith K f s ↔ LipschitzWith K (s.restrict f)
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
/-- The congruence relation used to localize a `CommMonoid` at a submonoid can be expressed
equivalently as an infimum (see `Localization.r`) or explicitly
(see `Localization.r'`). -/
@[to_additive AddLocalization.r_eq_r'
    "The additive congruence relation used to localize an `AddCommMonoid` at a submonoid can be
expressed equivalently as an infimum (see `AddLocalization.r`) or explicitly
(see `AddLocalization.r'`)."]
theorem r_eq_r' : r S = r' S
-- Mathlib/Order/Interval/Set/OrderEmbedding.lean
@[simp] theorem preimage_Iic : e ⁻¹' Iic (e x) = Iic x
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[simp]
theorem extend_comp_eq' [MeasurableSpace β] (f₁ : α →ₛ γ) {g : α → β} (hg : MeasurableEmbedding g)
    (f₂ : β →ₛ γ) : f₁.extend g hg f₂ ∘ g = f₁
-- Mathlib/Order/Heyting/Basic.lean
theorem compl_inf_eq_bot : aᶜ ⊓ a = ⊥
-- Mathlib/Algebra/BigOperators/Finsupp.lean
theorem sum_ite_self_eq [DecidableEq α] {N : Type*} [AddCommMonoid N] (f : α →₀ N) (a : α) :
    (f.sum fun x v => ite (a = x) v 0) = f a
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
protected theorem bijective (e : P₁ ≃ᵃ[k] P₂) : Bijective e
-- Mathlib/Algebra/Algebra/Equiv.lean
@[deprecated map_pow (since := "2024-06-20")]
protected theorem map_pow : ∀ (x : A₁) (n : ℕ), e (x ^ n) = e x ^ n
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
theorem of_eq_true (h : p = True) : p
-- Mathlib/Probability/Kernel/Composition.lean
theorem swapLeft_apply' (κ : Kernel (α × β) γ) (a : β × α) (s : Set γ) :
    swapLeft κ a s = κ a.swap s
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma nonsingular_zero [Nontrivial R] : W'.Nonsingular ![1, 1, 0]
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
protected theorem _root_.AEMeasurable.nullMeasurable {f : α → β} (h : AEMeasurable f μ) :
    NullMeasurable f μ
-- Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
@[simp]
theorem ι_range_map_lift (f : M →ₗ[R] A) (cond : ∀ m, f m * f m = algebraMap _ _ (Q m)) :
    (ι Q).range.map (lift Q ⟨f, cond⟩).toLinearMap = LinearMap.range f
-- Mathlib/Analysis/BoundedVariation.lean
/-- A real function into a finite dimensional real vector space which is Lipschitz on a set
is differentiable almost everywhere in this set. For the general Rademacher theorem assuming
that the source space is finite dimensional, see `LipschitzOnWith.ae_differentiableWithinAt`. -/
theorem LipschitzOnWith.ae_differentiableWithinAt_real {C : ℝ≥0} {f : ℝ → V} {s : Set ℝ}
    (h : LipschitzOnWith C f s) (hs : MeasurableSet s) :
    ∀ᵐ x ∂volume.restrict s, DifferentiableWithinAt ℝ f s x
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive (attr := simp)]
lemma mker_fst : mker (fst M N) = .prod ⊥ ⊤
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
@[simp]
theorem intervalIntegrable_pow : IntervalIntegrable (fun x => x ^ n) μ a b
-- Mathlib/Computability/Language.lean
lemma mem_kstar_iff_exists_nonempty {x : List α} :
    x ∈ l∗ ↔ ∃ S : List (List α), x = S.join ∧ ∀ y ∈ S, y ∈ l ∧ y ≠ []
-- Mathlib/CategoryTheory/Bicategory/FunctorBicategory.lean
/-- Right unitor for the vertical composition of oplax natural transformations. -/
-- Porting note: verified that projections are correct and changed @[simps] to @[simps!]
@[simps!]
def rightUnitor (η : F ⟶ G) : η ≫ 𝟙 G ≅ η