ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/Partition/Equipartition.lean
/-- An equipartition of a finset with `n` elements into `k` parts has
`n % k` parts of size `n / k + 1`. -/
theorem IsEquipartition.card_large_parts_eq_mod (hP : P.IsEquipartition) :
    (P.parts.filter fun p ↦ p.card = s.card / P.parts.card + 1).card = s.card % P.parts.card
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[reassoc]
theorem coprod.map_codiag {X Y : C} (f : X ⟶ Y) [HasBinaryCoproduct X X] [HasBinaryCoproduct Y Y] :
    coprod.map f f ≫ codiag Y = codiag X ≫ f
-- Mathlib/RingTheory/Localization/Integral.lean
theorem IsLocalization.scaleRoots_commonDenom_mem_lifts (p : Rₘ[X])
    (hp : p.leadingCoeff ∈ (algebraMap R Rₘ).range) :
    p.scaleRoots (algebraMap R Rₘ <| IsLocalization.commonDenom M p.support p.coeff) ∈
      Polynomial.lifts (algebraMap R Rₘ)
-- Mathlib/LinearAlgebra/AffineSpace/ContinuousAffineEquiv.lean
theorem symm_symm_apply (e : P₁ ≃ᵃL[k] P₂) (x : P₁) : e.symm.symm x = e x
-- Mathlib/RingTheory/Congruence/Basic.lean
/-- The supremum of a set of congruence relations `S` equals the smallest congruence relation
    containing the binary relation 'there exists `c ∈ S` such that `x` is related to `y` by
    `c`'. -/
theorem sSup_eq_ringConGen (S : Set (RingCon R)) :
    sSup S = ringConGen fun x y => ∃ c : RingCon R, c ∈ S ∧ c x y
-- Mathlib/Combinatorics/Quiver/Covering.lean
theorem Prefunctor.isCovering_of_bijective_costar (h : ∀ u, Bijective (φ.costar u)) :
    φ.IsCovering
-- Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
theorem log_natCast_nonneg (n : ℕ) : 0 ≤ log n
-- Mathlib/ModelTheory/Satisfiability.lean
theorem semanticallyEquivalent_not_not : T.SemanticallyEquivalent φ φ.not.not
-- Mathlib/SetTheory/Lists.lean
theorem lt_sizeof_cons' {b} (a : Lists' α b) (l) :
    SizeOf.sizeOf (⟨b, a⟩ : Lists α) < SizeOf.sizeOf (Lists'.cons' a l)
-- Mathlib/Topology/MetricSpace/PiNat.lean
@[simp]
theorem res_length (x : ℕ → α) (n : ℕ) : (res x n).length = n
-- Mathlib/Geometry/Euclidean/Sphere/Basic.lean
/-- The set of points in a sphere is cospherical. -/
theorem Sphere.cospherical (s : Sphere P) : Cospherical (s : Set P)
-- Mathlib/Analysis/Calculus/LHopital.lean
/-- L'Hôpital's rule for approaching -∞, `HasDerivAt` version -/
theorem lhopital_zero_atBot (hff' : ∀ᶠ x in atBot, HasDerivAt f (f' x) x)
    (hgg' : ∀ᶠ x in atBot, HasDerivAt g (g' x) x) (hg' : ∀ᶠ x in atBot, g' x ≠ 0)
    (hfbot : Tendsto f atBot (𝓝 0)) (hgbot : Tendsto g atBot (𝓝 0))
    (hdiv : Tendsto (fun x => f' x / g' x) atBot l) : Tendsto (fun x => f x / g x) atBot l
-- Mathlib/Algebra/Star/StarRingHom.lean
@[simp]
theorem apply_symm_apply (e : A ≃⋆+* B) : ∀ x, e (e.symm x) = x
-- Mathlib/Data/TwoPointing.lean
theorem snd_ne_fst : p.snd ≠ p.fst
-- Mathlib/MeasureTheory/Integral/Average.lean
theorem average_add_measure [IsFiniteMeasure μ] {ν : Measure α} [IsFiniteMeasure ν] {f : α → E}
    (hμ : Integrable f μ) (hν : Integrable f ν) :
    ⨍ x, f x ∂(μ + ν) =
      ((μ univ).toReal / ((μ univ).toReal + (ν univ).toReal)) • ⨍ x, f x ∂μ +
        ((ν univ).toReal / ((μ univ).toReal + (ν univ).toReal)) • ⨍ x, f x ∂ν
