ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
theorem quotientMap_mk {J : Ideal R} {I : Ideal S} {f : R →+* S} {H : J ≤ I.comap f} {x : R} :
    quotientMap I f H (Quotient.mk J x) = Quotient.mk I (f x)
-- Mathlib/Algebra/Algebra/Basic.lean
theorem algebraMap_ofSubring_apply {R : Type*} [CommRing R] (S : Subring R) (x : S) :
    algebraMap S R x = x
-- Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean
@[to_additive (attr := simp)]
lemma nndist_unop (x y : αᵐᵒᵖ) : nndist (unop x) (unop y) = nndist x y
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
/-- When `r < w`, we give a formula for `(x.rotateRight r).getLsb i`. -/
theorem getLsb_rotateRight_of_le {x : BitVec w} {r i : Nat} (hr: r < w) :
    (x.rotateRight r).getLsb i =
      cond (i < w - r)
      (x.getLsb (r + i))
      (decide (i < w) && x.getLsb (i - (w - r)))
-- Mathlib/CategoryTheory/Limits/VanKampen.lean
theorem NatTrans.Equifibered.whiskerLeft {K : Type*} [Category K]  {F G : J ⥤ C} {α : F ⟶ G}
    (hα : Equifibered α) (H : K ⥤ J) : Equifibered (whiskerLeft H α)
-- Mathlib/Algebra/Order/Ring/Basic.lean
@[simp]
lemma pow_left_inj (ha : 0 ≤ a) (hb : 0 ≤ b) (hn : n ≠ 0) : a ^ n = b ^ n ↔ a = b
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
@[simp]
lemma rightHomologyMap'_neg :
    rightHomologyMap' (-φ) h₁ h₂ = -rightHomologyMap' φ h₁ h₂
