ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/CliffordAlgebra/Even.lean
@[simp]
private theorem snd_fFold_fFold (m₁ m₂ m₃ : M) (x : A × S f) :
    ((fFold f m₁ (fFold f m₂ x)).snd : M →ₗ[R] A) m₃ = f.bilin m₃ m₁ * (x.snd : M →ₗ[R] A) m₂
-- Mathlib/CategoryTheory/Groupoid/VertexGroup.lean
/-- The inverse in the group is equal to the inverse given by `CategoryTheory.inv`. -/
theorem vertexGroup.inv_eq_inv (c : C) (γ : c ⟶ c) : γ⁻¹ = CategoryTheory.inv γ
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem floor_intCast (z : ℤ) : ⌊(z : α)⌋ = z
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[simp]
theorem coe_mk' {s : Set R} {sm : Submonoid R} (hm : ↑sm = s) {sa : AddSubmonoid R} (ha : ↑sa = s) :
    (Subsemiring.mk' s sm hm sa ha : Set R) = s
-- Mathlib/RingTheory/FreeCommRing.lean
theorem isSupported_of {p} {s : Set α} : IsSupported (of p) s ↔ p ∈ s
-- Mathlib/CategoryTheory/SmallObject/Construction.lean
/-- The canonical natural transformation `𝟭 (Over S) ⟶ functor f S`. -/
@[simps! app]
noncomputable def ε : 𝟭 (Over S) ⟶ functor f S
-- Mathlib/Data/Set/Defs.lean
@[simp] theorem mem_pi : f ∈ s.pi t ↔ ∀ i ∈ s, f i ∈ t i
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp, norm_cast]
theorem coe_prodMap [Module R₁ M₂] [Module R₁ M₃] [Module R₁ M₄] (f₁ : M₁ →L[R₁] M₂)
    (f₂ : M₃ →L[R₁] M₄) : ↑(f₁.prodMap f₂) = (f₁ : M₁ →ₗ[R₁] M₂).prodMap (f₂ : M₃ →ₗ[R₁] M₄)
-- Mathlib/CategoryTheory/Monad/Limits.lean
theorem hasLimit_of_reflective (F : J ⥤ D) (R : D ⥤ C) [HasLimit (F ⋙ R)] [Reflective R] :
    HasLimit F
-- Mathlib/Data/Real/Irrational.lean
theorem Nat.Prime.irrational_sqrt {p : ℕ} (hp : Nat.Prime p) : Irrational (√p)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem add_one_le_iff {a b : Int} : a + 1 ≤ b ↔ a < b
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem bmex_lt_ord_succ_card {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{u}) :
    bmex.{_, u} o f < (succ o.card).ord
-- Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean
@[simp]
theorem right_eq_midpoint_iff {x y : P} : y = midpoint R x y ↔ x = y
-- Mathlib/RingTheory/WittVector/Defs.lean
@[simp]
theorem constantCoeff_wittMul (n : ℕ) : constantCoeff (wittMul p n) = 0
-- Mathlib/LinearAlgebra/Matrix/Basis.lean
@[simp]
theorem Basis.toMatrix_reindex (b : Basis ι R M) (v : ι' → M) (e : ι ≃ ι') :
    (b.reindex e).toMatrix v = (b.toMatrix v).submatrix e.symm _root_.id
-- Mathlib/Data/Set/Function.lean
theorem StrictMonoOn.injOn [LinearOrder α] [Preorder β] {f : α → β} {s : Set α}
    (H : StrictMonoOn f s) : s.InjOn f
-- Mathlib/Analysis/Normed/Group/Hom.lean
@[simp]
theorem range_comp_incl_top : (f.comp (incl (⊤ : AddSubgroup V₁))).range = f.range
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem prodCongrRight_trans_prodComm :
    (prodCongrRight e).trans (prodComm _ _) = (prodComm _ _).trans (prodCongrLeft e)
-- Mathlib/Order/Chain.lean
theorem Monotone.isChain_range [LinearOrder α] [Preorder β] {f : α → β} (hf : Monotone f) :
    IsChain (· ≤ ·) (range f)
