ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem single_vecMul [Fintype m] [DecidableEq m] [NonUnitalNonAssocSemiring R] (M : Matrix m n R)
    (i : m) (x : R) : Pi.single i x ᵥ* M = fun j => x * M i j
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem neg_left {M : Type*} [AddCommGroup M] [TopologicalSpace M] [TopologicalAddGroup M]
    {v : VectorMeasure α M} {w : VectorMeasure α N} (h : v ≪ᵥ w) : -v ≪ᵥ w
-- Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean
theorem gramSchmidtOrthonormalBasis_inv_triangular' {i j : ι} (hij : i < j) :
    (gramSchmidtOrthonormalBasis h f).repr (f i) j = 0
-- Mathlib/Topology/Bases.lean
protected theorem _root_.Embedding.firstCountableTopology {β : Type*}
    [TopologicalSpace β] [FirstCountableTopology β] {f : α → β} (hf : Embedding f) :
    FirstCountableTopology α
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
/-- An induction principle for closure membership. If `p` holds for `1` and all elements of
`k` and their inverse, and is preserved under multiplication, then `p` holds for all elements of
the closure of `k`. -/
@[to_additive (attr := elab_as_elim)
  "An induction principle for additive closure membership. If `p` holds for `0` and all
  elements of `k` and their negation, and is preserved under addition, then `p` holds for all
  elements of the additive closure of `k`."]
theorem closure_induction'' {p : (g : G) → g ∈ closure s → Prop}
    (mem : ∀ x (hx : x ∈ s), p x (subset_closure hx))
    (inv_mem : ∀ x (hx : x ∈ s), p x⁻¹ (inv_mem (subset_closure hx)))
    (one : p 1 (one_mem _))
    (mul : ∀ x y hx hy, p x hx → p y hy → p (x * y) (mul_mem hx hy))
    {x} (h : x ∈ closure s) : p x h
-- Mathlib/Algebra/Group/TypeTags.lean
@[simp]
theorem ofMul_one [One α] : @Additive.ofMul α 1 = 0
-- Mathlib/Algebra/Category/ModuleCat/Basic.lean
@[simp]
theorem forget₂_obj (X : ModuleCat R) :
    (forget₂ (ModuleCat R) AddCommGrp).obj X = AddCommGrp.of X
-- Mathlib/Dynamics/PeriodicPts.lean
@[to_additive (attr := simp)]
theorem zpow_mod_period_smul (j : ℤ) {g : G} {a : α} :
    g ^ (j % (period g a : ℤ)) • a = g ^ j • a
-- Mathlib/Data/Fin/Basic.lean
protected lemma lt_iff_le_and_ne : a < b ↔ a ≤ b ∧ a ≠ b
-- Mathlib/Data/Num/Lemmas.lean
theorem lt_iff_cmp {m n} : m < n ↔ cmp m n = Ordering.lt
-- Mathlib/Tactic/Ring/Basic.lean
theorem cast_rat {n : ℤ} {d : ℕ} {R} [DivisionRing R] {a : R} :
    IsRat a n d → a = Rat.rawCast n d + 0
-- Mathlib/CategoryTheory/Comma/Basic.lean
/-- The functor `Comma L R ⥤ Comma L R` induced by the identity natural transformation on `R` is
    naturally isomorphic to the identity functor. -/
@[simps!]
def mapRightId : mapRight L (𝟙 R) ≅ 𝟭 _
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive]
theorem comp_lift {P' : Type*} [Monoid P'] (f : P →* P') (g₁ : M →* P) (g₂ : N →* P) :
    f.comp (lift g₁ g₂) = lift (f.comp g₁) (f.comp g₂)
-- Mathlib/MeasureTheory/Measure/Restrict.lean
@[simp]
theorem ae_restrict_biUnion_finset_iff (s : ι → Set α) (t : Finset ι) (p : α → Prop) :
    (∀ᵐ x ∂μ.restrict (⋃ i ∈ t, s i), p x) ↔ ∀ i ∈ t, ∀ᵐ x ∂μ.restrict (s i), p x
-- Mathlib/RingTheory/WittVector/Basic.lean
private theorem ghostFun_natCast (i : ℕ) : ghostFun (i : 𝕎 R) = i
-- Mathlib/Dynamics/Minimal.lean
@[to_additive]
theorem dense_of_nonempty_smul_invariant [IsMinimal M α] {s : Set α} (hne : s.Nonempty)
    (hsmul : ∀ c : M, c • s ⊆ s) : Dense s
-- Mathlib/Algebra/Algebra/Unitization.lean
theorem inl_mul_inr [Semiring R] [NonUnitalNonAssocSemiring A] [DistribMulAction R A] (r : R)
    (a : A) : ((inl r : Unitization R A) * a) = ↑(r • a)
-- Mathlib/Topology/Sheaves/Stalks.lean
theorem stalkFunctor_map_injective_of_app_injective {F G : Presheaf C X} (f : F ⟶ G)
    (h : ∀ U : Opens X, Function.Injective (f.app (op U))) (x : X) :
    Function.Injective ((stalkFunctor C x).map f)
-- Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
lemma liftCochain_v_descCochain_v (p₁ p₂ p₃ : ℤ) (h₁₂ : p₁ + n = p₂) (h₂₃ : p₂ + n' = p₃)
    (q : ℤ) (hq : p₁ + m = q) :
    (liftCochain φ α β h).v p₁ p₂ h₁₂ ≫ (descCochain φ α' β' h').v p₂ p₃ h₂₃ =
      α.v p₁ q hq ≫ α'.v q p₃ (by omega) + β.v p₁ p₂ h₁₂ ≫ β'.v p₂ p₃ h₂₃
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- Negating the first vector produces the same angle as negating the second vector. -/
theorem oangle_neg_left_eq_neg_right (x y : V) : o.oangle (-x) y = o.oangle x (-y)
-- Mathlib/Data/List/MinMax.lean
theorem minimum_le_of_mem : a ∈ l → (minimum l : WithTop α) = m → m ≤ a
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
theorem or_iff_right_of_imp (ha : a → b) : (a ∨ b) ↔ b
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
/-- The `nnnorm` of a function is controlled by the supremum of the pointwise `nnnorm`s. -/
theorem nnnorm_le (C : ℝ≥0) : ‖f‖₊ ≤ C ↔ ∀ x : α, ‖f x‖₊ ≤ C
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
theorem infEdist_closure_pos_iff_not_mem_closure {x : α} {E : Set α} :
    0 < infEdist x (closure E) ↔ x ∉ closure E
-- Mathlib/LinearAlgebra/Matrix/DotProduct.lean
@[simp]
lemma conjTranspose_mul_self_eq_zero {A : Matrix m n R} : Aᴴ * A = 0 ↔ A = 0
-- Mathlib/Data/Nat/Cast/Defs.lean
theorem three_add_one_eq_four [AddMonoidWithOne R] : 3 + 1 = (4 : R)
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem eval_one_map (f : R →+* S) (p : R[X]) : (p.map f).eval 1 = f (p.eval 1)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
/-- Given `f(A) = f(B)`, `ker f ≤ A`, and `ker f ≤ B`, deduce that `A = B`. -/
@[to_additive "Given `f(A) = f(B)`, `ker f ≤ A`, and `ker f ≤ B`, deduce that `A = B`."]
theorem map_injective_of_ker_le {H K : Subgroup G} (hH : f.ker ≤ H) (hK : f.ker ≤ K)
    (hf : map f H = map f K) : H = K
-- Mathlib/Order/Heyting/Regular.lean
protected theorem IsRegular.disjoint_compl_left_iff (ha : IsRegular a) :
    Disjoint aᶜ b ↔ b ≤ a
-- Mathlib/Data/Real/ConjExponents.lean
lemma mul_eq_add : p * q = p + q
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL2.lean
theorem integral_condexpL2_eq_of_fin_meas_real (f : Lp 𝕜 2 μ) (hs : MeasurableSet[m] s)
    (hμs : μ s ≠ ∞) : ∫ x in s, (condexpL2 𝕜 𝕜 hm f : α → 𝕜) x ∂μ = ∫ x in s, f x ∂μ
-- Mathlib/Algebra/Algebra/Defs.lean
/-- `mul_left_comm` for `Algebra`s when one element is from the base ring. -/
theorem left_comm (x : A) (r : R) (y : A) :
    x * (algebraMap R A r * y) = algebraMap R A r * (x * y)
-- Mathlib/Data/Int/Defs.lean
lemma neg_nat_succ (n : ℕ) : -(Nat.succ n : ℤ) = pred (-n)
-- Mathlib/MeasureTheory/Measure/Dirac.lean
/-- Dirac delta measures at two points are different if and only if the two points are different,
assuming the measurable space separates points. -/
lemma dirac_ne_dirac_iff [SeparatesPoints α] {x y : α} :
    Measure.dirac x ≠ Measure.dirac y ↔ x ≠ y
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem half_pos (h : 0 < a) : 0 < a / 2
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem as_sum (p : MvPolynomial σ R) : p = ∑ v ∈ p.support, monomial v (coeff v p)
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
@[simp]
theorem mk'_X_1 : (mk' X₀ X₁ d₀ succ').X 1 = X₁
-- Mathlib/Data/ENNReal/Real.lean
@[simp]
theorem toNNReal_lt_toNNReal (ha : a ≠ ∞) (hb : b ≠ ∞) : a.toNNReal < b.toNNReal ↔ a < b
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
/-- A characterization of weak convergence of probability measures by the condition that the
integrals of every continuous bounded nonnegative function converge to the integral of the function
against the limit measure. -/
theorem tendsto_iff_forall_lintegral_tendsto {γ : Type*} {F : Filter γ}
    {μs : γ → ProbabilityMeasure Ω} {μ : ProbabilityMeasure Ω} :
    Tendsto μs F (𝓝 μ) ↔
      ∀ f : Ω →ᵇ ℝ≥0,
        Tendsto (fun i => ∫⁻ ω, f ω ∂(μs i : Measure Ω)) F (𝓝 (∫⁻ ω, f ω ∂(μ : Measure Ω)))
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive]
theorem mk'_mul_cancel_left (x) (y : S) : f.mk' ((y : M) * x) y = f.toMap x
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
theorem closure_image_mem_nhds_of_uniformInducing {s : Set (α × α)} {e : α → β} (b : β)
    (he₁ : UniformInducing e) (he₂ : DenseInducing e) (hs : s ∈ 𝓤 α) :
    ∃ a, closure (e '' { a' | (a, a') ∈ s }) ∈ 𝓝 b
-- Mathlib/RingTheory/Norm/Defs.lean
theorem norm_eq_one_of_not_exists_basis (h : ¬∃ s : Finset S, Nonempty (Basis s R S)) (x : S) :
    norm R x = 1
-- Mathlib/Algebra/Algebra/Hom.lean
@[simp, norm_cast]
theorem coe_toRingHom (f : A →ₐ[R] B) : ⇑(f : A →+* B) = f
-- Mathlib/FieldTheory/IsPerfectClosure.lean
@[simp]
theorem lift_id : lift (RingHom.id K) j p = j
-- Mathlib/RingTheory/FiniteType.lean
theorem _root_.Subalgebra.fg_iff_finiteType (S : Subalgebra R A) : S.FG ↔ Algebra.FiniteType R S
-- Mathlib/Algebra/BigOperators/Finprod.lean
@[to_additive]
theorem finprod_dmem {s : Set α} [DecidablePred (· ∈ s)] (f : ∀ a : α, a ∈ s → M) :
    (∏ᶠ (a : α) (h : a ∈ s), f a h) = ∏ᶠ (a : α) (_ : a ∈ s), if h' : a ∈ s then f a h' else 1
-- Mathlib/Computability/TuringMachine.lean
@[simp]
theorem ListBlank.nth_map {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ')
    (l : ListBlank Γ) (n : ℕ) : (l.map f).nth n = f (l.nth n)
-- Mathlib/Order/RelSeries.lean
lemma monotone (x : LTSeries α) : Monotone x
-- Mathlib/Analysis/Calculus/LocalExtr/LineDeriv.lean
theorem IsLocalExtr.hasLineDerivAt_eq_zero (h : IsLocalExtr f a) (hd : HasLineDerivAt ℝ f f' a b) :
    f' = 0
-- Mathlib/Algebra/Associated/Basic.lean
theorem Associated.mul_left [Monoid α] (a : α) {b c : α} (h : b ~ᵤ c) : a * b ~ᵤ a * c
-- Mathlib/Topology/Algebra/ContinuousMonoidHom.lean
/-- The continuous homomorphism given by swapping components. -/
@[to_additive (attr := simps!) "The continuous homomorphism given by swapping components."]
def swap : ContinuousMonoidHom (A × B) (B × A)
-- Mathlib/Tactic/NormNum/Prime.lean
theorem isNat_prime_2 : {n n' : ℕ} →
    IsNat n n' → Nat.ble 2 n' = true → IsNat (minFac n') n' → n.Prime
-- Mathlib/Algebra/Group/Subgroup/MulOpposite.lean
@[to_additive]
theorem unop_sup (S₁ S₂ : Subgroup Gᵐᵒᵖ) : (S₁ ⊔ S₂).unop = S₁.unop ⊔ S₂.unop
-- Mathlib/CategoryTheory/Pi/Basic.lean
/-- The natural isomorphism between pulling back then evaluating, and just evaluating. -/
@[simps!]
def comapEvalIsoEval (h : J → I) (j : J) : comap C h ⋙ eval (C ∘ h) j ≅ eval C (h j)
-- Mathlib/Topology/Inseparable.lean
lemma SpecializingMap.stableUnderSpecialization_range (h : SpecializingMap f) :
    StableUnderSpecialization (range f)
-- Mathlib/Data/Finset/Basic.lean
theorem monotone_filter_right (s : Finset α) ⦃p q : α → Prop⦄ [DecidablePred p] [DecidablePred q]
    (h : p ≤ q) : s.filter p ⊆ s.filter q
-- Mathlib/Analysis/Normed/Order/UpperLower.lean
@[to_additive IsLowerSet.thickening]
protected theorem IsLowerSet.thickening' (hs : IsLowerSet s) (ε : ℝ) :
    IsLowerSet (thickening ε s)
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[norm_cast]
theorem natCast_le {m n : ℕ} : (m : Cardinal) ≤ n ↔ m ≤ n
-- Mathlib/MeasureTheory/Integral/Average.lean
theorem measure_smul_setAverage (f : α → E) {s : Set α} (h : μ s ≠ ∞) :
    (μ s).toReal • ⨍ x in s, f x ∂μ = ∫ x in s, f x ∂μ
-- Mathlib/Topology/Defs/Basic.lean
/-- A set is closed if its complement is open -/
class IsClosed (s : Set X) : Prop where
  /-- The complement of a closed set is an open set. -/
  isOpen_compl : IsOpen sᶜ
-- Mathlib/Topology/NoetherianSpace.lean
protected theorem _root_.Inducing.noetherianSpace [NoetherianSpace α] {i : β → α}
    (hi : Inducing i) : NoetherianSpace β
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
theorem isAdjointPair_id : IsAdjointPair B B 1 1
-- Mathlib/Algebra/Group/Units.lean
@[field_simps]
lemma divp_eq_div [DivisionMonoid α] (a : α) (u : αˣ) : a /ₚ u = a / u
-- Mathlib/RingTheory/Localization/Basic.lean
theorem mk'_eq_iff_mk'_eq {x₁ x₂} {y₁ y₂ : M} :
    mk' S x₁ y₁ = mk' S x₂ y₂ ↔ mk' P x₁ y₁ = mk' P x₂ y₂
-- Mathlib/RepresentationTheory/Action/Monoidal.lean
/-- A lax monoidal functor induces a lax monoidal functor between
the categories of `G`-actions within those categories. -/
@[simps!]
def mapActionLax (F : LaxMonoidalFunctor V W) (G : MonCat.{u}) :
    LaxMonoidalFunctor (Action V G) (Action W G)
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
theorem uniformEquicontinuousOn_finite [Finite ι] {F : ι → β → α} {S : Set β} :
    UniformEquicontinuousOn F S ↔ ∀ i, UniformContinuousOn (F i) S
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[to_additive]
theorem smul_set_iInter_subset (a : α) (t : ι → Set β) : (a • ⋂ i, t i) ⊆ ⋂ i, a • t i
-- Mathlib/Analysis/Complex/CauchyIntegral.lean
/-- **Cauchy integral formula**: if `f : ℂ → E` is continuous on a closed disc of radius `R` and is
complex differentiable at all but countably many points of its interior, then for any `w` in this
interior we have $\oint_{|z-c|=R}(z-w)^{-1}f(z)\,dz=2πif(w)$.
-/
theorem circleIntegral_sub_inv_smul_of_differentiable_on_off_countable {R : ℝ} {c w : ℂ} {f : ℂ → E}
    {s : Set ℂ} (hs : s.Countable) (hw : w ∈ ball c R) (hc : ContinuousOn f (closedBall c R))
    (hd : ∀ x ∈ ball c R \ s, DifferentiableAt ℂ f x) :
    (∮ z in C(c, R), (z - w)⁻¹ • f z) = (2 * π * I : ℂ) • f w
-- Mathlib/Data/NNReal/Basic.lean
@[simp]
lemma natCastle_toNNReal' {n : ℕ} {r : ℝ} : ↑n ≤ r.toNNReal ↔ n ≤ r ∨ n = 0
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
@[simp]
theorem intervalIntegrable_sin : IntervalIntegrable sin μ a b
-- Mathlib/Analysis/Complex/Tietze.lean
theorem Metric.instTietzeExtensionBall {𝕜 : Type v} [RCLike 𝕜] {E : Type w}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] [FiniteDimensional 𝕜 E] {r : ℝ} (hr : 0 < r) :
    TietzeExtension.{u, w} (Metric.ball (0 : E) r)
-- Mathlib/GroupTheory/Perm/Basic.lean
/-- A stronger version of `mul_right_injective` -/
@[simp]
theorem swap_mul_involutive (i j : α) : Function.Involutive (Equiv.swap i j * ·)
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem subtype_Ioi_eq : Ioi a = (Ioi (a : α)).subtype p
-- Mathlib/LinearAlgebra/QuotientPi.lean
theorem right_inv : Function.RightInverse (invFun p) (toFun p)
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem nontrivial_lowerCentralSeriesLast [Nontrivial M] [IsNilpotent R L M] :
    Nontrivial (lowerCentralSeriesLast R L M)
-- Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean
theorem zero : IsBoundedLinearMap 𝕜 fun _ : E => (0 : F)
-- Mathlib/Algebra/Category/HopfAlgebraCat/Basic.lean
@[simp] theorem toHopfAlgEquiv_symm (e : X ≅ Y) :
    toHopfAlgEquiv e.symm = (toHopfAlgEquiv e).symm
-- Mathlib/Data/Finset/Basic.lean
theorem Nonempty.toList_ne_nil {s : Finset α} (hs : s.Nonempty) : s.toList ≠ []
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
/-- If an element `p` of `FreeAddMonoid (R × Π i, s i)` lifts an element `x` of `⨂[R] i, s i`,
and if `a` is an element of `R`, then the list obtained by multiplying the first entry of each
element of `p` by `a` lifts `a • x`.
-/
lemma lifts_smul {x : ⨂[R] i, s i} {p : FreeAddMonoid (R × Π i, s i)} (h : p ∈ lifts x) (a : R) :
    List.map (fun (y : R × Π i, s i) ↦ (a * y.1, y.2)) p ∈ lifts (a • x)
-- Mathlib/Order/Bounds/Basic.lean
@[simp]
theorem upperBounds_union : upperBounds (s ∪ t) = upperBounds s ∩ upperBounds t
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive (attr := simp)]
theorem map_bot (f : F) : (⊥ : Submonoid M).map f = ⊥
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem _root_.Set.Countable.measure_zero (h : s.Countable) (μ : Measure α) [NoAtoms μ] :
    μ s = 0
-- Mathlib/Data/Matroid/Dual.lean
theorem dual_dep_iff_forall : (M✶.Dep I) ↔ (∀ B, M.Base B → (I ∩ B).Nonempty) ∧ I ⊆ M.E
-- Mathlib/Algebra/Star/Subalgebra.lean
theorem StarAlgEquiv.restrictScalars_injective :
    Function.Injective (StarAlgEquiv.restrictScalars R : (A ≃⋆ₐ[S] B) → A ≃⋆ₐ[R] B)
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem fmod_eq_of_lt {a b : Int} (H1 : 0 ≤ a) (H2 : a < b) : a.fmod b = a
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)]
theorem lift_inr_inl : lift (inr : M →* N ∗ M) inl = swap M N
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If `r` is a negative constant, `fun x ↦ r * f x` tends to infinity along a filter `l`
if and only if `f` tends to negative infinity along `l`. -/
theorem tendsto_const_mul_atTop_of_neg (hr : r < 0) :
    Tendsto (fun x => r * f x) l atTop ↔ Tendsto f l atBot
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[simp]
theorem add_apply {f g : ArithmeticFunction R} {n : ℕ} : (f + g) n = f n + g n
-- Mathlib/CategoryTheory/Shift/SingleFunctors.lean
@[simp]
lemma shiftIso_zero_inv_app (a : A) (X : C) :
    (F.shiftIso 0 a a (zero_add a)).inv.app X = (shiftFunctorZero D A).inv.app _
-- Mathlib/Data/Nat/Prime/Defs.lean
theorem minFac_has_prop {n : ℕ} (n1 : n ≠ 1) : minFacProp n (minFac n)
-- Mathlib/Data/List/MinMax.lean
@[simp]
theorem maximum_singleton (a : α) : maximum [a] = a
-- Mathlib/RingTheory/MvPolynomial/Symmetric.lean
@[simp]
theorem zero : IsSymmetric (0 : MvPolynomial σ R)
-- Mathlib/Data/Real/Irrational.lean
@[simp] theorem ne_ofNat (h : Irrational x) (n : ℕ) [n.AtLeastTwo] : x ≠ no_index (OfNat.ofNat n)
-- Mathlib/Data/Finsupp/Multiset.lean
theorem toMultiset_inf [DecidableEq α] (f g : α →₀ ℕ) :
    toMultiset (f ⊓ g) = toMultiset f ∩ toMultiset g
-- Mathlib/Analysis/BoundedVariation.lean
/-- A real function into a finite dimensional real vector space with bounded variation on a set
is differentiable almost everywhere in this set. -/
theorem ae_differentiableWithinAt {f : ℝ → V} {s : Set ℝ} (h : LocallyBoundedVariationOn f s)
    (hs : MeasurableSet s) : ∀ᵐ x ∂volume.restrict s, DifferentiableWithinAt ℝ f s x
-- Mathlib/Topology/UniformSpace/AbstractCompletion.lean
theorem compare_comp_eq_compare (γ : Type*) [TopologicalSpace γ]
    [T3Space γ] {f : α → γ} (cont_f : Continuous f) :
    letI := pkg.uniformStruct.toTopologicalSpace
    letI := pkg'.uniformStruct.toTopologicalSpace
    (∀ a : pkg.space,
      Filter.Tendsto f (Filter.comap pkg.coe (𝓝 a)) (𝓝 ((pkg.denseInducing.extend f) a))) →
      pkg.denseInducing.extend f ∘ pkg'.compare pkg = pkg'.denseInducing.extend f
-- Mathlib/Order/CompleteLattice.lean
@[congr]
theorem iInf_congr_Prop {p q : Prop} {f₁ : p → α} {f₂ : q → α} (pq : p ↔ q)
    (f : ∀ x, f₁ (pq.mpr x) = f₂ x) : iInf f₁ = iInf f₂
-- Mathlib/Topology/Instances/Matrix.lean
@[continuity]
theorem Continuous.matrix_reindex {A : X → Matrix l n R} (hA : Continuous A) (e₁ : l ≃ m)
    (e₂ : n ≃ p) : Continuous fun x => reindex e₁ e₂ (A x)
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem eval_divByMonic_eq_trailingCoeff_comp {p : R[X]} {t : R} :
    (p /ₘ (X - C t) ^ p.rootMultiplicity t).eval t = (p.comp (X + C t)).trailingCoeff
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_sum_le (s : Finset ι) (f : ι → R[X]) :
    degree (∑ i ∈ s, f i) ≤ s.sup fun b => degree (f b)
-- Mathlib/Algebra/MvPolynomial/Rename.lean
theorem rename_injective (f : σ → τ) (hf : Function.Injective f) :
    Function.Injective (rename f : MvPolynomial σ R → MvPolynomial τ R)
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
@[simp]
theorem neg_smul (g : GL(2, ℝ)⁺) (z : ℍ) : -g • z = g • z
-- Mathlib/Geometry/Manifold/Algebra/LieGroup.lean
theorem smoothAt_inv₀ {x : G} (hx : x ≠ 0) : SmoothAt I I (fun y ↦ y⁻¹) x
-- Mathlib/Combinatorics/SimpleGraph/Maps.lean
@[simp]
theorem coe_comp (f' : G' ≃g G'') (f : G ≃g G') : ⇑(f'.comp f) = f' ∘ f
-- Mathlib/Tactic/LinearCombination.lean
theorem eq_of_add_pow [Ring α] [NoZeroDivisors α] (n : ℕ) (p : (a:α) = b)
    (H : (a' - b')^n - (a - b) = 0) : a' = b'
-- Mathlib/RingTheory/AdicCompletion/Basic.lean
@[simp]
theorem transitionMap_comp_apply {m n k : ℕ} (hmn : m ≤ n) (hnk : n ≤ k)
    (x : M ⧸ (I ^ k • ⊤ : Submodule R M)) :
    transitionMap I M hmn (transitionMap I M hnk x) = transitionMap I M (hmn.trans hnk) x
-- Mathlib/Order/Lattice.lean
/-- Pointwise minimum of two antitone functions is an antitone function. -/
protected theorem min [Preorder α] [LinearOrder β] {f g : α → β} {s : Set α} (hf : AntitoneOn f s)
    (hg : AntitoneOn g s) : AntitoneOn (fun x => min (f x) (g x)) s
-- Mathlib/Data/Finset/Pointwise.lean
/-- Lift a `MonoidHom` to `Finset` via `image`. -/
@[to_additive (attr := simps) "Lift an `add_monoid_hom` to `Finset` via `image`"]
def imageMonoidHom [MulOneClass β] [FunLike F α β] [MonoidHomClass F α β] (f : F) :
    Finset α →* Finset β
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive] lemma zpow_mul_comm (a : G) (m n : ℤ) : a ^ m * a ^ n = a ^ n * a ^ m
-- Mathlib/Algebra/Category/ModuleCat/EpiMono.lean
theorem ker_eq_bot_of_mono [Mono f] : LinearMap.ker f = ⊥
-- Mathlib/Data/List/Sigma.lean
@[simp]
theorem kunion_nil : ∀ {l : List (Sigma β)}, kunion l [] = l
-- Mathlib/NumberTheory/NumberField/Units/Basic.lean
theorem coe_ne_zero (x : (𝓞 K)ˣ) : (x : K) ≠ 0
-- Mathlib/Topology/ContinuousOn.lean
theorem nhdsWithin_neBot_of_mem {s : Set α} {x : α} (hx : x ∈ s) : NeBot (𝓝[s] x)
-- Mathlib/CategoryTheory/Limits/Cones.lean
/-- `mapCone` commutes with `postcomposeEquivalence`
-/
@[simps!]
def mapConePostcomposeEquivalenceFunctor {α : F ≅ G} {c} :
    mapCone H ((Cones.postcomposeEquivalence α).functor.obj c) ≅
      (Cones.postcomposeEquivalence (isoWhiskerRight α H : _)).functor.obj (mapCone H c)