-- Mathlib/Order/Interval/Set/OrdConnectedComponent.lean
@[simp]
theorem ordConnectedComponent_eq_empty : ordConnectedComponent s x = ∅ ↔ x ∉ s
-- Mathlib/Data/Finset/Union.lean
lemma biUnion_subset {s' : Finset β} : s.biUnion t ⊆ s' ↔ ∀ x ∈ s, t x ⊆ s'
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
@[simp] theorem add_byteIdx (p₁ p₂ : Pos) : (p₁ + p₂).byteIdx = p₁.byteIdx + p₂.byteIdx
-- Mathlib/NumberTheory/Padics/PadicVal.lean
/-- **Legendre's Theorem**

Taking (`p - 1`) times the `p`-adic valuation of `n!` equals `n` minus the sum of base `p` digits
of `n`. -/
theorem sub_one_mul_padicValNat_factorial [hp : Fact p.Prime] (n : ℕ) :
    (p - 1) * padicValNat p (n !) = n - (p.digits n).sum
-- Mathlib/Topology/Category/Sequential.lean
/-- The type sequential topological spaces. -/
structure Sequential where
  /-- The underlying topological space of an object of `Sequential`. -/
  toTop : TopCat.{u}
  /-- The underlying topological space is sequential. -/
  [is_sequential : SequentialSpace toTop]
-- Mathlib/Order/ConditionallyCompleteLattice/Finset.lean
theorem Finset.Nonempty.csSup_mem {s : Finset α} (h : s.Nonempty) : sSup (s : Set α) ∈ s
-- Mathlib/Algebra/Module/Submodule/EqLocus.lean
@[simp]
theorem mem_eqLocus {x : M} {f g : F} : x ∈ eqLocus f g ↔ f x = g x
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem snd_linear : (snd : P1 × P2 →ᵃ[k] P2).linear = LinearMap.snd k V1 V2
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
theorem mulVec_surjective_iff_isUnit {A : Matrix m m R} :
    Function.Surjective A.mulVec ↔ IsUnit A
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- A `weightedVSub` with sum of weights 0 is in the `vectorSpan` of
an indexed family. -/
theorem weightedVSub_mem_vectorSpan {s : Finset ι} {w : ι → k} (h : ∑ i ∈ s, w i = 0)
    (p : ι → P) : s.weightedVSub p w ∈ vectorSpan k (Set.range p)
-- Mathlib/Data/Matroid/Basic.lean
/-- A `Finitary` matroid is one where a set is independent if and only if it all
  its finite subsets are independent, or equivalently a matroid whose circuits are finite. -/
class Finitary (M : Matroid α) : Prop where
  /-- `I` is independent if all its finite subsets are independent. -/
  indep_of_forall_finite : ∀ I, (∀ J, J ⊆ I → J.Finite → M.Indep J) → M.Indep I
-- Mathlib/Topology/TietzeExtension.lean
/-- **Tietze extension theorem** for `TietzeExtension` spaces. Let `e` be a closed embedding of a
nonempty topological space `X₁` into a normal topological space `X`. Let `f` be a continuous
function on `X₁` with values in a `TietzeExtension` space `Y`. Then there exists a
continuous function `g : C(X, Y)` such that `g ∘ e = f`. -/
theorem ContinuousMap.exists_extension (f : C(X₁, Y)) :
    ∃ (g : C(X, Y)), g.comp ⟨e, he.continuous⟩ = f
-- Mathlib/LinearAlgebra/Matrix/Transvection.lean
/-- Multiplying by all the matrices in `listTransvecRow M` kills all the coefficients in the
last row but the last one. -/
theorem mul_listTransvecRow_last_row (hM : M (inr unit) (inr unit) ≠ 0) (i : Fin r) :
    (M * (listTransvecRow M).prod) (inr unit) (inl i) = 0
-- Mathlib/Data/Nat/Squarefree.lean
theorem sq_mul_squarefree_of_pos' {n : ℕ} (h : 0 < n) :
    ∃ a b : ℕ, (b + 1) ^ 2 * (a + 1) = n ∧ Squarefree (a + 1)
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
theorem HasDerivAt.comp_hasDerivWithinAt_of_eq (hh₂ : HasDerivAt h₂ h₂' y)
    (hh : HasDerivWithinAt h h' s x) (hy : y = h x) :
    HasDerivWithinAt (h₂ ∘ h) (h₂' * h') s x
-- Mathlib/Data/Finset/Pi.lean
@[simp]
theorem pi_empty {t : ∀ a : α, Finset (β a)} : pi (∅ : Finset α) t = singleton (Pi.empty β)
-- Mathlib/Algebra/Module/LocalizedModule.lean
theorem mul_smul' {A : Type*} [Semiring A] [Algebra R A] (x : T) (p₁ p₂ : LocalizedModule S A) :
    p₁ * x • p₂ = x • (p₁ * p₂)
-- Mathlib/RingTheory/GradedAlgebra/Radical.lean
@[simp]
theorem HomogeneousIdeal.coe_radical (I : HomogeneousIdeal 𝒜) :
    I.radical.toIdeal = I.toIdeal.radical
-- Mathlib/Data/Num/Lemmas.lean
@[simp, norm_cast]
theorem mul_to_int : ∀ m n, ((m * n : ZNum) : ℤ) = m * n
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem comap_normalizer_eq_of_injective_of_le_range {N : Type*} [Group N] (H : Subgroup G)
    {f : N →* G} (hf : Function.Injective f) (h : H.normalizer ≤ f.range) :
    comap f H.normalizer = (comap f H).normalizer
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem zero_eq : vectorsProdEqOne G 0 = {Vector.nil}
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
protected theorem LocallyIntegrableOn.sub
    (hf : LocallyIntegrableOn f s μ) (hg : LocallyIntegrableOn g s μ) :
    LocallyIntegrableOn (f - g) s μ
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
@[simp]
theorem DifferentiableAt.csinh (hc : DifferentiableAt ℂ f x) :
    DifferentiableAt ℂ (fun x => Complex.sinh (f x)) x
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem tensorTensorTensorComm_symm :
    (tensorTensorTensorComm R M N P Q).symm = tensorTensorTensorComm R M P N Q
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem toFinsupp_monomial (n : ℕ) (r : R) : (monomial n r).toFinsupp = Finsupp.single n r
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[simp]
theorem AwayMap.lift_eq (hg : IsUnit (g x)) (a : M) : F.lift x hg (F.toMap a) = g a
-- Mathlib/LinearAlgebra/Semisimple.lean
theorem IsSemisimple.of_mem_adjoin_singleton {a : End K M}
    (ha : a ∈ Algebra.adjoin K {f}) : a.IsSemisimple
-- Mathlib/Analysis/SpecificLimits/Basic.lean
theorem hasSum_geometric_two : HasSum (fun n : ℕ ↦ ((1 : ℝ) / 2) ^ n) 2
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem csSup_image2_eq_csInf_csInf (h₁ : ∀ b, GaloisConnection (swap l b ∘ ofDual) (toDual ∘ u₁ b))
    (h₂ : ∀ a, GaloisConnection (l a ∘ ofDual) (toDual ∘ u₂ a)) :
    s.Nonempty → BddBelow s → t.Nonempty → BddBelow t → sSup (image2 l s t) = l (sInf s) (sInf t)
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
lemma count_attach (a : {x // x ∈ s}) : s.attach.count a = s.count ↑a
-- Mathlib/Order/Bounds/Basic.lean
@[simp] theorem isGLB_empty_iff : IsGLB ∅ a ↔ IsTop a
-- Mathlib/NumberTheory/MulChar/Basic.lean
/-- The inverse of a multiplicative character `χ`, applied to `a`, is the inverse of `χ a`. -/
theorem inv_apply_eq_inv (χ : MulChar R R') (a : R) : χ⁻¹ a = Ring.inverse (χ a)
-- Mathlib/Topology/Order.lean
theorem isClosed_induced_iff [t : TopologicalSpace β] {s : Set α} {f : α → β} :
    IsClosed[t.induced f] s ↔ ∃ t, IsClosed t ∧ f ⁻¹' t = s
-- Mathlib/RingTheory/PrimeSpectrum.lean
theorem zeroLocus_empty_iff_eq_top {I : Ideal R} : zeroLocus (I : Set R) = ∅ ↔ I = ⊤
-- Mathlib/Order/Filter/AtTopBot.lean
theorem frequently_atTop [SemilatticeSup α] [Nonempty α] {p : α → Prop} :
    (∃ᶠ x in atTop, p x) ↔ ∀ a, ∃ b ≥ a, p b
-- Mathlib/RepresentationTheory/Action/Basic.lean
/-- The composition of two `Action V G` homomorphisms is the composition of the underlying maps.
-/
@[simps]
def comp {M N K : Action V G} (p : Action.Hom M N) (q : Action.Hom N K) : Action.Hom M K
-- Mathlib/Algebra/Group/Commute/Basic.lean
@[to_additive (attr := simp)]
lemma zpow_right (h : Commute a b) (m : ℤ) : Commute a (b ^ m)
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem ContMDiff.contMDiffAt (h : ContMDiff I I' n f) : ContMDiffAt I I' n f x
-- Mathlib/CategoryTheory/Comma/Arrow.lean
/-- The functor sending an arrow to its target. -/
@[simps!]
def rightFunc : Arrow C ⥤ C
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- The minimal distance to a set (as `ℝ≥0`) is continuous in point -/
theorem continuous_infNndist_pt (s : Set α) : Continuous fun x => infNndist x s
-- Mathlib/Algebra/PUnitInstances/Algebra.lean
@[to_additive (attr := simp)]
theorem inv_eq {x : PUnit} : x⁻¹ = unit
-- Mathlib/Data/List/AList.lean
@[simp]
theorem union_empty {s : AList β} : s ∪ (∅ : AList β) = s
-- Mathlib/Algebra/Ring/BooleanRing.lean
theorem inf_assoc (a b c : α) : a ⊓ b ⊓ c = a ⊓ (b ⊓ c)
-- Mathlib/Algebra/Order/Field/Power.lean
theorem zpow_strictAnti (h₀ : 0 < a) (h₁ : a < 1) : StrictAnti (a ^ · : ℤ → α)
-- Mathlib/Order/Monotone/Basic.lean
@[simp]
theorem strictAntiOn_comp_ofDual_iff : StrictAntiOn (f ∘ ofDual) s ↔ StrictMonoOn f s
-- Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean
@[simp]
theorem integral_Ioi_inv_one_add_sq {i : ℝ} :
    ∫ (x : ℝ) in Set.Ioi i, (1 + x ^ 2)⁻¹ = (π / 2) - arctan i
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive]
theorem invRev_bijective : Function.Bijective (@invRev α)
-- Mathlib/Data/Ordmap/Ordset.lean
theorem rotateL_node (l : Ordnode α) (x : α) (sz : ℕ) (m : Ordnode α) (y : α) (r : Ordnode α) :
    rotateL l x (node sz m y r) =
      if size m < ratio * size r then node3L l x m y r else node4L l x m y r
-- Mathlib/RingTheory/Polynomial/Basic.lean
@[simp]
theorem degree_restriction {p : R[X]} : (restriction p).degree = p.degree
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
@[simp]
theorem flip_isRefl_iff : B.flip.IsRefl ↔ B.IsRefl
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem lid_tmul (m : M) (r : R) : (TensorProduct.lid R M : R ⊗ M → M) (r ⊗ₜ m) = r • m
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
/-- The bottom submodule is linearly equivalent to punit as an `R`-module. -/
@[simps]
def botEquivPUnit : (⊥ : Submodule R M) ≃ₗ[R] PUnit.{v+1}
-- Mathlib/Algebra/Category/Grp/EpiMono.lean
@[to_additive]
theorem epi_iff_range_eq_top : Epi f ↔ f.range = ⊤
-- Mathlib/Data/Nat/Bitwise.lean
theorem xor_cancel_right (n m : ℕ) : (m ^^^ n) ^^^ n = m
-- Mathlib/Order/Heyting/Basic.lean
theorem le_sup_sdiff : a ≤ b ⊔ a \ b
-- Mathlib/LinearAlgebra/Determinant.lean
@[simp]
theorem det_comp (f g : M →ₗ[A] M) :
    LinearMap.det (f.comp g) = LinearMap.det f * LinearMap.det g
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- The product of two strictly antitone functions is strictly antitone. -/
@[to_additive add "The sum of two strictly antitone functions is strictly antitone."]
theorem StrictAntiOn.mul' [CovariantClass α α (· * ·) (· < ·)]
    [CovariantClass α α (swap (· * ·)) (· < ·)] (hf : StrictAntiOn f s) (hg : StrictAntiOn g s) :
    StrictAntiOn (fun x => f x * g x) s
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
theorem Nat.not_succ_le_self : (n : Nat) → Not (LE.le (succ n) n)
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
lemma iteratedFDeriv_two_apply (f : E → F) (z : E) (m : Fin 2 → E) :
    iteratedFDeriv 𝕜 2 f z m = fderiv 𝕜 (fderiv 𝕜 f) z (m 0) (m 1)
-- Mathlib/Order/RelIso/Basic.lean
protected theorem map_rel (f : r →r s) {a b} : r a b → s (f a) (f b)
-- Mathlib/NumberTheory/ModularForms/EisensteinSeries/Defs.lean
lemma eisensteinSeries_slash_apply (k : ℤ) (γ : SL(2, ℤ)) :
    eisensteinSeries a k ∣[k] γ = eisensteinSeries (a ᵥ* γ) k
-- Mathlib/Analysis/Convex/Gauge.lean
/-- If `s` is a convex neighborhood of the origin in a topological real vector space, then `gauge s`
is continuous. If the ambient space is a normed space, then `gauge s` is Lipschitz continuous, see
`Convex.lipschitz_gauge`. -/
theorem continuousAt_gauge (hc : Convex ℝ s) (hs₀ : s ∈ 𝓝 0) : ContinuousAt (gauge s) x
-- Mathlib/AlgebraicTopology/DoldKan/PInfty.lean
@[reassoc (attr := simp)]
theorem QInfty_f_idem (n : ℕ) : (QInfty.f n : X _[n] ⟶ _) ≫ QInfty.f n = QInfty.f n
-- Mathlib/Topology/MetricSpace/Isometry.lean
theorem symm_bijective : Bijective (IsometryEquiv.symm : (α ≃ᵢ β) → β ≃ᵢ α)
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- Characterization of minimizers in the projection on a subspace, in the real case.
Let `u` be a point in a real inner product space, and let `K` be a nonempty subspace.
Then point `v` minimizes the distance `‖u - v‖` over points in `K` if and only if
for all `w ∈ K`, `⟪u - v, w⟫ = 0` (i.e., `u - v` is orthogonal to the subspace `K`).
This is superceded by `norm_eq_iInf_iff_inner_eq_zero` that gives the same conclusion over
any `RCLike` field.
-/
theorem norm_eq_iInf_iff_real_inner_eq_zero (K : Submodule ℝ F) {u : F} {v : F} (hv : v ∈ K) :
    (‖u - v‖ = ⨅ w : (↑K : Set F), ‖u - w‖) ↔ ∀ w ∈ K, ⟪u - v, w⟫_ℝ = 0
-- Mathlib/Probability/Kernel/Invariance.lean
theorem comp_const_apply_eq_bind (κ : Kernel α β) (μ : Measure α) (a : α) :
    (κ ∘ₖ const α μ) a = μ.bind κ
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[simp]
theorem ppow_zero {f : ArithmeticFunction R} : f.ppow 0 = ζ
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
lemma rpow_natCast_mul (x : ℝ≥0∞) (n : ℕ) (z : ℝ) : x ^ (n * z) = (x ^ n) ^ z
-- Mathlib/LinearAlgebra/GeneralLinearGroup.lean
@[simp]
theorem generalLinearEquiv_to_linearMap (f : GeneralLinearGroup R M) :
    (generalLinearEquiv R M f : M →ₗ[R] M) = f
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
@[reassoc]
theorem app_right_eq_ι_comp_snd (b) :
    K.π.app (WalkingMulticospan.right b) = K.ι (I.sndTo b) ≫ I.snd b
-- Mathlib/Order/Hom/Bounded.lean
@[ext]
theorem ext {f g : BotHom α β} (h : ∀ a, f a = g a) : f = g
-- Mathlib/CategoryTheory/Idempotents/FunctorExtension.lean
/-- The canonical functor `(C ⥤ Karoubi D) ⥤ (Karoubi C ⥤ Karoubi D)` -/
@[simps]
def functorExtension₁ : (C ⥤ Karoubi D) ⥤ Karoubi C ⥤ Karoubi D
-- Mathlib/Algebra/Group/Pi/Basic.lean
@[to_additive]
theorem elim_inv_inv [Inv γ] : Sum.elim a⁻¹ b⁻¹ = (Sum.elim a b)⁻¹
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
theorem lintegral_prod_swap [SFinite μ] (f : α × β → ℝ≥0∞) :
    ∫⁻ z, f z.swap ∂ν.prod μ = ∫⁻ z, f z ∂μ.prod ν
-- Mathlib/MeasureTheory/Measure/Lebesgue/Integral.lean
theorem volume_regionBetween_eq_integral' [SigmaFinite μ] (f_int : IntegrableOn f s μ)
    (g_int : IntegrableOn g s μ) (hs : MeasurableSet s) (hfg : f ≤ᵐ[μ.restrict s] g) :
    μ.prod volume (regionBetween f g s) = ENNReal.ofReal (∫ y in s, (g - f) y ∂μ)
-- Mathlib/Condensed/Explicit.lean
/-- A condensed object satisfies the equalizer condition. -/
theorem equalizerCondition (X : Condensed A) : EqualizerCondition X.val
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
@[simp]
theorem toOrdinal_cast_nat (n : ℕ) : toOrdinal n = n
-- Mathlib/Data/Nat/Defs.lean
lemma succ_div_of_dvd (hba : b ∣ a + 1) : (a + 1) / b = a / b + 1
-- Mathlib/Data/Set/MulAntidiagonal.lean
@[to_additive (attr := simp)]
theorem mem_mulAntidiagonal : x ∈ mulAntidiagonal s t a ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ x.1 * x.2 = a
-- Mathlib/Algebra/ContinuedFractions/Computation/CorrectnessTerminating.lean
/-- If `GenContFract.of v` terminates, then its convergents will eventually always be `v`. -/
theorem of_correctness_atTop_of_terminates (terminates : (of v).Terminates) :
    ∀ᶠ n in atTop, v = (of v).convs n
-- Mathlib/LinearAlgebra/BilinearMap.lean
theorem map_sum₂ {ι : Type*} (f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) (t : Finset ι) (x : ι → M) (y) :
    f (∑ i ∈ t, x i) y = ∑ i ∈ t, f (x i) y
-- Mathlib/ModelTheory/Bundled.lean
/-- A model of a theory is also a model of any subtheory. -/
@[simps]
def subtheoryModel (M : T.ModelType) {T' : L.Theory} (h : T' ⊆ T) : T'.ModelType
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
/-- Reorder a product.

The difference with `Finset.prod_bij'` is that the bijection is specified as a surjective injection,
rather than by an inverse function.

The difference with `Finset.prod_nbij` is that the bijection is allowed to use membership of the
domain of the product, rather than being a non-dependent function. -/
@[to_additive "Reorder a sum.

The difference with `Finset.sum_bij'` is that the bijection is specified as a surjective injection,
rather than by an inverse function.

The difference with `Finset.sum_nbij` is that the bijection is allowed to use membership of the
domain of the sum, rather than being a non-dependent function."]
theorem prod_bij (i : ∀ a ∈ s, κ) (hi : ∀ a ha, i a ha ∈ t)
    (i_inj : ∀ a₁ ha₁ a₂ ha₂, i a₁ ha₁ = i a₂ ha₂ → a₁ = a₂)
    (i_surj : ∀ b ∈ t, ∃ a ha, i a ha = b) (h : ∀ a ha, f a = g (i a ha)) :
    ∏ x ∈ s, f x = ∏ x ∈ t, g x
-- Mathlib/Topology/Algebra/Module/Basic.lean
theorem ker_coprod_of_disjoint_range [ContinuousAdd M₃] (f : M →L[R] M₃) (g : M₂ →L[R] M₃)
    (hd : Disjoint (range f) (range g)) :
    LinearMap.ker (f.coprod g) = (LinearMap.ker f).prod (LinearMap.ker g)
-- Mathlib/Order/Bounds/Basic.lean
theorem IsLeast.isGreatest_image2 (ha : IsLeast s a) (hb : IsLeast t b) :
    IsGreatest (Set.image2 f s t) (f a b)
-- Mathlib/Analysis/Normed/Group/Hom.lean
theorem sum_apply {ι : Type*} (s : Finset ι) (f : ι → NormedAddGroupHom V₁ V₂) (v : V₁) :
    (∑ i ∈ s, f i) v = ∑ i ∈ s, f i v
-- Mathlib/Order/Grade.lean
@[simp]
theorem isMax_grade_iff : IsMax (grade 𝕆 a) ↔ IsMax a
-- Mathlib/Data/PNat/Basic.lean
theorem natPred_injective : Function.Injective natPred
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
theorem Memℒp.eLpNormEssSup_indicator_norm_ge_eq_zero (hf : Memℒp f ∞ μ)
    (hmeas : StronglyMeasurable f) :
    ∃ M : ℝ, eLpNormEssSup ({ x | M ≤ ‖f x‖₊ }.indicator f) μ = 0
-- Mathlib/FieldTheory/Adjoin.lean
theorem biSup_adjoin_simple : ⨆ x ∈ S, F⟮x⟯ = adjoin F S
-- Mathlib/Algebra/Quaternion.lean
nonrec theorem mul_star_eq_coe : a * star a = (a * star a).re
-- Mathlib/RingTheory/HahnSeries/Summable.lean
@[simp]
theorem hsum_smul {x : HahnSeries Γ R} {s : SummableFamily Γ R α} : (x • s).hsum = x * s.hsum
-- Mathlib/LinearAlgebra/Matrix/Charpoly/Basic.lean
@[simp]
lemma charpoly_fromBlocks_zero₁₂ :
    (fromBlocks M₁₁ 0 M₂₁ M₂₂).charpoly = (M₁₁.charpoly * M₂₂.charpoly)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigOWith_zero (hc : 0 ≤ c) : IsBigOWith c l (fun _x => (0 : E')) g'
-- Mathlib/Topology/Algebra/Algebra.lean
@[ext]
theorem ext {f g : A →A[R] B} (h : ∀ x, f x = g x) : f = g
-- Mathlib/Probability/Process/Stopping.lean
theorem stoppedValue_const (u : ι → Ω → β) (i : ι) : (stoppedValue u fun _ => i) = u i
-- Mathlib/Data/Set/Basic.lean
theorem disjoint_iff_inter_eq_empty : Disjoint s t ↔ s ∩ t = ∅
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
/-- A strict affine subspace has measure zero. -/
theorem addHaar_affineSubspace {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [MeasurableSpace E] [BorelSpace E] [FiniteDimensional ℝ E] (μ : Measure E) [IsAddHaarMeasure μ]
    (s : AffineSubspace ℝ E) (hs : s ≠ ⊤) : μ s = 0
-- Mathlib/Analysis/Quaternion.lean
@[simp, nolint simpNF] -- Porting note (#10959): simp cannot prove this
theorem nnnorm_star (a : ℍ) : ‖star a‖₊ = ‖a‖₊
-- Mathlib/Order/Filter/Ultrafilter.lean
theorem mem_hyperfilter_of_finite_compl {s : Set α} (hf : Set.Finite sᶜ) : s ∈ hyperfilter α
-- Mathlib/CategoryTheory/Limits/Opposites.lean
theorem unop_inr {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
    c.unop.inr = c.snd.unop
-- Mathlib/CategoryTheory/Idempotents/FunctorCategories.lean
/-- On objects, the functor which sends a formal direct factor `P` of a
functor `F : J ⥤ C` to the functor `J ⥤ Karoubi C` which sends `(j : J)` to
the corresponding direct factor of `F.obj j`. -/
@[simps]
def obj (P : Karoubi (J ⥤ C)) : J ⥤ Karoubi C
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
theorem nonempty_of_affineSpan_eq_top {s : Set P} (h : affineSpan k s = ⊤) : s.Nonempty
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Basic.lean
theorem val_le_of_le {n : Nat} {a b : Fin n} (h : a ≤ b) : (a : Nat) ≤ (b : Nat)
-- Mathlib/Data/Fin/Tuple/Basic.lean
theorem repeat_rev {α : Type*} (a : Fin n → α) (k : Fin (m * n)) :
    Fin.repeat m a k.rev = Fin.repeat m (a ∘ Fin.rev) k
-- Mathlib/Combinatorics/Additive/Corner/Defs.lean
@[simp] lemma Set.Subsingleton.isCornerFree (hA : A.Subsingleton) : IsCornerFree A
-- Mathlib/Topology/MetricSpace/IsometricSMul.lean
@[to_additive (attr := simp)]
theorem edist_smul_left [SMul M X] [IsometricSMul M X] (c : M) (x y : X) :
    edist (c • x) (c • y) = edist x y
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
theorem Parallel.direction_eq {s₁ s₂ : AffineSubspace k P} (h : s₁ ∥ s₂) :
    s₁.direction = s₂.direction
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL2.lean
theorem condexpL2_comp_continuousLinearMap (hm : m ≤ m0) (T : E' →L[ℝ] E'') (f : α →₂[μ] E') :
    (condexpL2 E'' 𝕜' hm (T.compLp f) : α →₂[μ] E'') =ᵐ[μ]
    T.compLp (condexpL2 E' 𝕜 hm f : α →₂[μ] E')
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
@[to_additive]
theorem smooth_one [One M'] : Smooth I I' (1 : M → M')
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem foldl_eq_foldlM (f : β → α → β) (b) (l : List α) :
    l.foldl f b = l.foldlM (m := Id) f b
-- Mathlib/Analysis/Calculus/TangentCone.lean
theorem uniqueDiffWithinAt_Ioi (a : ℝ) : UniqueDiffWithinAt ℝ (Ioi a) a
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Lemmas.lean
theorem MeasureTheory.AEStronglyMeasurable.comp_measurePreserving
    {γ : Type*} {_ : MeasurableSpace γ} {_ : MeasurableSpace α} {f : γ → α} {μ : Measure γ}
    {ν : Measure α} (hg : AEStronglyMeasurable g ν) (hf : MeasurePreserving f μ ν) :
    AEStronglyMeasurable (g ∘ f) μ
-- Mathlib/Topology/Order/LocalExtr.lean
theorem IsLocalMinOn.on_subset {t : Set α} (hf : IsLocalMinOn f t a) (h : s ⊆ t) :
    IsLocalMinOn f s a
-- Mathlib/Geometry/RingedSpace/OpenImmersion.lean
/-- An open immersion is an iso if the underlying continuous map is epi. -/
theorem to_iso [h' : Epi f.base] : IsIso f
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem toFinsupp_C (a : R) : (C a).toFinsupp = single 0 a
-- Mathlib/Algebra/Order/Monovary.lean
@[to_additive] lemma AntivaryOn.mul_left (h₁ : AntivaryOn f₁ g s) (h₂ : AntivaryOn f₂ g s) :
    AntivaryOn (f₁ * f₂) g s
-- Mathlib/Algebra/Order/Interval/Set/Group.lean
@[to_additive]
theorem pairwise_disjoint_Ioo_zpow :
    Pairwise (Disjoint on fun n : ℤ => Ioo (b ^ n) (b ^ (n + 1)))
-- Mathlib/Data/Finset/Basic.lean
theorem singleton_subset_set_iff {s : Set α} {a : α} : ↑({a} : Finset α) ⊆ s ↔ a ∈ s
-- Mathlib/GroupTheory/Subsemigroup/Centralizer.lean
@[to_additive]
theorem centralizer_le (h : S ⊆ T) : centralizer T ≤ centralizer S
-- Mathlib/CategoryTheory/FiberedCategory/HomLift.lean
lemma of_commSq {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) (ha : p.obj a = R) (hb : p.obj b = S)
    (h : CommSq (p.map φ) (eqToHom ha) (eqToHom hb) f) : p.IsHomLift f φ
-- Mathlib/Algebra/Polynomial/Basic.lean
/-- `erase p n` is the polynomial `p` in which the `X^n` term has been erased. -/
irreducible_def erase (n : ℕ) : R[X] → R[X]
-- Mathlib/Analysis/Analytic/IsolatedZeros.lean
/-- The *identity principle* for analytic functions, global version: if two functions are
analytic on a connected set `U` and coincide at points which accumulate to a point `z₀ ∈ U`, then
they coincide globally in `U`.
For higher-dimensional versions requiring that the functions coincide in a neighborhood of `z₀`,
see `AnalyticOn.eqOn_of_preconnected_of_eventuallyEq`. -/
theorem eqOn_of_preconnected_of_frequently_eq (hf : AnalyticOn 𝕜 f U) (hg : AnalyticOn 𝕜 g U)
    (hU : IsPreconnected U) (h₀ : z₀ ∈ U) (hfg : ∃ᶠ z in 𝓝[≠] z₀, f z = g z) : EqOn f g U
-- Mathlib/Analysis/Calculus/Gradient/Basic.lean
theorem HasDerivAt.hasGradientAt (h : HasDerivAt g g' u) :
    HasGradientAt g (starRingEnd 𝕜 g') u