ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Dynamics/BirkhoffSum/Average.lean
theorem birkhoffAverage_congr_ring' (S : Type*) [DivisionSemiring S] [Module S M] :
    birkhoffAverage (α := α) (M := M) R = birkhoffAverage S
-- Mathlib/GroupTheory/Submonoid/Centralizer.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_centralizer : ↑(centralizer S) = S.centralizer
-- Mathlib/NumberTheory/FLT/Three.lean
private lemma y_spec : S.a + η * S.b = λ * S.y
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_map {β} [MeasurableSpace β] {φ : α → β} (hφ : AEMeasurable φ μ) {f : β → G}
    (hfm : AEStronglyMeasurable f (Measure.map φ μ)) :
    ∫ y, f y ∂Measure.map φ μ = ∫ x, f (φ x) ∂μ
-- Mathlib/GroupTheory/SpecificGroups/Cyclic.lean
@[to_additive (attr := simp)]
lemma mulEquivOfOrderOfEq_symm :
    (mulEquivOfOrderOfEq hg hg' h).symm = mulEquivOfOrderOfEq hg' hg h.symm
-- Mathlib/MeasureTheory/Group/Action.lean
/-- See also `measure_preimage_smul_of_nullMeasurableSet` and `measure_preimage_smul`. -/
@[to_additive "See also `measure_preimage_smul_of_nullMeasurableSet` and `measure_preimage_smul`."]
theorem measure_preimage_smul_le (c : G) (s : Set α) : μ ((c • ·) ⁻¹' s) ≤ μ s
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
/-- An image map is a morphism `image f → image g` fitting into a commutative square and satisfying
    the obvious commutativity conditions. -/
structure ImageMap {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] (sq : f ⟶ g) where
  map : image f.hom ⟶ image g.hom
  map_ι : map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right := by aesop
-- Mathlib/Order/Antichain.lean
theorem to_dual [LE α] (hs : IsAntichain (· ≤ ·) s) : @IsAntichain αᵒᵈ (· ≤ ·) s
-- Mathlib/Algebra/Lie/Basic.lean
@[simp]
theorem toFun_eq_coe (f : L₁ →ₗ⁅R⁆ L₂) : f.toFun = ⇑f
-- Mathlib/Algebra/Field/IsField.lean
/-- Transferring from `Semifield` to `IsField`. -/
theorem Semifield.toIsField (R : Type u) [Semifield R] : IsField R
-- Mathlib/Data/Set/Pointwise/SMul.lean
theorem vsub_iInter₂_subset (s : Set β) (t : ∀ i, κ i → Set β) :
    (s -ᵥ ⋂ (i) (j), t i j) ⊆ ⋂ (i) (j), s -ᵥ t i j
-- Mathlib/Probability/Process/Stopping.lean
/-- If the indexing order has the discrete topology, then the stopped process of an adapted process
is adapted. -/
theorem Adapted.stoppedProcess_of_discrete [DiscreteTopology ι] (hu : Adapted f u)
    (hτ : IsStoppingTime f τ) : Adapted f (MeasureTheory.stoppedProcess u τ)
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem Valid.mk (cs cs' : List Char) : Valid ⟨cs ++ cs'⟩ ⟨utf8Len cs⟩
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive]
theorem smul_orbit_subset (m : M) (a : α) : m • orbit M a ⊆ orbit M a
-- Mathlib/Data/ENNReal/Inv.lean
@[gcongr] protected theorem div_le_div (hab : a ≤ b) (hdc : d ≤ c) : a / c ≤ b / d
-- Mathlib/Order/OmegaCompletePartialOrder.lean
lemma isLUB_range_ωSup (c : Chain α) : IsLUB (Set.range c) (ωSup c)
-- Mathlib/Order/Minimal.lean
theorem mem_maximals_setOf_iff {P : α → Prop} :
    x ∈ maximals r (setOf P) ↔ P x ∧ ∀ ⦃y⦄, P y → r x y → x = y
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive]
theorem not_one_le_div_iff : ¬1 ≤ f / g ↔ Disjoint f g
-- Mathlib/LinearAlgebra/Lagrange.lean
@[simp]
theorem natDegree_basis (hvs : Set.InjOn v s) (hi : i ∈ s) :
    (Lagrange.basis s v i).natDegree = s.card - 1
-- Mathlib/Algebra/Group/AddChar.lean
@[simp] lemma toMonoidHomEquiv_apply (ψ : AddChar A M) (a : Multiplicative A) :
    toMonoidHomEquiv ψ a = ψ (Multiplicative.toAdd a)
-- Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean
lemma reverse_charpoly (M : Matrix n n R) :
    M.charpoly.reverse = M.charpolyRev
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
theorem IsTrail.of_append_left {u v w : V} {p : G.Walk u v} {q : G.Walk v w}
    (h : (p.append q).IsTrail) : p.IsTrail
-- Mathlib/AlgebraicTopology/DoldKan/NCompGamma.lean
theorem natTrans_app_f_app (P : Karoubi (SimplicialObject C)) :
    Γ₂N₂.natTrans.app P =
      (N₂ ⋙ Γ₂).map P.decompId_i ≫
        (Γ₂N₂ToKaroubiIso.hom ≫ Γ₂N₁.natTrans).app P.X ≫ P.decompId_p
-- Mathlib/Data/Multiset/FinsetOps.lean
theorem ndinter_eq_zero_iff_disjoint {s t : Multiset α} : ndinter s t = 0 ↔ Disjoint s t
-- Mathlib/NumberTheory/Cyclotomic/CyclotomicCharacter.lean
/-- The relationship between `IsPrimitiveRoot.autToPow` and
`ModularCyclotomicCharacter`. Note that `IsPrimitiveRoot.autToPow`
needs an explicit root of unity, and also an auxiliary "base ring" `R`. -/
lemma IsPrimitiveRoot.autToPow_eq_ModularCyclotomicCharacter (n : ℕ+)
    (R : Type*) [CommRing R] [Algebra R L] {μ : L} (hμ : IsPrimitiveRoot μ n) (g : L ≃ₐ[R] L) :
    hμ.autToPow R g = ModularCyclotomicCharacter L hμ.card_rootsOfUnity g
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_smul_left (x y : F) {r : 𝕜} : ⟪r • x, y⟫ = r† * ⟪x, y⟫
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
theorem adj_injective : Injective (Adj : SimpleGraph V → V → V → Prop)
-- Mathlib/Combinatorics/Quiver/Path.lean
@[simp]
theorem length_comp (p : Path a b) : ∀ {c} (q : Path b c), (p.comp q).length = p.length + q.length
-- Mathlib/Tactic/Linarith/Lemmas.lean
theorem lt_of_lt_of_eq {α} [OrderedSemiring α] {a b : α} (ha : a < 0) (hb : b = 0) : a + b < 0
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem uniformContinuous_ofAdd : UniformContinuous (ofAdd : α → Multiplicative α)
-- Mathlib/RingTheory/Localization/Integer.lean
theorem finsetIntegerMultiple_image [DecidableEq R] (s : Finset S) :
    algebraMap R S '' finsetIntegerMultiple M s = commonDenomOfFinset M s • (s : Set S)
-- Mathlib/CategoryTheory/Shift/ShiftedHom.lean
@[simp]
lemma comp_zero [∀ (a : M), (shiftFunctor C a).PreservesZeroMorphisms]
    {a : M} (β : ShiftedHom X Y a) {b c : M} (h : b + a = c) :
    β.comp (0 : ShiftedHom Y Z b) h = 0
-- Mathlib/Data/Num/Lemmas.lean
@[norm_cast] -- @[simp] -- Porting note (#10618): simp can prove this
theorem to_nat_to_int (n : PosNum) : ((n : ℕ) : ℤ) = n
-- Mathlib/RingTheory/RingHom/Finite.lean
theorem finite_stableUnderBaseChange : StableUnderBaseChange @Finite
-- Mathlib/CategoryTheory/Groupoid.lean
@[simp]
theorem Groupoid.reverse_eq_inv (f : X ⟶ Y) : Quiver.reverse f = Groupoid.inv f
-- Mathlib/Analysis/Normed/Group/Constructions.lean
/-- The seminorm of an element in a product space is `≤ r` if and only if the norm of each
component is. -/
@[to_additive pi_norm_le_iff_of_nonneg "The seminorm of an element in a product space is `≤ r` if
and only if the norm of each component is."]
lemma pi_norm_le_iff_of_nonneg' (hr : 0 ≤ r) : ‖x‖ ≤ r ↔ ∀ i, ‖x i‖ ≤ r
-- Mathlib/Order/Fin/Basic.lean
lemma strictMono_castSucc : StrictMono (castSucc : Fin n → Fin (n + 1))
-- Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean
@[simp]
theorem Differentiable.log (hf : Differentiable ℝ f) (hx : ∀ x, f x ≠ 0) :
    Differentiable ℝ fun x => log (f x)
-- Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean
theorem log_doublingGamma_eq :
    EqOn (log ∘ doublingGamma)
      (fun s => log (Gamma (s / 2)) + log (Gamma (s / 2 + 1 / 2)) + s * log 2 - log (2 * √π))
      (Ioi 0)
-- Mathlib/LinearAlgebra/DFinsupp.lean
theorem independent_of_dfinsupp_sumAddHom_injective (p : ι → AddSubmonoid N)
    (h : Function.Injective (sumAddHom fun i => (p i).subtype)) : Independent p
-- Mathlib/Algebra/Polynomial/Derivative.lean
theorem derivative_zero : derivative (0 : R[X]) = 0
-- Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean
theorem span_minpoly_eq_annihilator {M} [AddCommGroup M] [Module 𝕜 M] (f : Module.End 𝕜 M) :
    Ideal.span {minpoly 𝕜 f} = Module.annihilator 𝕜[X] (Module.AEval' f)
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
lemma HasEigenvalue.pow {f : End R M} {μ : R} (h : f.HasEigenvalue μ) (n : ℕ) :
    (f ^ n).HasEigenvalue (μ ^ n)
-- Mathlib/Logic/Basic.lean
theorem or_iff_not_and_not : a ∨ b ↔ ¬(¬a ∧ ¬b)
-- Mathlib/Combinatorics/SimpleGraph/Maps.lean
theorem map_adj_iff {v w : V} : G'.Adj (f v) (f w) ↔ G.Adj v w
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem drop_suffix (n) (l : List α) : drop n l <:+ l
-- Mathlib/Algebra/Order/GroupWithZero/Canonical.lean
@[simp]
theorem le_zero_iff : a ≤ 0 ↔ a = 0
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem append_data (arr arr' : Array α) :
    (arr ++ arr').data = arr.data ++ arr'.data
-- Mathlib/Order/Lattice.lean
theorem SemilatticeSup.dual_dual (α : Type*) [H : SemilatticeSup α] :
    OrderDual.instSemilatticeSup αᵒᵈ = H
-- Mathlib/Topology/Category/LightProfinite/AsLimit.lean
lemma surjective_transitionMap (n : ℕ) : Function.Surjective (S.transitionMap n)
-- Mathlib/Analysis/PSeries.lean
/-- Test for convergence of the `p`-series: the real-valued series `∑' n : ℕ, 1 / n ^ p` converges
if and only if `1 < p`. -/
theorem summable_one_div_nat_pow {p : ℕ} :
    Summable (fun n => 1 / (n : ℝ) ^ p : ℕ → ℝ) ↔ 1 < p
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive sub_nsmul]
lemma pow_sub (a : G) {m n : ℕ} (h : n ≤ m) : a ^ (m - n) = a ^ m * (a ^ n)⁻¹
-- Mathlib/Analysis/Calculus/FDeriv/Star.lean
@[fun_prop]
theorem HasStrictFDerivAt.star (h : HasStrictFDerivAt f f' x) :
    HasStrictFDerivAt (fun x => star (f x)) (((starL' 𝕜 : F ≃L[𝕜] F) : F →L[𝕜] F) ∘L f') x
-- Mathlib/RingTheory/Valuation/ValuationRing.lean
@[simp]
theorem coe_equivInteger_apply (a : A) : (equivInteger A K a : K) = algebraMap A K a
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Cospan.lean
@[simp]
theorem spanExt_hom_app_zero : (spanExt iX iY iZ wf wg).hom.app WalkingSpan.zero = iX.hom
-- Mathlib/CategoryTheory/Idempotents/HomologicalComplex.lean
@[simp, reassoc]
theorem p_comp_d : P.p.f n ≫ f.f.f n = f.f.f n
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_lt_wf : WellFounded fun p q : R[X] => degree p < degree q
-- Mathlib/Algebra/GCDMonoid/Finset.lean
nonrec theorem gcd_mul_right {a : α} : (s.gcd fun x ↦ f x * a) = s.gcd f * normalize a
-- Mathlib/Data/Set/Function.lean
theorem image_restrict (f : α → β) (s t : Set α) :
    s.restrict f '' (Subtype.val ⁻¹' t) = f '' (t ∩ s)
-- Mathlib/Data/Matrix/ColumnRowPartitioned.lean
@[simp]
lemma sum_elim_vecMul_fromRows (B₁ : Matrix m₁ n R) (B₂ : Matrix m₂ n R)
    (v₁ : m₁ → R) (v₂ : m₂ → R) :
    Sum.elim v₁ v₂ ᵥ* fromRows B₁ B₂ = v₁ ᵥ* B₁ + v₂ ᵥ* B₂
-- Mathlib/Data/Finsupp/Basic.lean
theorem graph_injective (α M) [Zero M] : Injective (@graph α M _)
-- Mathlib/Topology/Order/IsLUB.lean
theorem exists_seq_strictAnti_strictMono_tendsto [DenselyOrdered α] [FirstCountableTopology α]
    {x y : α} (h : x < y) :
    ∃ u v : ℕ → α, StrictAnti u ∧ StrictMono v ∧ (∀ k, u k ∈ Ioo x y) ∧ (∀ l, v l ∈ Ioo x y) ∧
      (∀ k l, u k < v l) ∧ Tendsto u atTop (𝓝 x) ∧ Tendsto v atTop (𝓝 y)
-- Mathlib/Data/Option/Basic.lean
theorem pbind_eq_none {f : ∀ a : α, a ∈ x → Option β}
    (h' : ∀ a (H : a ∈ x), f a H = none → x = none) : x.pbind f = none ↔ x = none
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem lipschitzWith_compLp [Fact (1 ≤ p)] (hg : LipschitzWith c g) (g0 : g 0 = 0) :
    LipschitzWith c (hg.compLp g0 : Lp E p μ → Lp F p μ)
-- Mathlib/Analysis/Normed/Group/InfiniteSum.lean
/-- If `∑' i, ‖f i‖` is summable, then `‖∑' i, f i‖ ≤ (∑' i, ‖f i‖)`. Note that we do not assume
that `∑' i, f i` is summable, and it might not be the case if `α` is not a complete space. -/
theorem norm_tsum_le_tsum_norm {f : ι → E} (hf : Summable fun i => ‖f i‖) :
    ‖∑' i, f i‖ ≤ ∑' i, ‖f i‖
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
@[simp]
theorem isCokernelEpiComp_desc {c : CokernelCofork f} (i : IsColimit c) {W} (g : W ⟶ X) [hg : Epi g]
    {h : W ⟶ Y} (hh : h = g ≫ f) (s : CokernelCofork h) :
    (isCokernelEpiComp i g hh).desc s =
      i.desc
        (Cofork.ofπ s.π
          (by
            rw [← cancel_epi g, ← Category.assoc, ← hh]
            simp))
-- Mathlib/ModelTheory/Substructures.lean
theorem comap_injective_of_surjective : Function.Injective (comap f)
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
@[reassoc]
theorem δ_comp_σ_of_gt' {n} {i : Fin (n + 3)} {j : Fin (n + 2)} (H : j.succ < i) :
    δ i ≫ σ j = σ (j.castLT ((add_lt_add_iff_right 1).mp (lt_of_lt_of_le H i.is_le))) ≫
      δ (i.pred fun (hi : i = 0) => by simp only [Fin.not_lt_zero, hi] at H)
-- Mathlib/Data/TypeVec.lean
/-- Extensionality for arrows -/
@[ext]
theorem Arrow.ext {α β : TypeVec n} (f g : α ⟹ β) :
    (∀ i, f i = g i) → f = g
-- Mathlib/Data/Sign.lean
@[simp]
theorem sign_mul_self (x : α) : sign x * x = |x|
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Iio_inj : Iio a = Iio b ↔ a = b
-- Mathlib/Topology/Algebra/Module/StrongTopology.lean
theorem topologicalSpace_eq [UniformSpace F] [UniformAddGroup F] (𝔖 : Set (Set E)) :
    instTopologicalSpace σ F 𝔖 = TopologicalSpace.induced DFunLike.coe
      (UniformOnFun.topologicalSpace E F 𝔖)
-- Mathlib/Data/Matroid/Basic.lean
theorem Base.basis_ground (hB : M.Base B) : M.Basis B M.E
-- Mathlib/Analysis/Convex/Caratheodory.lean
theorem minCardFinsetOfMemConvexHull_nonempty : (minCardFinsetOfMemConvexHull hx).Nonempty
-- Mathlib/Data/Finset/NatDivisors.lean
lemma Finset.nat_divisors_prod {ι : Type*} (s : Finset ι) (f : ι → ℕ) :
    divisors (∏ i ∈ s, f i) = ∏ i ∈ s, divisors (f i)
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
theorem AntioneOn.integrableOn_isCompact [IsFiniteMeasureOnCompacts μ] (hs : IsCompact s)
    (hanti : AntitoneOn f s) : IntegrableOn f s μ
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
@[simp]
theorem transpose_transpose (μ : YoungDiagram) : μ.transpose.transpose = μ
-- Mathlib/Data/Nat/Squarefree.lean
theorem prod_primeFactors_sdiff_of_squarefree {n : ℕ} (hn : Squarefree n) {t : Finset ℕ}
    (ht : t ⊆ n.primeFactors) :
    ∏ a ∈ (n.primeFactors \ t), a = n / ∏ a ∈ t, a
-- Mathlib/Topology/Algebra/Order/Field.lean
/-- In a linearly ordered field with the order topology, if `f` tends to a positive constant `C` and
`g` tends to `Filter.atBot` then `f * g` tends to `Filter.atBot`. -/
theorem Filter.Tendsto.mul_atBot {C : 𝕜} (hC : 0 < C) (hf : Tendsto f l (𝓝 C))
    (hg : Tendsto g l atBot) : Tendsto (fun x => f x * g x) l atBot
-- Mathlib/Data/List/Sym.lean
theorem length_sym {n : ℕ} {xs : List α} :
    (xs.sym n).length = Nat.multichoose xs.length n
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
theorem isLocalization_stalk' (y : PrimeSpectrum Γ(X, U)) (hy : hU.fromSpec.1.base y ∈ U) :
    @IsLocalization.AtPrime
      (R := Γ(X, U))
      (S := X.presheaf.stalk <| hU.fromSpec.1.base y) _ _
      ((TopCat.Presheaf.algebra_section_stalk X.presheaf _)) y.asIdeal _
-- Mathlib/RingTheory/AdjoinRoot.lean
theorem isIntegral_root' (hg : g.Monic) : IsIntegral R (root g)
-- Mathlib/RingTheory/Jacobson.lean
/-- If `S` is the localization of the Jacobson ring `R` at the submonoid generated by `y : R`, then
`S` is Jacobson. -/
theorem isJacobson_localization [H : IsJacobson R] : IsJacobson S
-- Mathlib/SetTheory/Game/Ordinal.lean
theorem toPGame_lf {a b : Ordinal} (h : a < b) : a.toPGame ⧏ b.toPGame
-- Mathlib/Computability/Halting.lean
theorem RePred.of_eq {α} [Primcodable α] {p q : α → Prop} (hp : RePred p) (H : ∀ a, p a ↔ q a) :
    RePred q
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
/-- Uniform convergence on a filter `p'` to a constant function is equivalent to convergence in
`p ×ˢ p'`. -/
theorem tendsto_prod_filter_iff {c : β} :
    Tendsto (↿F) (p ×ˢ p') (𝓝 c) ↔ TendstoUniformlyOnFilter F (fun _ => c) p p'
-- Mathlib/Data/Real/Hyperreal.lean
theorem eq_of_isSt_real {r s : ℝ} : IsSt r s → r = s
-- Mathlib/Data/Finset/Basic.lean
@[simp] lemma forall_mem_not_eq' {s : Finset α} {a : α} : (∀ b ∈ s, ¬ b = a) ↔ a ∉ s
-- Mathlib/Data/Set/Basic.lean
theorem eq_of_mem_singleton {x y : α} (h : x ∈ ({y} : Set α)) : x = y
-- Mathlib/AlgebraicGeometry/Spec.lean
/-- The spectrum, as a contravariant functor from commutative rings to topological spaces.
-/
@[simps! obj map]
def Spec.toTop : CommRingCat.{u}ᵒᵖ ⥤ TopCat
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
theorem Differentiable.const_sub (hf : Differentiable 𝕜 f) (c : F) :
    Differentiable 𝕜 fun y => c - f y
-- Mathlib/Analysis/Calculus/LocalExtr/Basic.lean
theorem mem_posTangentConeAt_of_frequently_mem (h : ∃ᶠ t : ℝ in 𝓝[>] 0, x + t • y ∈ s) :
    y ∈ posTangentConeAt s x
-- Mathlib/CategoryTheory/Monad/Basic.lean
/-- The data of a monad on C consists of an endofunctor T together with natural transformations
η : 𝟭 C ⟶ T and μ : T ⋙ T ⟶ T satisfying three equations:
- T μ_X ≫ μ_X = μ_(TX) ≫ μ_X (associativity)
- η_(TX) ≫ μ_X = 1_X (left unit)
- Tη_X ≫ μ_X = 1_X (right unit)
-/
structure Monad extends C ⥤ C where
  /-- The unit for the monad. -/
  η : 𝟭 _ ⟶ toFunctor
  /-- The multiplication for the monad. -/
  μ : toFunctor ⋙ toFunctor ⟶ toFunctor
  assoc : ∀ X, toFunctor.map (NatTrans.app μ X) ≫ μ.app _ = μ.app _ ≫ μ.app _ := by aesop_cat
  left_unit : ∀ X : C, η.app (toFunctor.obj X) ≫ μ.app _ = 𝟙 _ := by aesop_cat
  right_unit : ∀ X : C, toFunctor.map (η.app X) ≫ μ.app _ = 𝟙 _ := by aesop_cat
-- Mathlib/Data/Set/Basic.lean
theorem compl_ne_univ : sᶜ ≠ univ ↔ s.Nonempty
-- Mathlib/CategoryTheory/Limits/Types.lean
/-- Sections of `F ⋙ coyoneda.obj (op X)` identify to natural
transformations `(const J).obj X ⟶ F`. -/
@[simps]
def compCoyonedaSectionsEquiv (F : J ⥤ C) (X : C) :
    (F ⋙ coyoneda.obj (op X)).sections ≃ ((const J).obj X ⟶ F)
-- Mathlib/Geometry/Euclidean/MongePoint.lean
/-- The Monge point of an (n+2)-simplex, minus the centroid of an
n-dimensional face, is orthogonal to the difference of the two
vertices not in that face. -/
theorem inner_mongePoint_vsub_face_centroid_vsub {n : ℕ} (s : Simplex ℝ P (n + 2))
    {i₁ i₂ : Fin (n + 3)} :
    ⟪s.mongePoint -ᵥ ({i₁, i₂}ᶜ : Finset (Fin (n + 3))).centroid ℝ s.points,
        s.points i₁ -ᵥ s.points i₂⟫ =
      0
-- Mathlib/Analysis/Convex/Basic.lean
theorem Convex.linear_preimage {s : Set F} (hs : Convex 𝕜 s) (f : E →ₗ[𝕜] F) :
    Convex 𝕜 (f ⁻¹' s)
-- Mathlib/Probability/Kernel/RadonNikodym.lean
lemma withDensity_rnDeriv_of_subset_compl_mutuallySingularSetSlice
    [IsFiniteKernel κ] [IsFiniteKernel η] {a : α} {s : Set γ} (hsm : MeasurableSet s)
    (hs : s ⊆ (mutuallySingularSetSlice κ η a)ᶜ) :
    withDensity η (rnDeriv κ η) a s = κ a s
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp] lemma mapₗ_eq_zero_iff (hf : Measurable f) : Measure.mapₗ f μ = 0 ↔ μ = 0
-- Mathlib/Order/Synonym.lean
@[simp] lemma Lex.forall {p : Lex α → Prop} : (∀ a, p a) ↔ ∀ a, p (toLex a)
-- Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
theorem ΓSpecIso_obj_hom {X : Scheme.{u}} (U : X.Opens) :
    (Scheme.ΓSpecIso Γ(X, U)).hom = (Spec.map U.topIso.inv).app ⊤ ≫
      (ΓSpec.adjunction.unit.app U).app ⊤ ≫ U.topIso.hom
-- Mathlib/Data/PEquiv.lean
theorem symm_trans_rev (f : α ≃. β) (g : β ≃. γ) : (f.trans g).symm = g.symm.trans f.symm
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurable_to_bool {f : α → Bool} (h : MeasurableSet (f ⁻¹' {true})) : Measurable f
-- Mathlib/Topology/Constructions.lean
theorem isClosedMap_toAdd : IsClosedMap (toAdd : Multiplicative X → X)
-- Mathlib/Data/List/Rotate.lean
@[simp]
theorem rotate'_zero (l : List α) : l.rotate' 0 = l
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Eval.lean
theorem sub_one_pow_totient_lt_natAbs_cyclotomic_eval {n : ℕ} {q : ℕ} (hn' : 1 < n) (hq : q ≠ 1) :
    (q - 1) ^ totient n < ((cyclotomic n ℤ).eval ↑q).natAbs
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem symm_dual_id :
    CompleteLatticeHom.dual.symm (CompleteLatticeHom.id _) = CompleteLatticeHom.id α
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem empty_inter (a : Set α) : ∅ ∩ a = ∅
-- Mathlib/Algebra/Group/Subsemigroup/Basic.lean
/-- If `s` is a dense set in a magma `M`, `Subsemigroup.closure s = ⊤`, then in order to prove that
some predicate `p` holds for all `x : M` it suffices to verify `p x` for `x ∈ s`,
and verify that `p x` and `p y` imply `p (x * y)`. -/
@[to_additive (attr := elab_as_elim) "If `s` is a dense set in an additive monoid `M`,
  `AddSubsemigroup.closure s = ⊤`, then in order to prove that some predicate `p` holds
  for all `x : M` it suffices to verify `p x` for `x ∈ s`, and verify that `p x` and `p y` imply
  `p (x + y)`."]
theorem dense_induction {p : M → Prop} (x : M) {s : Set M} (hs : closure s = ⊤)
    (mem : ∀ x ∈ s, p x)
    (mul : ∀ x y, p x → p y → p (x * y)) : p x
-- Mathlib/Analysis/Normed/Group/Quotient.lean
theorem bddBelow_image_norm (s : Set M) : BddBelow (norm '' s)
-- Mathlib/Order/Cover.lean
lemma wcovBy_eq_reflGen_covBy [PartialOrder α] : ((· : α) ⩿ ·) = ReflGen (· ⋖ ·)
-- Mathlib/Analysis/Convex/Hull.lean
theorem convex_convexHull : Convex 𝕜 (convexHull 𝕜 s)
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem contMDiffOn_fst {s : Set (M × N)} : ContMDiffOn (I.prod J) I n Prod.fst s
-- Mathlib/LinearAlgebra/DFinsupp.lean
theorem mapRange.linearEquiv_trans (f : ∀ i, β i ≃ₗ[R] β₁ i) (f₂ : ∀ i, β₁ i ≃ₗ[R] β₂ i) :
    (mapRange.linearEquiv fun i => (f i).trans (f₂ i)) =
      (mapRange.linearEquiv f).trans (mapRange.linearEquiv f₂)
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem eval₂_C_X : eval₂ C X p = p
-- Mathlib/Data/List/Sigma.lean
theorem perm_nodupKeys {l₁ l₂ : List (Sigma β)} (h : l₁ ~ l₂) : NodupKeys l₁ ↔ NodupKeys l₂
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem totalOn_range (s : Set α) : LinearMap.range (Finsupp.totalOn α M R v s) = ⊤
-- Mathlib/Data/Set/Pointwise/Interval.lean
theorem Iio_add_bij : BijOn (· + a) (Iio b) (Iio (b + a))
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem IsOpen.closure_div (ht : IsOpen t) (s : Set G) : closure s / t = s / t
-- Mathlib/Algebra/Lie/Submodule.lean
theorem coe_toSubmodule_mk (p : Submodule R M) (h) :
    (({ p with lie_mem := h } : LieSubmodule R L M) : Submodule R M) = p
-- Mathlib/Topology/ContinuousOn.lean
theorem continuousWithinAt_prod_of_discrete_left [DiscreteTopology α]
    {f : α × β → γ} {s : Set (α × β)} {x : α × β} :
    ContinuousWithinAt f s x ↔ ContinuousWithinAt (f ⟨x.1, ·⟩) {b | (x.1, b) ∈ s} x.2
-- Mathlib/Data/Finset/Sups.lean
theorem singleton_infs_singleton : ({a} ⊼ {b} : Finset α) = {a ⊓ b}
-- Mathlib/Analysis/Complex/Basic.lean
@[simp]
theorem conjLIE_symm : conjLIE.symm = conjLIE
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[simp]
theorem sInf_toAddSubgroup (s : Set (Subring R)) :
    (sInf s).toAddSubgroup = ⨅ t ∈ s, Subring.toAddSubgroup t
-- Mathlib/Order/Defs.lean
theorem lt_trichotomy (a b : α) : a < b ∨ a = b ∨ b < a
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
/-- The composition of `C^∞` functions within domains at points is `C^∞`. -/
nonrec theorem SmoothWithinAt.comp' {t : Set M'} {g : M' → M''} (x : M)
    (hg : SmoothWithinAt I' I'' g t (f x)) (hf : SmoothWithinAt I I' f s x) :
    SmoothWithinAt I I'' (g ∘ f) (s ∩ f ⁻¹' t) x
-- Mathlib/CategoryTheory/Shift/Basic.lean
theorem shift_shiftFunctorCompIsoId_inv_app (n m : A) (h : n + m = 0) (X : C) :
    ((shiftFunctorCompIsoId C n m h).inv.app X)⟦n⟧' =
    ((shiftFunctorCompIsoId C m n
      (by rw [← neg_eq_of_add_eq_zero_left h, add_right_neg])).inv.app (X⟦n⟧))
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem lookup_replicate {k : α} :
    (replicate n (a,b)).lookup k = if n = 0 then none else if k == a then some b else none
-- Mathlib/Order/PiLex.lean
theorem lex_lt_of_lt_of_preorder [∀ i, Preorder (β i)] {r} (hwf : WellFounded r) {x y : ∀ i, β i}
    (hlt : x < y) : ∃ i, (∀ j, r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i
-- Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean
theorem Gamma_zero_bot : Gamma 0 = ⊥
-- Mathlib/Topology/Compactification/OnePoint.lean
theorem isCompl_range_coe_infty : IsCompl (range ((↑) : X → OnePoint X)) {∞}
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
@[simp]
theorem nat_add_iff : LiouvilleWith p (n + x) ↔ LiouvilleWith p x
-- Mathlib/LinearAlgebra/Prod.lean
@[simp]
theorem comap_fst : p.comap (fst R M M₂) = prod p ⊤
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem div_lt_div_iff (b0 : 0 < b) (d0 : 0 < d) : a / b < c / d ↔ a * d < c * b
-- Mathlib/Data/Finset/Card.lean
lemma cast_card_inter [AddGroupWithOne R] :
    ((s ∩ t).card : R) = s.card + t.card - (s ∪ t).card
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
@[simp]
theorem addValuation.apply {x : ℚ_[p]} (hx : x ≠ 0) :
    Padic.addValuation x = (x.valuation : WithTop ℤ)
-- Mathlib/Data/ENNReal/Real.lean
theorem ofReal_lt_coe_iff {a : ℝ} {b : ℝ≥0} (ha : 0 ≤ a) : ENNReal.ofReal a < b ↔ a < b