-- Mathlib/CategoryTheory/Bicategory/Kan/HasKan.lean
/-- The 1-morphism `h` commutes with the left Kan lift `f₊ g`. -/
@[simps!]
def lanLiftCompIso : f₊ (h ≫ g) ≅ h ≫ f₊ g
-- Mathlib/Algebra/Field/Basic.lean
theorem one_sub_div {a b : K} (h : b ≠ 0) : 1 - a / b = (b - a) / b
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem map_extChartAt_symm_nhdsWithin_range (x : M) :
    map (extChartAt I x).symm (𝓝[range I] extChartAt I x x) = 𝓝 x
-- Mathlib/Computability/Reduce.lean
private theorem le_refl (d : ManyOneDegree) : d ≤ d
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem isRegular_cof {o : Ordinal} (h : o.IsLimit) : IsRegular o.cof
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem continuousAt_iff_prod [TopologicalSpace β] {f : β → α} {b : β} :
    ContinuousAt f b ↔ Tendsto (fun x : β × β => (f x.1, f x.2)) (𝓝 (b, b)) (𝓤 α)
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
theorem single_mul_coeff_add [NonUnitalNonAssocSemiring R] {r : R} {x : HahnSeries Γ R} {a : Γ}
    {b : Γ} : (single b r * x).coeff (a + b) = r * x.coeff a
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Assoc.lean
@[reassoc (attr := simp)]
theorem pullbackAssoc_hom_snd_snd [HasPullback ((pullback.snd _ _ : Z₁ ⟶ X₂) ≫ f₃) f₄]
    [HasPullback f₁ ((pullback.fst _ _ : Z₂ ⟶ X₂) ≫ f₂)] :
    (pullbackAssoc f₁ f₂ f₃ f₄).hom ≫ pullback.snd _ _ ≫ pullback.snd _ _ = pullback.snd _ _