-- Mathlib/Order/Basic.lean
@[simp]
theorem const_le_const : const β a ≤ const β b ↔ a ≤ b
-- Mathlib/Data/Real/Hyperreal.lean
@[simp, norm_cast]
theorem coe_mul (x y : ℝ) : ↑(x * y) = (x * y : ℝ*)
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
@[simp] theorem of_symm_add (x y : HahnModule Γ R V) :
  (of R).symm (x + y) = (of R).symm x + (of R).symm y
-- Mathlib/Order/Interval/Finset/Fin.lean
theorem Icc_eq_finset_subtype : Icc a b = (Icc (a : ℕ) b).fin n
-- Mathlib/Combinatorics/Additive/FreimanHom.lean
@[to_additive]
lemma isMulFreimanHom_const {b : β} (hb : b ∈ B) : IsMulFreimanHom n A B fun _ ↦ b
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙ_nonpos (f : R → R) (a : A) (h : ∀ x ∈ σₙ R a, f x ≤ 0) :
    cfcₙ f a ≤ 0
-- Mathlib/Data/Finset/Lattice.lean
theorem iInf_insert_update {x : α} {t : Finset α} (f : α → β) {s : β} (hx : x ∉ t) :
    ⨅ i ∈ insert x t, update f x s i = s ⊓ ⨅ i ∈ t, f i
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem isPrefixOf_replicate {a : α} :
    isPrefixOf l (replicate n a) = (decide (l.length ≤ n) && l.all (· == a))
-- Mathlib/NumberTheory/FunctionField.lean
theorem InftyValuation.map_one' : inftyValuationDef Fq 1 = 1
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- Given a point in an affine subspace, the set of vectors in its direction equals the set of
vectors subtracting that point on the left. -/
theorem coe_direction_eq_vsub_set_left {s : AffineSubspace k P} {p : P} (hp : p ∈ s) :
    (s.direction : Set V) = (p -ᵥ ·) '' s
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
theorem spanFinset_ne_zero {ι : Type*} {s : Finset ι} {f : ι → K} :
    spanFinset R₁ s f ≠ 0 ↔ ∃ j ∈ s, f j ≠ 0
-- Mathlib/Probability/Variance.lean
theorem variance_le_expectation_sq [@IsProbabilityMeasure Ω _ ℙ] {X : Ω → ℝ}
    (hm : AEStronglyMeasurable X ℙ) : Var[X] ≤ 𝔼[X ^ 2]
-- Mathlib/Algebra/Homology/ShortComplex/Linear.lean
@[simp]
lemma rightHomologyMap'_smul :
    rightHomologyMap' (a • φ) h₁ h₂ = a • rightHomologyMap' φ h₁ h₂
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem Filter.EventuallyEq.hasDerivWithinAt_iff (h₁ : f₁ =ᶠ[𝓝[s] x] f) (hx : f₁ x = f x) :
    HasDerivWithinAt f₁ f' s x ↔ HasDerivWithinAt f f' s x
-- Mathlib/Geometry/Euclidean/Inversion/Basic.lean
/-- Distance from the image of a point under inversion to the center. This formula accidentally
works for `x = c`. -/
theorem dist_inversion_center (c x : P) (R : ℝ) : dist (inversion c R x) c = R ^ 2 / dist x c
-- Mathlib/Algebra/Polynomial/Derivative.lean
theorem derivative_X_add_C (c : R) : derivative (X + C c) = 1
-- Mathlib/Analysis/Normed/Group/Uniform.lean
@[to_additive]
theorem LipschitzOnWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : LipschitzOnWith C f s)
    (ha : a ∈ s) (hb : b ∈ s) (hr : ‖a / b‖ ≤ r) : ‖f a / f b‖ ≤ C * r
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
/-- If `𝓕 : ι → X → α` tends to `f : X → α` *pointwise on `S ∪ {x₀} : Set X`* along some nontrivial
filter, and if the family `𝓕` is equicontinuous at `x₀ : X` within `S`, then the limit is
continuous at `x₀` within `S`. -/
theorem Filter.Tendsto.continuousWithinAt_of_equicontinuousWithinAt {l : Filter ι} [l.NeBot]
    {F : ι → X → α} {f : X → α} {S : Set X} {x₀ : X} (h₁ : ∀ x ∈ S, Tendsto (F · x) l (𝓝 (f x)))
    (h₂ : Tendsto (F · x₀) l (𝓝 (f x₀))) (h₃ : EquicontinuousWithinAt F S x₀) :
    ContinuousWithinAt f S x₀
