ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/NumberTheory/SmoothNumbers.lean
@[gcongr] lemma factoredNumbers_mono {s t : Finset ℕ} (hst : s ≤ t) :
    factoredNumbers s ⊆ factoredNumbers t
-- Mathlib/Data/List/Nodup.lean
@[simp]
theorem nodup_reverse {l : List α} : Nodup (reverse l) ↔ Nodup l
-- Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean
@[simp]
lemma inr_comp_binaryCoproductIso_inv :
    coprod.inr ≫ (binaryCoproductIso F G).inv = (Limits.coprod.inr (X := F))
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ici_prod_Ici (a : α) (b : β) : Ici a ×ˢ Ici b = Ici (a, b)
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean
theorem condexpL1CLM_of_aestronglyMeasurable' (f : α →₁[μ] F') (hfm : AEStronglyMeasurable' m f μ) :
    condexpL1CLM F' hm μ f = f
-- Mathlib/Algebra/Algebra/Hom.lean
theorem comp_algebraMap : (φ : A →+* B).comp (algebraMap R A) = algebraMap R B
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem rat_inf_continuous_lemma {ε : α} {a₁ a₂ b₁ b₂ : α} :
    abs (a₁ - b₁) < ε → abs (a₂ - b₂) < ε → abs (a₁ ⊓ a₂ - b₁ ⊓ b₂) < ε
-- Mathlib/Topology/ContinuousOn.lean
theorem nhdsWithin_pi_eq' {I : Set ι} (hI : I.Finite) (s : ∀ i, Set (π i)) (x : ∀ i, π i) :
    𝓝[pi I s] x = ⨅ i, comap (fun x => x i) (𝓝 (x i) ⊓ ⨅ (_ : i ∈ I), 𝓟 (s i))
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem ContDiffOn.rpow (hf : ContDiffOn ℝ n f s) (hg : ContDiffOn ℝ n g s) (h : ∀ x ∈ s, f x ≠ 0) :
    ContDiffOn ℝ n (fun x => f x ^ g x) s
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
theorem LinearMap.toMatrix₂_mul (B : M₁ →ₗ[R] M₂ →ₗ[R] R) (M : Matrix m m' R) :
    LinearMap.toMatrix₂ b₁ b₂ B * M =
      LinearMap.toMatrix₂ b₁ b₂' (B.compl₂ (toLin b₂' b₂ M))