-- Mathlib/RingTheory/Valuation/Basic.lean
@[simp]
theorem mem_supp_iff (x : R) : x ∈ supp v ↔ v x = 0
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive mul_zsmul'] lemma zpow_mul (a : α) : ∀ m n : ℤ, a ^ (m * n) = (a ^ m) ^ n
-- Mathlib/Order/Hom/Basic.lean
theorem OrderIso.map_top' [LE α] [PartialOrder β] (f : α ≃o β) {x : α} {y : β} (hx : ∀ x', x' ≤ x)
    (hy : ∀ y', y' ≤ y) : f x = y
-- Mathlib/Algebra/Lie/Solvable.lean
theorem derivedSeriesOfIdeal_antitone {k l : ℕ} (h : l ≤ k) : D k I ≤ D l I
-- Mathlib/Analysis/Complex/AbelLimit.lean
lemma stolzCone_subset_stolzSet_aux {s : ℝ} (hs : 0 < s) :
    ∃ M ε, 0 < M ∧ 0 < ε ∧ {z : ℂ | 1 - ε < z.re} ∩ stolzCone s ⊆ stolzSet M
-- Mathlib/LinearAlgebra/Matrix/Hermitian.lean
/-- A block matrix `A.from_blocks B C D` is hermitian,
    if `A` and `D` are hermitian and `Bᴴ = C`. -/