-- Mathlib/Analysis/Calculus/Deriv/Inv.lean
theorem derivWithin_div (hc : DifferentiableWithinAt 𝕜 c s x) (hd : DifferentiableWithinAt 𝕜 d s x)
    (hx : d x ≠ 0) (hxs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin (fun x => c x / d x) s x =
      (derivWithin c s x * d x - c x * derivWithin d s x) / d x ^ 2
-- Mathlib/Order/CompleteLattice.lean
lemma biInf_le {ι : Type*} {s : Set ι} (f : ι → α) {i : ι} (hi : i ∈ s) :
    ⨅ i ∈ s, f i ≤ f i
-- Mathlib/Data/Finsupp/Order.lean
theorem support_sup_union_support_inf : (f ⊔ g).support ∪ (f ⊓ g).support = f.support ∪ g.support
-- Mathlib/Data/Real/Irrational.lean
@[simp]
theorem irrational_mul_rat_iff : Irrational (x * q) ↔ q ≠ 0 ∧ Irrational x
-- Mathlib/Order/Filter/Lift.lean
theorem lift_lift'_same_eq_lift' {g : Set α → Set α → Set β} (hg₁ : ∀ s, Monotone fun t => g s t)
    (hg₂ : ∀ t, Monotone fun s => g s t) :
    (f.lift fun s => f.lift' (g s)) = f.lift' fun s => g s s
-- Mathlib/Tactic/Positivity/Core.lean
lemma pos_of_isRat {n : ℤ} {d : ℕ} [LinearOrderedRing A] :
    (NormNum.IsRat e n d) → (decide (0 < n)) → ((0 : A) < (e : A))
-- Mathlib/Data/Finset/Pointwise.lean
theorem div_zero_subset (s : Finset α) : s / 0 ⊆ 0
-- Mathlib/Data/Finsupp/Basic.lean
/-- `Finsupp.mapRange` as an equiv. -/
@[simps apply]
def mapRange.equiv (f : M ≃ N) (hf : f 0 = 0) (hf' : f.symm 0 = 0) : (α →₀ M) ≃ (α →₀ N)
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem coeff_mul_monomial (m) (s : σ →₀ ℕ) (r : R) (p : MvPolynomial σ R) :
    coeff (m + s) (p * monomial s r) = coeff m p * r
-- Mathlib/Analysis/NormedSpace/ENorm.lean
theorem map_sub_le (x y : V) : e (x - y) ≤ e x + e y
-- Mathlib/RingTheory/Ideal/IsPrincipal.lean
theorem associatesEquivIsPrincipal_mul (x y : Associates R) :
    (associatesEquivIsPrincipal R (x * y) : Ideal R) =
      (associatesEquivIsPrincipal R x) * (associatesEquivIsPrincipal R y)
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive]
theorem srange_top_iff_surjective {N} [Mul N] {f : M →ₙ* N} :
    f.srange = (⊤ : Subsemigroup N) ↔ Function.Surjective f
-- Mathlib/Algebra/DirectSum/Decomposition.lean
@[simp]
theorem Decomposition.decompose'_eq : Decomposition.decompose' = decompose ℳ
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem sep_subset (s : Set α) (p : α → Prop) : { x ∈ s | p x } ⊆ s
-- Mathlib/Data/Multiset/Sym.lean
theorem mem_sym2_iff {m : Multiset α} {z : Sym2 α} :
    z ∈ m.sym2 ↔ ∀ y ∈ z, y ∈ m
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
/-- See also `List.zip_replicate` in `Init.Data.List.TakeDrop` for a generalization with different lengths. -/
@[simp] theorem zip_replicate' {a : α} {b : β} {n : Nat} :
    zip (replicate n a) (replicate n b) = replicate n (a, b)
-- Mathlib/MeasureTheory/Measure/GiryMonad.lean
theorem bind_dirac {f : α → Measure β} (hf : Measurable f) (a : α) : bind (dirac a) f = f a
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem aeval_X_left : aeval X = AlgHom.id R (MvPolynomial σ R)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem IsPrefix.isInfix : l₁ <+: l₂ → l₁ <:+: l₂
-- Mathlib/Data/Complex/Basic.lean
theorem mk_eq_add_mul_I (a b : ℝ) : Complex.mk a b = a + b * I
-- Mathlib/Combinatorics/Enumerative/Partition.lean
@[simp] lemma partition_zero_parts (p : Partition 0) : p.parts = 0
-- Mathlib/Data/List/Perm.lean
theorem get_permutations'Aux (s : List α) (x : α) (n : ℕ)
    (hn : n < length (permutations'Aux x s)) :
    (permutations'Aux x s).get ⟨n, hn⟩ = s.insertNth n x
-- Mathlib/Algebra/Group/Subgroup/ZPowers.lean
theorem ofMul_image_zpowers_eq_zmultiples_ofMul {x : G} :
    Additive.ofMul '' (Subgroup.zpowers x : Set G) = AddSubgroup.zmultiples (Additive.ofMul x)
-- Mathlib/Topology/Constructions.lean
@[continuity]
theorem continuous_uLift_up [TopologicalSpace X] : Continuous (ULift.up : X → ULift.{v, u} X)
-- Mathlib/Analysis/Calculus/FDeriv/Extend.lean
/-- If a real function `f` has a derivative `g` everywhere but at a point, and `f` and `g` are
continuous at this point, then `g` is the derivative of `f` everywhere. -/
theorem hasDerivAt_of_hasDerivAt_of_ne' {f g : ℝ → E} {x : ℝ}
    (f_diff : ∀ y ≠ x, HasDerivAt f (g y) y) (hf : ContinuousAt f x)
    (hg : ContinuousAt g x) (y : ℝ) : HasDerivAt f (g y) y
-- Mathlib/Data/Multiset/Fintype.lean
@[simp]
theorem Multiset.toEnumFinset_subset_iff {m₁ m₂ : Multiset α} :
    m₁.toEnumFinset ⊆ m₂.toEnumFinset ↔ m₁ ≤ m₂
-- Mathlib/Tactic/NormNum/Basic.lean
theorem eq_of_false {a b : Prop} (ha : ¬a) (hb : ¬b) : a = b
-- Mathlib/Order/Bounds/OrderIso.lean
@[simp]
theorem isGLB_preimage {s : Set β} {x : α} : IsGLB (f ⁻¹' s) x ↔ IsGLB s (f x)
-- Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean
/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
compactly-supported function `u` on a normed space `E` of finite dimension `n ≥ 2`, equipped
with Haar measure. Then the Lebesgue integral of the pointwise expression
`|u x| ^ (n / (n - 1))` is bounded above by a constant times the `n / (n - 1)`-th power of the
Lebesgue integral of the Fréchet derivative of `u`. -/
theorem lintegral_pow_le_pow_lintegral_fderiv {u : E → F}
    (hu : ContDiff ℝ 1 u) (h2u : HasCompactSupport u)
    {p : ℝ} (hp : Real.IsConjExponent (finrank ℝ E) p) :
    ∫⁻ x, (‖u x‖₊ : ℝ≥0∞) ^ p ∂μ ≤
    lintegralPowLePowLIntegralFDerivConst μ p * (∫⁻ x, ‖fderiv ℝ u x‖₊ ∂μ) ^ p
-- Mathlib/Topology/Maps/Basic.lean
theorem preimage_closure_eq_closure_preimage (hf : IsOpenMap f) (hfc : Continuous f) (s : Set Y) :
    f ⁻¹' closure s = closure (f ⁻¹' s)
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem relMap_sum_inl {n : ℕ} (R : L₁.Relations n) :
    @RelMap (L₁.sum L₂) S _ n (Sum.inl R) = RelMap R
-- Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean
theorem superpolynomialDecay_iff_isLittleO (hk : Tendsto k l atTop) :
    SuperpolynomialDecay l k f ↔ ∀ z : ℤ, f =o[l] fun a : α => k a ^ z
-- Mathlib/Probability/Kernel/Composition.lean
@[simp]
lemma fst_swapRight (κ : Kernel α (β × γ)) : fst (swapRight κ) = snd κ
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem iInter_of_empty [IsEmpty ι] (s : ι → Set α) : ⋂ i, s i = univ
-- Mathlib/Data/Nat/Factorial/SuperFactorial.lean
theorem superFactorial_succ (n : ℕ) : (sf n.succ) = (n + 1)! * sf n
-- Mathlib/Logic/Embedding/Set.lean
/-- Embedding into `WithTop α`. -/
@[simps]
def coeWithTop {α} : α ↪ WithTop α
-- Mathlib/Topology/Order/IsLUB.lean
theorem IsGLB.frequently_nhds_mem {a : α} {s : Set α} (ha : IsGLB s a) (hs : s.Nonempty) :
    ∃ᶠ x in 𝓝 a, x ∈ s
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem map_mono (h : m₁ ≤ m₂) : m₁.map f ≤ m₂.map f
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
theorem ext' {a b : SimplexCategory} (f g : SimplexCategory.Hom a b) :
    f.toOrderHom = g.toOrderHom → f = g
-- Mathlib/Data/Set/Function.lean
@[simp]
theorem pi_piecewise {ι : Type*} {α : ι → Type*} (s s' : Set ι) (t t' : ∀ i, Set (α i))
    [∀ x, Decidable (x ∈ s')] : pi s (s'.piecewise t t') = pi (s ∩ s') t ∩ pi (s \ s') t'
-- Mathlib/LinearAlgebra/Matrix/Circulant.lean
/-- The product of two circulant matrices `circulant v` and `circulant w` is
    the circulant matrix generated by `circulant v *ᵥ w`. -/
theorem circulant_mul [Semiring α] [Fintype n] [AddGroup n] (v w : n → α) :
    circulant v * circulant w = circulant (circulant v *ᵥ w)
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem singleton_span_mem_normalizedFactors_of_mem_normalizedFactors [NormalizationMonoid R]
    {a b : R} (ha : a ∈ normalizedFactors b) :
    Ideal.span ({a} : Set R) ∈ normalizedFactors (Ideal.span ({b} : Set R))
-- Mathlib/Algebra/Algebra/Unitization.lean
lemma _root_.IsSelfAdjoint.inr (ha : IsSelfAdjoint a) : IsSelfAdjoint (a : Unitization R A)
-- Mathlib/CategoryTheory/Sites/Sieves.lean
theorem ofArrows_surj {ι : Type*} {Y : ι → C} (f : ∀ i, Y i ⟶ X) {Z : C} (g : Z ⟶ X)
    (hg : ofArrows Y f g) : ∃ (i : ι) (h : Y i = Z),
    g = eqToHom h.symm ≫ f i
-- Mathlib/Algebra/Homology/ShortComplex/ModuleCat.lean
lemma Exact.moduleCat_of_range_eq_ker {X₁ X₂ X₃ : ModuleCat.{v} R}
    (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃) (hfg : LinearMap.range f = LinearMap.ker g) :
    (moduleCatMkOfKerLERange f g (by rw [hfg])).Exact
-- Mathlib/SetTheory/Lists.lean
theorem equiv_atom {a} {l : Lists α} : atom a ~ l ↔ atom a = l
-- Mathlib/Algebra/Quaternion.lean
nonrec theorem star_add_self' : star a + a = ↑(2 * a.re)
-- Mathlib/RingTheory/Noetherian.lean
theorem isNoetherianRing_of_surjective (R) [Ring R] (S) [Ring S] (f : R →+* S)
    (hf : Function.Surjective f) [H : IsNoetherianRing R] : IsNoetherianRing S
-- Mathlib/Topology/DiscreteQuotient.lean
theorem trans (x y z : X) : S.Rel x y → S.Rel y z → S.Rel x z
-- Mathlib/Data/PFun.lean
@[simp]
theorem fn_apply (f : α →. β) (a : α) : f.fn a = (f a).get
-- Mathlib/Topology/FiberBundle/Constructions.lean
theorem Pullback.continuous_proj (f : B' → B) : Continuous (π F (f *ᵖ E))
-- Mathlib/Data/Finset/Card.lean
theorem pred_card_le_card_erase : s.card - 1 ≤ (s.erase a).card
-- Mathlib/Data/Seq/Computation.lean
theorem terminates_iff (s : Computation α) : Terminates s ↔ ∃ a, a ∈ s
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
theorem image_range_orderOf [DecidableEq G] :
    Finset.image (fun i => x ^ i) (Finset.range (orderOf x)) = (zpowers x : Set G).toFinset
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
@[simp]
lemma variableChange_Δ : (W.variableChange C).Δ = C.u⁻¹ ^ 12 * W.Δ
-- Mathlib/Data/DFinsupp/Interval.lean
@[simp]
theorem card_dfinsupp (s : Finset ι) (t : ∀ i, Finset (α i)) :
    (s.dfinsupp t).card = ∏ i ∈ s, (t i).card
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
@[simp]
theorem arg_I : arg I = π / 2
-- Mathlib/NumberTheory/NumberField/Basic.lean
theorem mem_span_integralBasis {x : K} :
    x ∈ Submodule.span ℤ (Set.range (integralBasis K)) ↔ x ∈ (algebraMap (𝓞 K) K).range
-- Mathlib/RingTheory/Ideal/Basic.lean
/-- Krull's theorem: a nontrivial ring has a maximal ideal. -/
theorem exists_maximal [Nontrivial α] : ∃ M : Ideal α, M.IsMaximal
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean
theorem continuous_comp {γ} [TopologicalSpace γ] {f : α → β} {g : β → γ} (hg : Continuous g)
    (hf : AEStronglyMeasurable' m f μ) : AEStronglyMeasurable' m (g ∘ f) μ
-- Mathlib/Analysis/CstarAlgebra/Multiplier.lean
theorem natCast_snd (n : ℕ) : (n : 𝓜(𝕜, A)).snd = n
-- Mathlib/Data/List/ToFinsupp.lean
theorem toFinsupp_concat_eq_toFinsupp_add_single {R : Type*} [AddZeroClass R] (x : R) (xs : List R)
    [DecidablePred fun i => getD (xs ++ [x]) i 0 ≠ 0] [DecidablePred fun i => getD xs i 0 ≠ 0] :
    toFinsupp (xs ++ [x]) = toFinsupp xs + Finsupp.single xs.length x
-- Mathlib/Order/Basic.lean
theorem le_or_lt [LinearOrder α] {a b : α} (h : a ≤ b) (c : α) : a ≤ c ∨ c < b
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
/-- A left homology map data for a morphism of short complexes induces
a right homology map data in the opposite category. -/
@[simps]
def LeftHomologyMapData.op {S₁ S₂ : ShortComplex C} {φ : S₁ ⟶ S₂}
    {h₁ : S₁.LeftHomologyData} {h₂ : S₂.LeftHomologyData}
    (ψ : LeftHomologyMapData φ h₁ h₂) : RightHomologyMapData (opMap φ) h₂.op h₁.op
-- Mathlib/Algebra/Associated/Basic.lean
theorem associated_unit_mul_right {β : Type*} [CommMonoid β] (a u : β) (hu : IsUnit u) :
    Associated a (u * a)
-- Mathlib/CategoryTheory/Sites/LocallySurjective.lean
lemma isLocallySurjective_iff_epi {F G : Sheaf J (Type w)} (φ : F ⟶ G)
    [HasSheafify J (Type w)] :
    IsLocallySurjective φ ↔ Epi φ
-- Mathlib/Data/Nat/Factors.lean
theorem four_dvd_or_exists_odd_prime_and_dvd_of_two_lt {n : ℕ} (n2 : 2 < n) :
    4 ∣ n ∨ ∃ p, Prime p ∧ p ∣ n ∧ Odd p
-- Mathlib/Geometry/Manifold/PartitionOfUnity.lean
theorem contMDiff_smul {g : M → F} {i} (hg : ∀ x ∈ tsupport (f i), ContMDiffAt I 𝓘(ℝ, F) n g x) :
    ContMDiff I 𝓘(ℝ, F) n fun x => f i x • g x
-- Mathlib/Probability/Process/Filtration.lean
theorem stronglyMeasurable_limit_process' : StronglyMeasurable[m] (limitProcess f ℱ μ)
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem _root_.Equiv.Perm.prod_comp' (σ : Equiv.Perm α) (s : Finset α) (f : α → α → β)
    (hs : { a | σ a ≠ a } ⊆ s) : (∏ x ∈ s, f (σ x) x) = ∏ x ∈ s, f x (σ.symm x)
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem snd_hnot [HNot α] [HNot β] (a : α × β) : (￢a).2 = ￢a.2
-- Mathlib/CategoryTheory/Functor/FullyFaithful.lean
/-- Structure containing the data of inverse map `(F.obj X ⟶ F.obj Y) ⟶ (X ⟶ Y)` of `F.map`
in order to express that `F` is a fully faithful functor. -/
structure FullyFaithful where
  /-- The inverse map `(F.obj X ⟶ F.obj Y) ⟶ (X ⟶ Y)` of `F.map`. -/
  preimage {X Y : C} (f : F.obj X ⟶ F.obj Y) : X ⟶ Y
  map_preimage {X Y : C} (f : F.obj X ⟶ F.obj Y) : F.map (preimage f) = f := by aesop_cat
  preimage_map {X Y : C} (f : X ⟶ Y) : preimage (F.map f) = f := by aesop_cat
-- Mathlib/FieldTheory/Adjoin.lean
@[simp]
theorem AdjoinSimple.isIntegral_gen : IsIntegral F (AdjoinSimple.gen F α) ↔ IsIntegral F α
-- Mathlib/CategoryTheory/Opposites.lean
@[simp]
theorem op_inv {X Y : C} (f : X ⟶ Y) [IsIso f] : (inv f).op = inv f.op
-- Mathlib/GroupTheory/Perm/Basic.lean
@[simp]
theorem ofSubtype_apply_coe (f : Perm (Subtype p)) (x : Subtype p) : ofSubtype f x = f x
-- Mathlib/Analysis/BoxIntegral/Partition/Filter.lean
theorem hasBasis_toFilteriUnion_top (l : IntegrationParams) (I : Box ι) :
    (l.toFilteriUnion I ⊤).HasBasis (fun r : ℝ≥0 → (ι → ℝ) → Ioi (0 : ℝ) => ∀ c, l.RCond (r c))
      fun r => { π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.IsPartition }
-- Mathlib/CategoryTheory/Subobject/Lattice.lean
theorem bot_eq_initial_to {B : C} : (⊥ : Subobject B) = Subobject.mk (initial.to B)
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive]
theorem edist_eq_coe_nnnorm_div (a b : E) : edist a b = ‖a / b‖₊
-- Mathlib/Data/Finsupp/Basic.lean
theorem mapDomain_finset_sum {f : α → β} {s : Finset ι} {v : ι → α →₀ M} :
    mapDomain f (∑ i ∈ s, v i) = ∑ i ∈ s, mapDomain f (v i)
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
theorem fromSpec_primeIdealOf (x : U) :
    hU.fromSpec.val.base (hU.primeIdealOf x) = x.1
-- Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean
theorem of_gt {M} [CanonicallyOrderedAddCommMonoid M] {x y : M} (h : x < y) : NeZero y
-- Mathlib/Logic/Basic.lean
theorem dite_prop_iff_and {Q : P → Prop} {R : ¬P → Prop} [Decidable P] :
    dite P Q R ↔ (∀ h, Q h) ∧ (∀ h, R h)
-- Mathlib/Algebra/AddConstMap/Basic.lean
@[simp] theorem mk_coe (f : G →+c[a, b] H) : mk f f.2 = f
-- Mathlib/Algebra/Order/Kleene.lean
theorem add_le_iff : a + b ≤ c ↔ a ≤ c ∧ b ≤ c
-- Mathlib/Analysis/SpecialFunctions/Complex/Log.lean
theorem tendsto_log_nhdsWithin_im_nonneg_of_re_neg_of_im_zero {z : ℂ} (hre : z.re < 0)
    (him : z.im = 0) : Tendsto log (𝓝[{ z : ℂ | 0 ≤ z.im }] z) (𝓝 <| Real.log (abs z) + π * I)
-- Mathlib/Topology/Constructions.lean
theorem ULift.isOpen_iff [TopologicalSpace X] {s : Set (ULift.{v} X)} :
    IsOpen s ↔ IsOpen (ULift.up ⁻¹' s)
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The `vectorSpan` of an indexed family is the span of the pairwise subtractions with a given
point on the left, excluding the subtraction of that point from itself. -/
theorem vectorSpan_range_eq_span_range_vsub_left_ne (p : ι → P) (i₀ : ι) :
    vectorSpan k (Set.range p) =
      Submodule.span k (Set.range fun i : { x // x ≠ i₀ } => p i₀ -ᵥ p i)
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem comp_eval₂Hom [CommSemiring S₂] (f : R →+* S₁) (g : σ → S₁) (φ : S₁ →+* S₂) :
    φ.comp (eval₂Hom f g) = eval₂Hom (φ.comp f) fun i => φ (g i)
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Expand.lean
/-- If `Irreducible (cyclotomic (p ^ n) R)` then `Irreducible (cyclotomic p R).` -/
theorem cyclotomic_irreducible_of_irreducible_pow {p : ℕ} (hp : Nat.Prime p) {R} [CommRing R]
    [IsDomain R] {n : ℕ} (hn : n ≠ 0) (h : Irreducible (cyclotomic (p ^ n) R)) :
    Irreducible (cyclotomic p R)
-- Mathlib/Topology/Inseparable.lean
lemma stableUnderSpecialization_univ : StableUnderSpecialization (univ : Set X)
-- Mathlib/Data/Real/Sqrt.lean
theorem sqrt_eq_zero' : √x = 0 ↔ x ≤ 0
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem coe_coeEmb : ⇑(coeEmb : Finset α ↪o Set α) = ((↑) : Finset α → Set α)
-- Mathlib/CategoryTheory/Limits/Preserves/Ulift.lean
lemma iUnion_descSet_singleton : ⋃ x : lc.pt, descSet hc {x} = Set.univ
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
theorem iUnion_Iic_eq_Iio_of_lt_of_tendsto (x : R) {as : ι → R} (lt_x : ∀ i, as i < x)
    {F : Filter ι} [Filter.NeBot F] (as_lim : Filter.Tendsto as F (𝓝 x)) :
    ⋃ i : ι, Iic (as i) = Iio x
-- Mathlib/Topology/Instances/ENNReal.lean
theorem summable_toNNReal_of_tsum_ne_top {α : Type*} {f : α → ℝ≥0∞} (hf : ∑' i, f i ≠ ∞) :
    Summable (ENNReal.toNNReal ∘ f)
-- Mathlib/Computability/TMToPartrec.lean
theorem trStmts₁_supports' {S q K} (H₁ : (q : Λ').Supports S) (H₂ : trStmts₁ q ∪ K ⊆ S)
    (H₃ : K ⊆ S → Supports K S) : Supports (trStmts₁ q ∪ K) S
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
@[simp]
theorem toMeasure_comp_toFiniteMeasure_eq_toMeasure (ν : ProbabilityMeasure Ω) :
    (ν.toFiniteMeasure : Measure Ω) = (ν : Measure Ω)
-- Mathlib/MeasureTheory/Group/Measure.lean
@[to_additive (attr := simp)]
lemma measure_mul_closure_one (s : Set G) (μ : Measure G) :
    μ (s * (closure {1} : Set G)) = μ s
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[simp]
theorem piecewise_univ (f g : α →ₛ β) : piecewise univ MeasurableSet.univ f g = f
-- Mathlib/FieldTheory/IntermediateField.lean
/-- An intermediate field is closed under inverses. -/
protected theorem inv_mem {x : L} : x ∈ S → x⁻¹ ∈ S
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp, norm_cast]
theorem coe_smul (c : R) (f : P1 →ᵃ[k] V2) : ⇑(c • f) = c • ⇑f
-- Mathlib/Data/Multiset/Lattice.lean
@[simp]
theorem inf_coe (l : List α) : inf (l : Multiset α) = l.foldr (· ⊓ ·) ⊤
-- Mathlib/Algebra/Star/StarRingHom.lean
@[simp]
theorem mk_coe (e : A ≃⋆+* B) (e' h₁ h₂ h₃ h₄ h₅) :
    (⟨⟨⟨e, e', h₁, h₂⟩, h₃, h₄⟩, h₅⟩ : A ≃⋆+* B) = e
-- Mathlib/Data/Int/GCD.lean
theorem lcm_def (i j : ℤ) : lcm i j = Nat.lcm (natAbs i) (natAbs j)
-- .lake/packages/batteries/Batteries/Data/Nat/Lemmas.lean
theorem recDiag_succ_zero {motive : Nat → Nat → Sort _} (zero_zero : motive 0 0)
    (zero_succ : ∀ n, motive 0 n → motive 0 (n+1)) (succ_zero : ∀ m, motive m 0 → motive (m+1) 0)
    (succ_succ : ∀ m n, motive m n → motive (m+1) (n+1)) (m) :
    Nat.recDiag zero_zero zero_succ succ_zero succ_succ (m+1) 0
      = succ_zero m (Nat.recDiag zero_zero zero_succ succ_zero succ_succ m 0)
-- Mathlib/Order/JordanHolder.lean
theorem eq_of_head_eq_head_of_last_eq_last_of_length_eq_zero {s₁ s₂ : CompositionSeries X}
    (hb : s₁.head = s₂.head) (ht : s₁.last = s₂.last) (hs₁0 : s₁.length = 0) : s₁ = s₂
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem HasFDerivAt.mul_const' (ha : HasFDerivAt a a' x) (b : 𝔸) :
    HasFDerivAt (fun y => a y * b) (a'.smulRight b) x
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem coeff_injective : Injective (coeff : R[X] → ℕ → R)
-- Mathlib/CategoryTheory/Idempotents/FunctorCategories.lean
@[reassoc (attr := simp)]
theorem app_comp_p : f.f.app X ≫ Q.p.app X = f.f.app X
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem ContDiffAt.sum {ι : Type*} {f : ι → E → F} {s : Finset ι} {x : E}
    (h : ∀ i ∈ s, ContDiffAt 𝕜 n (fun x => f i x) x) :
    ContDiffAt 𝕜 n (fun x => ∑ i ∈ s, f i x) x
-- Mathlib/Analysis/Analytic/Basic.lean
/-- If a function `f` is analytic on a set `s` and `g` is linear, then `g ∘ f` is analytic
on `s`. -/
theorem ContinuousLinearMap.comp_analyticOn {s : Set E} (g : F →L[𝕜] G) (h : AnalyticOn 𝕜 f s) :
    AnalyticOn 𝕜 (g ∘ f) s
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem IsNormal.blsub_eq {f : Ordinal.{u} → Ordinal.{max u v}} (H : IsNormal f) {o : Ordinal.{u}}
    (h : IsLimit o) : (blsub.{_, v} o fun x _ => f x) = f o
-- Mathlib/Geometry/RingedSpace/PresheafedSpace.lean
theorem Γ_obj_op (X : PresheafedSpace C) : Γ.obj (op X) = X.presheaf.obj (op ⊤)
-- Mathlib/Algebra/Category/Grp/EpiMono.lean
theorem τ_symm_apply_infinity :
    Equiv.symm τ ∞ = fromCoset ⟨f.range, 1, one_leftCoset _⟩
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem Mem.congr_right : ∀ {x y : PSet.{u}}, Equiv x y → ∀ {w : PSet.{u}}, w ∈ x ↔ w ∈ y
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem eq_false_and_eq_true_self : ∀(b : Bool), (b = false ∧ b = true) ↔ False
-- Mathlib/Analysis/Convex/Basic.lean
theorem Convex.vadd (hs : Convex 𝕜 s) (z : E) : Convex 𝕜 (z +ᵥ s)
-- Mathlib/Algebra/Algebra/Unitization.lean
@[simp]
theorem fst_smul [SMul S R] [SMul S A] (s : S) (x : Unitization R A) : (s • x).fst = s • x.fst
-- Mathlib/RingTheory/Nakayama.lean
lemma top_ne_set_smul_of_subset_jacobson_annihilator [Nontrivial M]
    [Module.Finite R M] {s : Set R}
    (h : s ⊆ (Module.annihilator R M).jacobson) :
    (⊤ : Submodule R M) ≠ s • ⊤
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[deprecated getElem?_take (since := "2024-06-12")]
theorem get?_take {l : List α} {n m : Nat} (h : m < n) : (l.take n).get? m = l.get? m
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] protected theorem one_mul (x : BitVec w) : 1#w * x = x