-- Mathlib/Algebra/Lie/Free.lean
theorem Rel.subLeft (a : lib R X) {b c : lib R X} (h : Rel R X b c) : Rel R X (a - b) (a - c)
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
/-- If the restriction to a set `s` of a σ-algebra `m` is included in the restriction to `s` of
another σ-algebra `m₂` (hypothesis `hs`), the set `s` is `m` measurable and a function `f` supported
on `s` is `m`-strongly-measurable, then `f` is also `m₂`-strongly-measurable. -/
theorem stronglyMeasurable_of_measurableSpace_le_on {α E} {m m₂ : MeasurableSpace α}
    [TopologicalSpace E] [Zero E] {s : Set α} {f : α → E} (hs_m : MeasurableSet[m] s)
    (hs : ∀ t, MeasurableSet[m] (s ∩ t) → MeasurableSet[m₂] (s ∩ t))
    (hf : StronglyMeasurable[m] f) (hf_zero : ∀ x ∉ s, f x = 0) :
    StronglyMeasurable[m₂] f
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
@[simp]
theorem preimage_comap_zeroLocus (s : Set R) : comap f ⁻¹' zeroLocus s = zeroLocus (f '' s)
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
@[simp]
lemma coeff_Φ (n : ℤ) : (W.Φ n).coeff (n.natAbs ^ 2) = 1
-- .lake/packages/lean4/src/lean/Init/Control/Lawful/Instances.lean
theorem seqLeft_eq [Monad m] [LawfulMonad m] (x : StateT σ m α) (y : StateT σ m β) : x <* y = const β <$> x <*> y
-- Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean
protected lemma connected_iff {H : G.Subgraph} :
    H.Connected ↔ H.Preconnected ∧ H.verts.Nonempty
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
/-- The pure tensors (i.e. the elements of the image of `PiTensorProduct.tprod`) span
the tensor product. -/
theorem span_tprod_eq_top :
    Submodule.span R (Set.range (tprod R)) = (⊤ : Submodule R (⨂[R] i, s i))
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
@[simp]
theorem map_int_add (m : ℤ) (x : ℝ) : f (m + x) = m + f x
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
theorem Matrix.toLinearMap₂'_comp (M : Matrix n m R) (P : Matrix n n' R) (Q : Matrix m m' R) :
    LinearMap.compl₁₂ (Matrix.toLinearMap₂' R M) (toLin' P) (toLin' Q) =
      toLinearMap₂' R (Pᵀ * M * Q)
-- Mathlib/Data/Finset/Sum.lean
@[simp]
theorem disjSum_eq_empty : s.disjSum t = ∅ ↔ s = ∅ ∧ t = ∅
-- Mathlib/InformationTheory/Hamming.lean
@[simp]
theorem toHamming_symm_eq : (@toHamming _ β).symm = ofHamming
-- Mathlib/Data/Finsupp/Defs.lean
@[simp]
theorem mapRange_single {f : M → N} {hf : f 0 = 0} {a : α} {b : M} :
    mapRange f hf (single a b) = single a (f b)
-- Mathlib/Data/NNReal/Basic.lean
@[simp]
theorem _root_.Real.toNNReal_coe {r : ℝ≥0} : Real.toNNReal r = r
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
/-- Radon-Nikodym derivative with respect to the scalar multiple of a measure.
See also `rnDeriv_smul_right'`, which requires sigma-finite `ν` and `μ`. -/
theorem rnDeriv_smul_right (ν μ : Measure α) [IsFiniteMeasure ν]
    [ν.HaveLebesgueDecomposition μ] {r : ℝ≥0} (hr : r ≠ 0) :
    ν.rnDeriv (r • μ) =ᵐ[μ] r⁻¹ • ν.rnDeriv μ
-- Mathlib/Analysis/Calculus/FDeriv/RestrictScalars.lean
@[fun_prop]
theorem HasFDerivWithinAt.of_restrictScalars {g' : E →L[𝕜] F} (h : HasFDerivWithinAt f g' s x)
    (H : f'.restrictScalars 𝕜 = g') : HasFDerivWithinAt f f' s x
-- Mathlib/Logic/Denumerable.lean
private theorem right_inverse_aux : ∀ n, toFunAux (ofNat s n) = n
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem mfderiv_sub (hf : MDifferentiableAt I 𝓘(𝕜, E') f z)
    (hg : MDifferentiableAt I 𝓘(𝕜, E') g z) :
    (by exact mfderiv I 𝓘(𝕜, E') (f - g) z : TangentSpace I z →L[𝕜] E') =
      (by exact mfderiv I 𝓘(𝕜, E') f z) - (by exact mfderiv I 𝓘(𝕜, E') g z)
-- Mathlib/Data/Set/Sups.lean
theorem singleton_infs_singleton : ({a} ⊼ {b} : Set α) = {a ⊓ b}
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Mul.lean
@[simp]
lemma opNNNorm_mul_apply (x : 𝕜') : ‖mul 𝕜 𝕜' x‖₊ = ‖x‖₊
-- Mathlib/Analysis/MeanInequalitiesPow.lean
/-- Specific case of Jensen's inequality for sums of powers -/
theorem pow_sum_div_card_le_sum_pow {f : ι → ℝ} (n : ℕ) (hf : ∀ a ∈ s, 0 ≤ f a) :
    (∑ x ∈ s, f x) ^ (n + 1) / (s.card : ℝ) ^ n ≤ ∑ x ∈ s, f x ^ (n + 1)
-- Mathlib/Data/Complex/Abs.lean
private theorem abs_re_le_abs (z : ℂ) : |z.re| ≤ abs z
-- Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean
/-- Taking the reverse of the product a list of $n$ vectors lifted via `ι` is equivalent to
taking the product of the reverse of that list. -/
theorem reverse_prod_map_ι :
    ∀ l : List M, reverse (l.map <| ι Q).prod = (l.map <| ι Q).reverse.prod
-- Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean
theorem hasDerivAt_log (hx : x ≠ 0) : HasDerivAt log x⁻¹ x
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
@[simp]
theorem Differentiable.cosh (hc : Differentiable ℝ f) : Differentiable ℝ fun x => Real.cosh (f x)
-- Mathlib/Topology/ContinuousOn.lean
@[simp]
theorem continuousOn_singleton (f : α → β) (a : α) : ContinuousOn f {a}
-- Mathlib/CategoryTheory/Shift/SingleFunctors.lean
@[reassoc (attr := simp)]
lemma hom_inv_id_hom_app (e : F ≅ G) (n : A) (X : C) :
    (e.hom.hom n).app X ≫ (e.inv.hom n).app X = 𝟙 _
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
theorem dimH_univ (e : X ≃ᵢ Y) : dimH (univ : Set X) = dimH (univ : Set Y)
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem tendsto_translationNumber_of_dist_bounded_aux (x : ℕ → ℝ) (C : ℝ)
    (H : ∀ n : ℕ, dist ((f ^ n) 0) (x n) ≤ C) :
    Tendsto (fun n : ℕ => x (2 ^ n) / 2 ^ n) atTop (𝓝 <| τ f)
-- Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Basic.lean
/-- Construct a right unitor from specified limit cones.
-/
@[simps]
def BinaryFan.rightUnitor {X : C} {s : Cone (Functor.empty.{0} C)} (P : IsLimit s)
    {t : BinaryFan X s.pt} (Q : IsLimit t) : t.pt ≅ X
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem mem_map_range {R S : Type*} [Ring R] [Ring S] (f : R →+* S) {p : S[X]} :
    p ∈ (mapRingHom f).range ↔ ∀ n, p.coeff n ∈ f.range
-- Mathlib/Data/Fin/Basic.lean
theorem last_sub (i : Fin (n + 1)) : last n - i = Fin.rev i
-- Mathlib/RingTheory/Localization/LocalizationLocalization.lean
/-- Given submodules `M ⊆ R` and `N ⊆ S = M⁻¹R`, with `f : R →+* S` the localization map, if
`N` contains all the units of `S`, then `N ⁻¹ S = T = (f⁻¹ N) ⁻¹ R`. I.e., the localization of a
localization is a localization.
-/
theorem localization_localization_isLocalization_of_has_all_units [IsLocalization N T]
    (H : ∀ x : S, IsUnit x → x ∈ N) : IsLocalization (N.comap (algebraMap R S)) T
-- Mathlib/Analysis/LocallyConvex/ContinuousOfBounded.lean
theorem LinearMap.clmOfExistsBoundedImage_coe {f : E →ₗ[𝕜] F}
    {h : ∃ V ∈ 𝓝 (0 : E), Bornology.IsVonNBounded 𝕜 (f '' V)} :
    (f.clmOfExistsBoundedImage h : E →ₗ[𝕜] F) = f
-- Mathlib/Data/Nat/Fib/Zeckendorf.lean
lemma lt_fib_greatestFib_add_one (n : ℕ) : n < fib (greatestFib n + 1)
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem toL1_smul' (f : α → β) (hf : Integrable f μ) (k : 𝕜) :
    toL1 (k • f) (hf.smul k) = k • toL1 f hf
-- Mathlib/Tactic/NormNum/Basic.lean
theorem isintCast {R} [Ring R] (n m : ℤ) :
    IsInt n m → IsInt (n : R) m
-- Mathlib/Data/List/MinMax.lean
theorem maximum_ne_bot_of_ne_nil (h : l ≠ []) : l.maximum ≠ ⊥
-- Mathlib/Algebra/Lie/Weights/RootSystem.lean
/-- `±α` are the only `K`-multiples of a root `α` that are also (non-zero) roots. -/
lemma eq_neg_or_eq_of_eq_smul (hβ : β.IsNonZero) (k : K) (h : (β : H → K) = k • α) :
    β = -α ∨ β = α
-- Mathlib/Algebra/Order/Floor.lean
theorem add_one_le_ceil_iff : n + 1 ≤ ⌈a⌉₊ ↔ (n : α) < a
-- Mathlib/LinearAlgebra/Trace.lean
theorem trace_prodMap :
    trace R (M × N) ∘ₗ prodMapLinear R M N M N R =
      (coprod id id : R × R →ₗ[R] R) ∘ₗ prodMap (trace R M) (trace R N)
-- Mathlib/Order/Hom/Lattice.lean
theorem Codisjoint.map (h : Codisjoint a b) : Codisjoint (f a) (f b)
-- Mathlib/Order/CompleteLattice.lean
/-- When taking the supremum of `f : ι → α`, the elements of `ι` on which `f` gives `⊥` can be
dropped, without changing the result. -/
@[simp]
theorem iSup_ne_bot_subtype (f : ι → α) : ⨆ i : { i // f i ≠ ⊥ }, f i = ⨆ i, f i
-- Mathlib/CategoryTheory/Monoidal/End.lean
@[simp] theorem endofunctorMonoidalCategory_leftUnitor_hom_app (F : C ⥤ C) (X : C) :
  (λ_ F).hom.app X = 𝟙 _
-- Mathlib/Order/Heyting/Hom.lean
@[simp]
theorem comp_id (f : BiheytingHom α β) : f.comp (BiheytingHom.id α) = f
-- Mathlib/Data/Set/Pairwise/Basic.lean
protected theorem Pairwise.insert (hs : s.Pairwise r) (h : ∀ b ∈ s, a ≠ b → r a b ∧ r b a) :
    (insert a s).Pairwise r
-- Mathlib/Algebra/Polynomial/Module/AEval.lean
@[simp] lemma C_smul (t : R) (m : AEval R M a) : C t • m = t • m
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem sup_principal {s t : Set α} : 𝓟 s ⊔ 𝓟 t = 𝓟 (s ∪ t)
-- Mathlib/CategoryTheory/Limits/Shapes/StrongEpi.lean
/-- The composition of two strong monomorphisms is a strong monomorphism. -/
theorem strongMono_comp [StrongMono f] [StrongMono g] : StrongMono (f ≫ g)
-- Mathlib/Order/WithBot.lean
lemma forall_lt_iff_eq_top {x : WithTop α} : (∀ y : α, y < x) ↔ x = ⊤
-- Mathlib/Order/Filter/Basic.lean
theorem comap_neBot_iff {f : Filter β} {m : α → β} : NeBot (comap m f) ↔ ∀ t ∈ f, ∃ a, m a ∈ t
-- Mathlib/Algebra/Group/Center.lean
@[to_additive (attr := simp) addCentralizer_addCentralizer_addCentralizer]
lemma centralizer_centralizer_centralizer (S : Set M) :
    S.centralizer.centralizer.centralizer = S.centralizer
-- Mathlib/Algebra/Module/Equiv/Defs.lean
@[simp]
theorem symm_mk (f h₁ h₂ h₃ h₄) :
    (⟨⟨⟨e, h₁⟩, h₂⟩, f, h₃, h₄⟩ : M ≃ₛₗ[σ] M₂).symm =
      { symm_mk.aux e f h₁ h₂ h₃ h₄ with
        toFun := f
        invFun := e }
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem filter_subset (s : Finset α) : s.filter p ⊆ s
-- Mathlib/Analysis/Calculus/Deriv/Inv.lean
theorem deriv_inv : deriv (fun x => x⁻¹) x = -(x ^ 2)⁻¹
-- .lake/packages/batteries/Batteries/Data/RBMap/Basic.lean
theorem all_iff {t : RBNode α} : t.all p ↔ t.All (p ·)
-- Mathlib/Data/Set/Image.lean
theorem image_eq_image {f : α → β} (hf : Injective f) : f '' s = f '' t ↔ s = t
-- Mathlib/Data/Real/EReal.lean
theorem add_lt_add_of_lt_of_le' {x y z t : EReal} (h : x < y) (h' : z ≤ t) (hbot : t ≠ ⊥)
    (htop : t = ⊤ → z = ⊤ → x = ⊥) : x + z < y + t
-- Mathlib/Topology/MetricSpace/GromovHausdorff.lean
theorem toGHSpace_lipschitz :
    LipschitzWith 1 (NonemptyCompacts.toGHSpace : NonemptyCompacts X → GHSpace)
-- Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean
theorem singularPart_add_withDensity_rnDeriv_eq [c.HaveLebesgueDecomposition μ] :
    c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = c
-- Mathlib/Analysis/Calculus/Dslope.lean
theorem eqOn_dslope_sub_smul (f : 𝕜 → E) (a : 𝕜) :
    EqOn (dslope (fun x => (x - a) • f x) a) f {a}ᶜ
-- Mathlib/Logic/Equiv/Option.lean
theorem removeNone_some {x : α} (h : ∃ x', e (some x) = some x') :
    some (removeNone e x) = e (some x)
-- Mathlib/MeasureTheory/Function/Floor.lean
@[measurability]
theorem Measurable.fract [BorelSpace R] {f : α → R} (hf : Measurable f) :
    Measurable fun x => Int.fract (f x)
-- Mathlib/Algebra/Group/Submonoid/Basic.lean
/-- A dependent version of `Submonoid.closure_induction`.  -/
@[to_additive (attr := elab_as_elim) "A dependent version of `AddSubmonoid.closure_induction`. "]
theorem closure_induction' (s : Set M) {p : ∀ x, x ∈ closure s → Prop}
    (mem : ∀ (x) (h : x ∈ s), p x (subset_closure h)) (one : p 1 (one_mem _))
    (mul : ∀ x hx y hy, p x hx → p y hy → p (x * y) (mul_mem hx hy)) {x} (hx : x ∈ closure s) :
    p x hx
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[simp]
theorem ofLeftInverse_symm_apply {g : S → R} {f : R →+* S} (h : Function.LeftInverse g f)
    (x : f.range) : (ofLeftInverse h).symm x = g x
-- Mathlib/Data/Set/Function.lean
lemma SurjOn.iterate {f : α → α} {s : Set α} (h : SurjOn f s s) : ∀ n, SurjOn f^[n] s s
-- Mathlib/Order/Filter/Pointwise.lean
theorem zero_smul_filter_nonpos : (0 : α) • g ≤ 0
-- Mathlib/Data/Nat/GCD/Basic.lean
@[simp]
theorem gcd_self_add_right (m n : ℕ) : gcd m (m + n) = gcd m n
-- Mathlib/Analysis/BoxIntegral/Partition/Split.lean
theorem splitUpper_le : I.splitUpper i x ≤ I
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
/-- The complex cosine function is everywhere differentiable, with the derivative `-sin x`. -/
theorem hasDerivAt_cos (x : ℂ) : HasDerivAt cos (-sin x) x
-- Mathlib/CategoryTheory/Bicategory/NaturalTransformation/Oplax.lean
/-- Vertical composition of modifications. -/
@[simps]
def vcomp (Γ : Modification η θ) (Δ : Modification θ ι) : Modification η ι
-- Mathlib/Algebra/Order/Ring/Basic.lean
theorem lt_of_pow_lt_pow_left (n : ℕ) (hb : 0 ≤ b) (h : a ^ n < b ^ n) : a < b
-- Mathlib/Order/Basic.lean
/-- To prove associativity of a commutative binary operation `○`, we only to check
`(a ○ b) ○ c ≤ a ○ (b ○ c)` for all `a`, `b`, `c`. -/
theorem associative_of_commutative_of_le {f : α → α → α} (comm : Commutative f)
    (assoc : ∀ a b c, f (f a b) c ≤ f a (f b c)) : Associative f
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
protected theorem neg_eq_neg_one_mul : ∀ a : Int, -a = -1 * a
-- Mathlib/MeasureTheory/Covering/VitaliFamily.lean
theorem eventually_filterAt_measurableSet (x : α) : ∀ᶠ a in v.filterAt x, MeasurableSet a
-- Mathlib/Combinatorics/Pigeonhole.lean
/-- The pigeonhole principle for finitely many pigeons counted by heads: given a function between
finite sets `s` and `t` and a number `b` such that `card t • b ≤ card s`, there exists `y ∈ t` such
that its preimage in `s` has at least `b` elements.
See also `Finset.exists_lt_card_fiber_of_nsmul_lt_card_of_maps_to` for a stronger statement. -/
theorem exists_le_card_fiber_of_nsmul_le_card_of_maps_to (hf : ∀ a ∈ s, f a ∈ t) (ht : t.Nonempty)
    (hb : t.card • b ≤ s.card) : ∃ y ∈ t, b ≤ (s.filter fun x => f x = y).card
-- Mathlib/Logic/Function/Basic.lean
protected theorem bijective : Bijective f
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem IsNormal.eq_iff_zero_and_succ {f g : Ordinal.{u} → Ordinal.{u}} (hf : IsNormal f)
    (hg : IsNormal g) : f = g ↔ f 0 = g 0 ∧ ∀ a, f a = g a → f (succ a) = g (succ a)
-- Mathlib/Analysis/VonNeumannAlgebra/Basic.lean
@[simp]
theorem centralizer_centralizer (S : VonNeumannAlgebra H) :
    Set.centralizer (Set.centralizer (S : Set (H →L[ℂ] H))) = S
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem not_limZero_of_not_congr_zero {f : CauSeq _ abv} (hf : ¬f ≈ 0) : ¬LimZero f
-- Mathlib/MeasureTheory/Integral/IntervalAverage.lean
theorem interval_average_symm (f : ℝ → E) (a b : ℝ) : (⨍ x in a..b, f x) = ⨍ x in b..a, f x
-- Mathlib/CategoryTheory/ChosenFiniteProducts/FunctorCategory.lean
@[reassoc (attr := simp)]
lemma whiskerLeft_app_fst (F₁ : J ⥤ C) {F₂ F₂' : J ⥤ C} (g : F₂ ⟶ F₂') (j : J) :
    (F₁ ◁ g).app j ≫ fst _ _ = fst _ _
-- Mathlib/Data/List/Infix.lean
@[gcongr]
theorem drop_sublist_drop_left (l : List α) {m n : ℕ} (h : m ≤ n) : drop n l <+ drop m l
-- Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean
@[simp]
theorem midpoint_eq_left_iff {x y : P} : midpoint R x y = x ↔ x = y
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
@[measurability]
theorem measurableSet_le' : MeasurableSet { p : α × α | p.1 ≤ p.2 }
-- Mathlib/SetTheory/Ordinal/Basic.lean
/-- An ordinal lifted to the zero universe equals itself. -/
@[simp]
theorem lift_uzero (a : Ordinal.{u}) : lift.{0} a = a
-- Mathlib/Topology/Category/TopCat/Opens.lean
@[simp 1100]
theorem map_id_obj' (U) (p) : (map (𝟙 X)).obj ⟨U, p⟩ = ⟨U, p⟩
-- Mathlib/Algebra/Polynomial/Taylor.lean
theorem taylor_injective {R} [CommRing R] (r : R) : Function.Injective (taylor r)
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem smul_imI : (s • a).imI = s • a.imI
-- Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean
@[fun_prop, aesop unsafe 30% apply (rule_sets := [Measurable])]
theorem Measurable.aemeasurable (h : Measurable f) : AEMeasurable f μ
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem inv_eq : I⁻¹ = 1 / I
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem map_constants (φ : M →[L] N) (c : L.Constants) : φ c = c
-- Mathlib/RingTheory/Ideal/Quotient.lean
protected theorem nontrivial {I : Ideal R} (hI : I ≠ ⊤) : Nontrivial (R ⧸ I)
-- .lake/packages/batteries/Batteries/Data/AssocList.lean
@[simp] theorem toList_mapKey (f : α → δ) (l : AssocList α β) :
    (mapKey f l).toList = l.toList.map (fun (a, b) => (f a, b))
-- Mathlib/Order/Filter/Lift.lean
theorem map_lift_eq2 {g : Set β → Filter γ} {m : α → β} (hg : Monotone g) :
    (map m f).lift g = f.lift (g ∘ image m)
-- Mathlib/NumberTheory/ArithmeticFunction.lean
theorem cardFactors_apply {n : ℕ} : Ω n = n.primeFactorsList.length
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
theorem curryFinFinset_apply_const {k l n : ℕ} {s : Finset (Fin n)} (hk : s.card = k)
    (hl : sᶜ.card = l) (f : MultilinearMap R (fun _ : Fin n => M') M₂) (x y : M') :
    (curryFinFinset R M₂ M' hk hl f (fun _ => x) fun _ => y) =
      f (s.piecewise (fun _ => x) fun _ => y)
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem inv_antitoneOn_Iio :
    AntitoneOn (fun x : α ↦ x⁻¹) (Set.Iio 0)
-- Mathlib/Order/Directed.lean
theorem Directed.mono_comp (r : α → α → Prop) {ι} {rb : β → β → Prop} {g : α → β} {f : ι → α}
    (hg : ∀ ⦃x y⦄, r x y → rb (g x) (g y)) (hf : Directed r f) : Directed rb (g ∘ f)
-- Mathlib/RepresentationTheory/Maschke.lean
lemma sumOfConjugates_apply (v : W) : π.sumOfConjugates G v = ∑ g : G, π.conjugate g v
-- Mathlib/Analysis/CstarAlgebra/Basic.lean
theorem nnnorm_star_mul_self {x : E} : ‖x⋆ * x‖₊ = ‖x‖₊ * ‖x‖₊
-- Mathlib/Algebra/GroupWithZero/Center.lean
lemma center_units_subset : center G₀ˣ ⊆ ((↑) : G₀ˣ → G₀) ⁻¹' center G₀
-- Mathlib/Order/MinMax.lean
theorem min_lt_min_right_iff : min a b < min a c ↔ b < c ∧ b < a
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem isLeast_csInf (hs : s.Nonempty) : IsLeast s (sInf s)
-- Mathlib/Order/OrdContinuous.lean
theorem comp (hg : RightOrdContinuous g) (hf : RightOrdContinuous f) : RightOrdContinuous (g ∘ f)
-- Mathlib/Topology/NhdsSet.lean
theorem mem_nhdsSet_empty : s ∈ 𝓝ˢ (∅ : Set X)
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean
/-- The tangent of an angle in a right-angled triangle as a ratio of sides. -/
theorem tan_angle_of_angle_eq_pi_div_two {p₁ p₂ p₃ : P} (h : ∠ p₁ p₂ p₃ = π / 2) :
    Real.tan (∠ p₂ p₃ p₁) = dist p₁ p₂ / dist p₃ p₂
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem setLIntegral_empty (f : α → ℝ≥0∞) : ∫⁻ x in ∅, f x ∂μ = 0
-- Mathlib/RingTheory/EssentialFiniteness.lean
lemma EssFiniteType.aux (σ : Subalgebra R S)
    (hσ : ∀ s : S, ∃ t ∈ σ, IsUnit t ∧ s * t ∈ σ)
    (τ : Set T) (t : T) (ht : t ∈ Algebra.adjoin S τ) :
    ∃ s ∈ σ, IsUnit s ∧ s • t ∈ σ.map (IsScalarTower.toAlgHom R S T) ⊔ Algebra.adjoin R τ
-- Mathlib/RingTheory/Localization/BaseChange.lean
/-- The forward direction of `isLocalizedModule_iff_isBaseChange`. It is also used to prove the
other direction. -/
theorem IsLocalizedModule.isBaseChange [IsLocalizedModule S f] : IsBaseChange A f
-- Mathlib/LinearAlgebra/CliffordAlgebra/BaseChange.lean
theorem toBaseChange_comp_involute (Q : QuadraticForm R V) :
    (toBaseChange A Q).comp (involute : CliffordAlgebra (Q.baseChange A) →ₐ[A] _) =
      (Algebra.TensorProduct.map (AlgHom.id _ _) involute).comp (toBaseChange A Q)
-- Mathlib/Algebra/Field/Subfield.lean
/-- Closure of a subfield `S` equals `S`. -/
theorem closure_eq (s : Subfield K) : closure (s : Set K) = s
-- Mathlib/Order/Monotone/Basic.lean
protected theorem StrictAnti.comp (hg : StrictAnti g) (hf : StrictAnti f) : StrictMono (g ∘ f)
-- Mathlib/Topology/ContinuousOn.lean
theorem nhdsWithin_le_nhds {a : α} {s : Set α} : 𝓝[s] a ≤ 𝓝 a
-- Mathlib/AlgebraicGeometry/OpenImmersion.lean
/-- The canonical map from the restriction to the subspace. -/
@[simps! val_base, simps! (config := .lemmasOnly) val_c_app]
def Scheme.ofRestrict : X.restrict h ⟶ X
-- Mathlib/Analysis/Complex/Basic.lean
theorem im_tsum {f : α → ℂ} (h : Summable f) : (∑' a, f a).im = ∑' a, (f a).im
-- Mathlib/Data/List/Enum.lean
theorem get?_enumFrom (n) (l : List α) (m) :
    get? (enumFrom n l) m = (get? l m).map fun a => (n + m, a)
-- Mathlib/Data/Rat/Defs.lean
@[simp] lemma mk'_pow (num : ℤ) (den : ℕ) (hd hdn) (n : ℕ) :
    mk' num den hd hdn ^ n = mk' (num ^ n) (den ^ n)
      (by simp [Nat.pow_eq_zero, hd]) (by rw [Int.natAbs_pow]; exact hdn.pow _ _)
-- Mathlib/Data/Sigma/Order.lean
theorem le_def [LT ι] [∀ i, LE (α i)] {a b : Σₗ i, α i} :
    a ≤ b ↔ a.1 < b.1 ∨ ∃ h : a.1 = b.1, h.rec a.2 ≤ b.2
-- Mathlib/Analysis/InnerProductSpace/EuclideanDist.lean
theorem closedBall_eq_preimage (x : E) (r : ℝ) :
    closedBall x r = toEuclidean ⁻¹' Metric.closedBall (toEuclidean x) r
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_dite (f : ∀ i, p i → α) (g : ∀ i, ¬p i → α) :
    ⨅ i, (if h : p i then f i h else g i h) = (⨅ (i) (h : p i), f i h) ⊓ ⨅ (i) (h : ¬p i), g i h
-- Mathlib/Data/List/Basic.lean
theorem takeI_eq_take : ∀ {n} {l : List α}, n ≤ length l → takeI n l = take n l
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
theorem toNonUnitalSubsemiring_inj {S U : NonUnitalSubalgebra R A} :
    S.toNonUnitalSubsemiring = U.toNonUnitalSubsemiring ↔ S = U
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem take_drop : ∀ (m n : Nat) (l : List α), take n (drop m l) = drop m (take (m + n) l)
-- Mathlib/MeasureTheory/PiSystem.lean
theorem has_diff {s₁ s₂ : Set α} (h₁ : d.Has s₁) (h₂ : d.Has s₂) (h : s₂ ⊆ s₁) :
    d.Has (s₁ \ s₂)
-- Mathlib/Topology/Algebra/Valued/ValuationTopology.lean
/-- A valued ring is a ring that comes equipped with a distinguished valuation. The class `Valued`
is designed for the situation that there is a canonical valuation on the ring.

TODO: show that there always exists an equivalent valuation taking values in a type belonging to
the same universe as the ring.

See Note [forgetful inheritance] for why we extend `UniformSpace`, `UniformAddGroup`. -/
class Valued (R : Type u) [Ring R] (Γ₀ : outParam (Type v))
  [LinearOrderedCommGroupWithZero Γ₀] extends UniformSpace R, UniformAddGroup R where
  v : Valuation R Γ₀
  is_topological_valuation : ∀ s, s ∈ 𝓝 (0 : R) ↔ ∃ γ : Γ₀ˣ, { x : R | v x < γ } ⊆ s
-- Mathlib/RingTheory/Congruence/Opposite.lean
lemma op_iff {c : RingCon R} {x y : Rᵐᵒᵖ} : c.op x y ↔ c y.unop x.unop
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
@[simp, mfld_simps]
theorem mk_symm (e : PartialEquiv H E) (a b c d) :
    (ModelWithCorners.mk e a b c d : ModelWithCorners 𝕜 E H).symm = e.symm
-- Mathlib/RingTheory/FreeCommRing.lean
@[simp, norm_cast]
protected theorem coe_add (x y : FreeRing α) : ↑(x + y) = (x : FreeCommRing α) + y
-- Mathlib/Topology/Category/TopCat/Opens.lean
@[simp 1100]
theorem op_map_id_obj (U : (Opens X)ᵒᵖ) : (map (𝟙 X)).op.obj U = U
-- Mathlib/Algebra/Order/Sub/Defs.lean
@[simp]
theorem add_tsub_cancel_right (a b : α) : a + b - b = a