-- Mathlib/Algebra/Homology/ShortComplex/Basic.lean
/-- The opposite morphism in `ShortComplex Cᵒᵖ` associated to a morphism in `ShortComplex C` -/
@[simps]
def opMap (φ : S₁ ⟶ S₂) : S₂.op ⟶ S₁.op
-- Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean
@[to_additive]
theorem tprod_eq_zero_mul'
    {f : ℕ → M} (hf : Multipliable (fun n ↦ f (n + 1))) :
    ∏' b, f b = f 0 * ∏' b, f (b + 1)
-- Mathlib/GroupTheory/Congruence/Basic.lean
/-- The diagram describing the universal property for quotients of monoids commutes. -/
@[to_additive (attr := simp) "The diagram describing the universal property for quotients of
`AddMonoid`s commutes."]
theorem lift_comp_mk' (H : c ≤ ker f) : (c.lift f H).comp c.mk' = f
-- Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
theorem continuousOn_log : ContinuousOn log {0}ᶜ
-- Mathlib/Order/Cover.lean
theorem WCovBy.Ico_subset (h : a ⩿ b) : Ico a b ⊆ {a}
-- Mathlib/CategoryTheory/Abelian/Pseudoelements.lean
theorem zero_eq_zero' {P Q R : C} :
    (⟦((0 : Q ⟶ P) : Over P)⟧ : Pseudoelement P) = ⟦((0 : R ⟶ P) : Over P)⟧
-- Mathlib/Data/Finset/Sups.lean
lemma biUnion_image_inf_right : t.biUnion (fun b ↦ s.image (· ⊓ b)) = s ⊼ t
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
theorem mem_chart_target (x : M) : chartAt H x x ∈ (chartAt H x).target
-- Mathlib/Data/Nat/Defs.lean
lemma le_three_of_sqrt_eq_one (h : sqrt n = 1) : n ≤ 3
-- Mathlib/Topology/Gluing.lean
theorem range_fromOpenSubsetsGlue : Set.range (fromOpenSubsetsGlue U) = ⋃ i, (U i : Set α)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sin_mem_Icc (x : ℝ) : sin x ∈ Icc (-1 : ℝ) 1
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem ceil_one : ⌈(1 : α)⌉₊ = 1
-- Mathlib/Data/Finset/NoncommProd.lean
theorem noncommProd_erase_mul [DecidableEq α] (s : Finset α) {a : α} (h : a ∈ s) (f : α → β) (comm)
    (comm' := fun x hx y hy hxy ↦ comm (s.mem_of_mem_erase hx) (s.mem_of_mem_erase hy) hxy) :
    (s.erase a).noncommProd f comm' * f a = s.noncommProd f comm
-- Mathlib/Data/Seq/WSeq.lean
@[simp]
theorem dropn_cons (a : α) (s) (n) : drop (cons a s) (n + 1) = drop s n
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem setLIntegral_map [MeasurableSpace β] {f : β → ℝ≥0∞} {g : α → β} {s : Set β}
    (hs : MeasurableSet s) (hf : Measurable f) (hg : Measurable g) :
    ∫⁻ y in s, f y ∂map g μ = ∫⁻ x in g ⁻¹' s, f (g x) ∂μ
-- Mathlib/Logic/Basic.lean
theorem eq_equivalence {α : Sort*} : Equivalence (@Eq α)
-- Mathlib/Order/Filter/Basic.lean
/-- There are only two filters on a `Subsingleton`: `⊥` and `⊤`. If the type is empty, then they are
equal. -/
theorem eq_top_of_neBot [Subsingleton α] (l : Filter α) [NeBot l] : l = ⊤
-- Mathlib/Data/Rat/Defs.lean
lemma mul_eq_mkRat (q r : ℚ) : q * r = mkRat (q.num * r.num) (q.den * r.den)
-- Mathlib/Tactic/NormNum/Prime.lean
theorem minFacHelper_2 {n k k' : ℕ} (e : k + 2 = k') (nk : ¬ Nat.Prime k)
    (h : MinFacHelper n k) : MinFacHelper n k'
-- Mathlib/Tactic/NormNum/GCD.lean
theorem isNat_gcd : {x y nx ny z : ℕ} →
    IsNat x nx → IsNat y ny → Nat.gcd nx ny = z → IsNat (Nat.gcd x y) z
-- Mathlib/Data/ENNReal/Real.lean
theorem le_toNNReal_of_coe_le (h : p ≤ a) (ha : a ≠ ∞) : p ≤ a.toNNReal
-- Mathlib/CategoryTheory/Adjunction/FullyFaithful.lean
/-- If the counit of an adjunction is an isomorphism, then its inverse on the image of R is given
by R whiskered with the unit. -/
@[simp]
theorem inv_counit_map {X : D} [IsIso (h.counit.app X)] :
    inv (R.map (h.counit.app X)) = h.unit.app (R.obj X)
-- Mathlib/RingTheory/HopfAlgebra.lean
/-- A Hopf algebra over a commutative (semi)ring `R` is a bialgebra over `R` equipped with an
`R`-linear endomorphism `antipode` satisfying the antipode axioms. -/
class HopfAlgebra (R : Type u) (A : Type v) [CommSemiring R] [Semiring A] extends
    Bialgebra R A where
  /-- The antipode of the Hopf algebra. -/
  antipode : A →ₗ[R] A
  /-- One of the antipode axioms for a Hopf algebra. -/
  mul_antipode_rTensor_comul :
    LinearMap.mul' R A ∘ₗ antipode.rTensor A ∘ₗ comul = (Algebra.linearMap R A) ∘ₗ counit
  /-- One of the antipode axioms for a Hopf algebra. -/
  mul_antipode_lTensor_comul :
    LinearMap.mul' R A ∘ₗ antipode.lTensor A ∘ₗ comul = (Algebra.linearMap R A) ∘ₗ counit
-- Mathlib/Order/Interval/Multiset.lean
@[simp]
theorem Ico_inter_Ico_of_le [DecidableEq α] {a b c d : α} (h : b ≤ c) : Ico a b ∩ Ico c d = 0
-- Mathlib/Data/Sum/Basic.lean
theorem exists_of_isLeft_left (h₁ : LiftRel r s x y) (h₂ : x.isLeft) :
    ∃ a c, r a c ∧ x = inl a ∧ y = inl c
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem not_mem_uIcc_of_gt : a < c → b < c → c ∉ [[a, b]]
-- Mathlib/Topology/Order/PartialSups.lean
protected lemma ContinuousOn.partialSups (hf : ∀ k ≤ n, ContinuousOn (f k) s) :
    ContinuousOn (partialSups f n) s
-- Mathlib/LinearAlgebra/Span.lean
/-- An induction principle for elements of `⨆ i, p i`.
If `C` holds for `0` and all elements of `p i` for all `i`, and is preserved under addition,
then it holds for all elements of the supremum of `p`. -/
@[elab_as_elim]
theorem iSup_induction {ι : Sort*} (p : ι → Submodule R M) {C : M → Prop} {x : M}
    (hx : x ∈ ⨆ i, p i) (hp : ∀ (i), ∀ x ∈ p i, C x) (h0 : C 0)
    (hadd : ∀ x y, C x → C y → C (x + y)) : C x
-- Mathlib/LinearAlgebra/AffineSpace/Slope.lean
/-- `slope f a c` is an affine combination of `slope f a b` and `slope f b c`. This version uses
`lineMap` to express this property. -/
theorem lineMap_slope_slope_sub_div_sub (f : k → PE) (a b c : k) (h : a ≠ c) :
    lineMap (slope f a b) (slope f b c) ((c - b) / (c - a)) = slope f a c
-- Mathlib/Topology/MetricSpace/Holder.lean
theorem ediam_image_inter_le (hf : HolderOnWith C r f s) (t : Set X) :
    EMetric.diam (f '' (t ∩ s)) ≤ (C : ℝ≥0∞) * EMetric.diam t ^ (r : ℝ)
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
protected nonrec theorem Smooth.coordChangeL
    (hf : Smooth IM IB f) (he : ∀ x, f x ∈ e.baseSet) (he' : ∀ x, f x ∈ e'.baseSet) :
    Smooth IM 𝓘(𝕜, F →L[𝕜] F) (fun y ↦ (e.coordChangeL 𝕜 e' (f y) : F →L[𝕜] F))
-- Mathlib/CategoryTheory/Category/Basic.lean
theorem eq_of_comp_right_eq {f g : Y ⟶ Z} (w : ∀ {X : C} (h : X ⟶ Y), h ≫ f = h ≫ g) :
    f = g
-- Mathlib/Data/Complex/Exponential.lean
@[simp]
theorem tanh_neg : tanh (-x) = -tanh x
-- .lake/packages/lean4/src/lean/Init/Data/Int/Bitwise/Lemmas.lean
@[simp]
theorem negSucc_shiftRight (m n : Nat) :
    -[m+1] >>> n = -[m >>>n +1]
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem totallyBounded_iff_ultrafilter {s : Set α} :
    TotallyBounded s ↔ ∀ f : Ultrafilter α, ↑f ≤ 𝓟 s → Cauchy (f : Filter α)
-- Mathlib/Algebra/Algebra/Hom.lean
@[ext]
theorem ext {φ₁ φ₂ : A →ₐ[R] B} (H : ∀ x, φ₁ x = φ₂ x) : φ₁ = φ₂
-- Mathlib/Analysis/Convex/Quasiconvex.lean
theorem AntitoneOn.quasiconcaveOn (hf : AntitoneOn f s) (hs : Convex 𝕜 s) : QuasiconcaveOn 𝕜 s f
-- Mathlib/Geometry/Manifold/PartitionOfUnity.lean
/-- The `tsupport`s of a smooth partition of unity are locally finite. -/
theorem finite_tsupport : {i | x₀ ∈ tsupport (ρ i)}.Finite
-- Mathlib/RingTheory/Finiteness.lean
theorem fg_induction (R M : Type*) [Semiring R] [AddCommMonoid M] [Module R M]
    (P : Submodule R M → Prop) (h₁ : ∀ x, P (Submodule.span R {x}))
    (h₂ : ∀ M₁ M₂, P M₁ → P M₂ → P (M₁ ⊔ M₂)) (N : Submodule R M) (hN : N.FG) : P N
-- Mathlib/Order/Filter/Basic.lean
@[simp] theorem sup_neBot {f g : Filter α} : NeBot (f ⊔ g) ↔ NeBot f ∨ NeBot g
-- Mathlib/NumberTheory/PellMatiyasevic.lean
@[simp]
theorem yz_succ (n : ℕ) : yz a1 (n + 1) = xz a1 n + yz a1 n * az a
-- Mathlib/Data/Prod/Basic.lean
lemma mk_inj_left {a : α} {b₁ b₂ : β} : (a, b₁) = (a, b₂) ↔ b₁ = b₂
-- Mathlib/RepresentationTheory/Basic.lean
@[simp]
theorem linHom_apply (g : G) (f : V →ₗ[k] W) : (linHom ρV ρW) g f = ρW g ∘ₗ f ∘ₗ ρV g⁻¹
-- Mathlib/Algebra/Field/Subfield.lean
theorem map_map (g : L →+* M) (f : K →+* L) : (s.map f).map g = s.map (g.comp f)
-- Mathlib/Order/Hom/Lattice.lean
/-- Adjoins a `⊥` to the domain and codomain of a `SupHom`. -/
@[simps]
protected def withBot (f : SupHom α β) : SupBotHom (WithBot α) (WithBot β)
-- Mathlib/Order/GaloisConnection.lean
protected theorem id [pα : Preorder α] : @GaloisConnection α α pα pα id id
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma not_isUnramified_iff_card_stabilizer_eq_two [IsGalois k K] :
    ¬ IsUnramified k w ↔ Nat.card (Stab w) = 2
-- Mathlib/Algebra/GroupWithZero/Defs.lean
/-- A mixin for right cancellative multiplication by nonzero elements. -/
class IsRightCancelMulZero (M₀ : Type u) [Mul M₀] [Zero M₀] : Prop where
  /-- Multiplicatin by a nonzero element is right cancellative. -/
  protected mul_right_cancel_of_ne_zero : ∀ {a b c : M₀}, b ≠ 0 → a * b = c * b → a = c
-- Mathlib/Algebra/Category/CoalgebraCat/Basic.lean
@[simp]
lemma of_counit {X : Type v} [AddCommGroup X] [Module R X] [Coalgebra R X] :
    Coalgebra.counit (A := of R X) = Coalgebra.counit (R := R) (A := X)
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem Integrable.inf {β} [NormedLatticeAddCommGroup β] {f g : α → β} (hf : Integrable f μ)
    (hg : Integrable g μ) : Integrable (f ⊓ g) μ
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
@[simp]
theorem inner_zero_right (x : E) : ⟪x, 0⟫ = 0
-- Mathlib/GroupTheory/Exponent.lean
@[to_additive]
theorem lcm_orderOf_eq_exponent [Fintype G] : (Finset.univ : Finset G).lcm orderOf = exponent G
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
lemma isEquivalent_one_sub_smoothingFn_one : (fun x => 1 - ε x) ~[atTop] (fun _ => (1 : ℝ))
-- Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean
theorem ι_mul_prod_list {n : ℕ} (f : Fin n → M) (i : Fin n) :
    (ι R <| f i) * (List.ofFn fun i => ι R <| f i).prod = 0
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive (attr := simp)]
theorem singletonMonoidHom_apply (a : α) : singletonMonoidHom a = {a}
-- Mathlib/Algebra/Group/Submonoid/Units.lean
@[to_additive]
lemma inv_val_mem_of_mem_units (S : Submonoid M) {x : Mˣ} (h : x ∈ S.units) :
    ((x⁻¹ : Mˣ) : M) ∈ S
-- Mathlib/Topology/PartialHomeomorph.lean
/-- Restriction of partial homeomorphisms respects equivalence -/
theorem EqOnSource.restr {e e' : PartialHomeomorph X Y} (he : e ≈ e') (s : Set X) :
    e.restr s ≈ e'.restr s
-- Mathlib/Data/Matroid/Closure.lean
lemma subset_closure_of_subset (M : Matroid α) (hXY : X ⊆ Y) (hY : Y ⊆ M.E := by aesop_mat) :
    X ⊆ M.closure Y
-- Mathlib/Topology/Algebra/Algebra.lean
@[continuity, fun_prop]
theorem continuous_algebraMap [ContinuousSMul R A] : Continuous (algebraMap R A)
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Metric.lean
/-- If a closed set has a thickening with finite measure, then the measure of its
`r`-thickenings converge to its measure as `r > 0` tends to `0`. -/
theorem tendsto_measure_thickening_of_isClosed {μ : Measure α} {s : Set α}
    (hs : ∃ R > 0, μ (thickening R s) ≠ ∞) (h's : IsClosed s) :
    Tendsto (fun r => μ (thickening r s)) (𝓝[>] 0) (𝓝 (μ s))
-- Mathlib/Analysis/InnerProductSpace/l2Space.lean
@[simp]
protected theorem coe_mkOfOrthogonalEqBot (hsp : (span 𝕜 (Set.range v))ᗮ = ⊥) :
    ⇑(HilbertBasis.mkOfOrthogonalEqBot hv hsp) = v
-- Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean
theorem logEmbedding_component_le {r : ℝ} {x : (𝓞 K)ˣ} (hr : 0 ≤ r) (h : ‖logEmbedding K x‖ ≤ r)
    (w : {w : InfinitePlace K // w ≠ w₀}) : |logEmbedding K x w| ≤ r
-- Mathlib/Order/Interval/Set/Pi.lean
theorem pi_univ_Ioc_update_union (x y : ∀ i, α i) (i₀ : ι) (m : α i₀) (hm : m ∈ Icc (x i₀) (y i₀)) :
    ((pi univ fun i ↦ Ioc (x i) (update y i₀ m i)) ∪
        pi univ fun i ↦ Ioc (update x i₀ m i) (y i)) =
      pi univ fun i ↦ Ioc (x i) (y i)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sin_sub_nat_mul_pi (x : ℝ) (n : ℕ) : sin (x - n * π) = (-1) ^ n * sin x
-- Mathlib/Combinatorics/HalesJewett.lean
protected lemma IsMono.reindex {eη : η ≃ η'} {eα : α ≃ α'} {eι : ι ≃ ι'} {C : (ι → α) → κ}
    (hl : l.IsMono C) : (l.reindex eη eα eι).IsMono fun x ↦ C <| eα.symm ∘ x ∘ eι
-- Mathlib/Topology/FiberBundle/Basic.lean
/-- Characterization of continuous functions (at a point, within a set) into a fiber bundle. -/
theorem continuousWithinAt_totalSpace (f : X → TotalSpace F E) {s : Set X} {x₀ : X} :
    ContinuousWithinAt f s x₀ ↔
      ContinuousWithinAt (fun x => (f x).proj) s x₀ ∧
        ContinuousWithinAt (fun x => ((trivializationAt F E (f x₀).proj) (f x)).2) s x₀
-- Mathlib/Data/Finset/Lattice.lean
theorem count_finset_sup [DecidableEq β] (s : Finset α) (f : α → Multiset β) (b : β) :
    count b (s.sup f) = s.sup fun a => count b (f a)
-- Mathlib/Algebra/Order/Floor.lean
theorem fract_add (a b : α) : ∃ z : ℤ, fract (a + b) - fract a - fract b = z
-- Mathlib/LinearAlgebra/Matrix/AbsoluteValue.lean
theorem det_le {A : Matrix n n R} {abv : AbsoluteValue R S} {x : S} (hx : ∀ i j, abv (A i j) ≤ x) :
    abv A.det ≤ Nat.factorial (Fintype.card n) • x ^ Fintype.card n
-- Mathlib/Analysis/Convex/Independent.lean
/-- If a family is convex independent, so is any subfamily given by composition of an embedding into
index type with the original family. -/
theorem ConvexIndependent.comp_embedding {ι' : Type*} (f : ι' ↪ ι) {p : ι → E}
    (hc : ConvexIndependent 𝕜 p) : ConvexIndependent 𝕜 (p ∘ f)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem div_lt {a b c : Ordinal} (b0 : b ≠ 0) : a / b < c ↔ a < b * c
-- Mathlib/Logic/Function/Basic.lean
@[simp]
theorem const_inj [Nonempty α] {y₁ y₂ : β} : const α y₁ = const α y₂ ↔ y₁ = y₂
-- Mathlib/Topology/MetricSpace/Basic.lean
/-- We now define `MetricSpace`, extending `PseudoMetricSpace`. -/
class MetricSpace (α : Type u) extends PseudoMetricSpace α : Type u where
  eq_of_dist_eq_zero : ∀ {x y : α}, dist x y = 0 → x = y
-- Mathlib/RingTheory/Polynomial/Content.lean
@[simp]
theorem content_C {r : R} : (C r).content = normalize r
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
@[simp]
theorem fderiv_exp (hc : DifferentiableAt ℝ f x) :
    fderiv ℝ (fun x => Real.exp (f x)) x = Real.exp (f x) • fderiv ℝ f x
-- Mathlib/Data/Nat/Bitwise.lean
theorem testBit_land : ∀ m n k, testBit (m &&& n) k = (testBit m k && testBit n k)
-- Mathlib/SetTheory/ZFC/Ordinal.lean
theorem isTransitive_iff_sUnion_subset : x.IsTransitive ↔ (⋃₀ x : ZFSet) ⊆ x
-- Mathlib/Order/OmegaCompletePartialOrder.lean
theorem ωSup_apply_ωSup (c₀ : Chain (α →𝒄 β)) (c₁ : Chain α) :
    ωSup c₀ (ωSup c₁) = Prod.apply (ωSup (c₀.zip c₁))
-- Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean
@[simp]
theorem right_sub_midpoint (v₁ v₂ : V) : v₂ - midpoint R v₁ v₂ = (⅟ 2 : R) • (v₂ - v₁)
-- Mathlib/Analysis/Analytic/Basic.lean
theorem HasFPowerSeriesOnBall.coeff_zero (hf : HasFPowerSeriesOnBall f pf x r) (v : Fin 0 → E) :
    pf 0 v = f x
-- Mathlib/LinearAlgebra/QuadraticForm/Prod.lean
/-- If a family is anisotropic then its components must be. The converse is not true. -/
theorem anisotropic_of_pi [Fintype ι]
    {Q : ∀ i, QuadraticMap R (Mᵢ i) P} (h : (pi Q).Anisotropic) : ∀ i, (Q i).Anisotropic
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- An `affineCombination` equals a point if that point is in the set
and has weight 1 and the other points in the set have weight 0. -/
@[simp]
theorem affineCombination_of_eq_one_of_eq_zero (w : ι → k) (p : ι → P) {i : ι} (his : i ∈ s)
    (hwi : w i = 1) (hw0 : ∀ i2 ∈ s, i2 ≠ i → w i2 = 0) : s.affineCombination k p w = p i
-- Mathlib/Algebra/Homology/ShortComplex/ShortExact.lean
lemma isIso₂_of_shortExact_of_isIso₁₃ [Balanced C] {S₁ S₂ : ShortComplex C} (φ : S₁ ⟶ S₂)
    (h₁ : S₁.ShortExact) (h₂ : S₂.ShortExact) [IsIso φ.τ₁] [IsIso φ.τ₃] : IsIso φ.τ₂
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
@[reassoc]
lemma rightHomologyMap'_comp (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃)
    (h₁ : S₁.RightHomologyData) (h₂ : S₂.RightHomologyData) (h₃ : S₃.RightHomologyData) :
    rightHomologyMap' (φ₁ ≫ φ₂) h₁ h₃ = rightHomologyMap' φ₁ h₁ h₂ ≫
      rightHomologyMap' φ₂ h₂ h₃
-- Mathlib/Algebra/Order/Sub/Canonical.lean
theorem zero_tsub (a : α) : 0 - a = 0
-- Mathlib/Data/List/Chain.lean
theorem chain'_cons' {x l} : Chain' R (x :: l) ↔ (∀ y ∈ head? l, R x y) ∧ Chain' R l
-- Mathlib/Data/Set/Countable.lean
@[simp] theorem countable_empty : (∅ : Set α).Countable
-- Mathlib/Logic/Equiv/Basic.lean
theorem swapCore_self (r a : α) : swapCore a a r = r
-- Mathlib/CategoryTheory/Category/Preorder.lean
/-- A functor between preorder categories is monotone.
-/
@[mono]
theorem Functor.monotone (f : X ⥤ Y) : Monotone f.obj
-- Mathlib/Data/Finset/Basic.lean
theorem not_mem_union : a ∉ s ∪ t ↔ a ∉ s ∧ a ∉ t
-- Mathlib/Topology/Separation.lean
theorem comm (s t : Set X) : SeparatedNhds s t ↔ SeparatedNhds t s
-- Mathlib/Data/Fin/Tuple/Basic.lean
/-- `Fin.snoc` is the same as appending a one-tuple -/
theorem snoc_eq_append {α : Type*} (xs : Fin n → α) (x : α) :
    snoc xs x = append xs (cons x Fin.elim0)
-- Mathlib/Order/Antichain.lean
protected theorem insert (hs : IsAntichain r s) (hl : ∀ ⦃b⦄, b ∈ s → a ≠ b → ¬r b a)
    (hr : ∀ ⦃b⦄, b ∈ s → a ≠ b → ¬r a b) : IsAntichain r (insert a s)
-- Mathlib/Analysis/Convex/Segment.lean
lemma segment_inter_eq_endpoint_of_linearIndependent_sub
    {c x y : E} (h : LinearIndependent 𝕜 ![x - c, y - c]) :
    [c -[𝕜] x] ∩ [c -[𝕜] y] = {c}
-- Mathlib/Algebra/Group/Hom/Instances.lean
/-- Flipping arguments of monoid morphisms (`MonoidHom.flip`) as a monoid morphism. -/
@[to_additive (attr := simps)
      "Flipping arguments of additive monoid morphisms (`AddMonoidHom.flip`)
      as an additive monoid morphism."]
def flipHom {_ : MulOneClass M} {_ : MulOneClass N} {_ : CommMonoid P} :
    (M →* N →* P) →* N →* M →* P
-- Mathlib/Topology/Constructions.lean
/-- The product of a neighborhood of `s` and a neighborhood of `t` is a neighborhood of `s ×ˢ t`,
formulated in terms of a filter inequality. -/
theorem nhdsSet_prod_le (s : Set X) (t : Set Y) : 𝓝ˢ (s ×ˢ t) ≤ 𝓝ˢ s ×ˢ 𝓝ˢ t
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem natDegree_mul (hp : p ≠ 0) (hq : q ≠ 0) : (p*q).natDegree = p.natDegree + q.natDegree
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
@[simp] lemma to_WithUpperSet_symm_eq : (@toUpperSet α).symm = ofUpperSet