theorem IsHermitian.fromBlocks {A : Matrix m m α} {B : Matrix m n α} {C : Matrix n m α}
    {D : Matrix n n α} (hA : A.IsHermitian) (hBC : Bᴴ = C) (hD : D.IsHermitian) :
    (A.fromBlocks B C D).IsHermitian
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem neg_imI : (-a).imI = -a.imI
-- Mathlib/Data/List/Basic.lean
theorem Sublist.of_cons_cons {l₁ l₂ : List α} {a b : α} (h : a :: l₁ <+ b :: l₂) : l₁ <+ l₂
-- Mathlib/Data/Multiset/Pi.lean
theorem cons_injective {a : α} {b : δ a} {s : Multiset α} (hs : a ∉ s) :
    Function.Injective (Pi.cons s a b)
-- Mathlib/Data/Real/Archimedean.lean
@[simp] nonrec lemma iInf_of_isEmpty {α : Sort*} [IsEmpty α] (f : α → ℝ) : ⨅ i, f i = 0
-- Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
theorem eq_one_of_pos_of_log_eq_zero {x : ℝ} (h₁ : 0 < x) (h₂ : log x = 0) : x = 1
-- Mathlib/Algebra/Periodic.lean
theorem Periodic.image_uIcc [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
    (hc : c ≠ 0) (a : α) : f '' uIcc a (a + c) = range f
-- Mathlib/Algebra/Module/Equiv/Defs.lean
protected theorem image_eq_preimage (s : Set M) : e '' s = e.symm ⁻¹' s