ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/EuclideanDomain/Basic.lean
@[simp]
theorem lcm_eq_zero_iff {x y : R} : lcm x y = 0 ↔ x = 0 ∨ y = 0
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_const_add_Ioi : (fun x => a + x) ⁻¹' Ioi b = Ioi (b - a)
-- Mathlib/Topology/Sober.lean
protected theorem isIrreducible (h : IsGenericPoint x S) : IsIrreducible S
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem mapRange.zeroHom_id : mapRange.zeroHom (ZeroHom.id M) = ZeroHom.id (α →₀ M)
-- Mathlib/Data/Complex/Exponential.lean
theorem exp_sum {α : Type*} (s : Finset α) (f : α → ℂ) :
    exp (∑ x ∈ s, f x) = ∏ x ∈ s, exp (f x)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem pos_pow_of_pos {n : Nat} (m : Nat) (h : 0 < n) : 0 < n^m
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
theorem singleton_eq (c : Char) : singleton c = ⟨[c]⟩
-- Mathlib/Order/Sublattice.lean
@[simp, norm_cast] lemma coe_copy (L : Sublattice α) (s : Set α) (hs) : L.copy s hs = s
-- Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean
theorem isTheta_exp_arg_mul_im (hl : IsBoundedUnder (· ≤ ·) l fun x => |(g x).im|) :
    (fun x => Real.exp (arg (f x) * im (g x))) =Θ[l] fun _ => (1 : ℝ)
-- Mathlib/GroupTheory/SpecificGroups/KleinFour.lean
@[to_additive]
lemma eq_finset_univ [Fintype G] [DecidableEq G]
    {x y : G} (hx : x ≠ 1) (hy : y ≠ 1) (hxy : x ≠ y) : {x * y, x, y, (1 : G)} = Finset.univ
-- Mathlib/Order/CompleteLattice.lean
@[simp]
theorem sSup_diff_singleton_bot (s : Set α) : sSup (s \ {⊥}) = sSup s
-- Mathlib/Topology/UnitInterval.lean
theorem mem_iff_one_sub_mem {t : ℝ} : t ∈ I ↔ 1 - t ∈ I
-- Mathlib/RingTheory/MatrixAlgebra.lean
@[simp]
theorem matrixEquivTensor_apply (M : Matrix n n A) :
    matrixEquivTensor R A n M = ∑ p : n × n, M p.1 p.2 ⊗ₜ stdBasisMatrix p.1 p.2 1
-- Mathlib/Data/Finset/Lattice.lean
theorem max_mem_image_coe {s : Finset α} (hs : s.Nonempty) :
    s.max ∈ (s.image (↑) : Finset (WithBot α))
-- Mathlib/Analysis/Convex/Side.lean
theorem not_sOppSide_self (s : AffineSubspace R P) (x : P) : ¬s.SOppSide x x
-- Mathlib/CategoryTheory/Localization/Composition.lean
lemma of_comp (W₃ : MorphismProperty C₁)
    [L₁.IsLocalization W₁] [(L₁ ⋙ L₂).IsLocalization W₃]
    (hW₁₃ : W₁ ≤ W₃) (hW₂₃ : W₂ = W₃.map L₁) :
    L₂.IsLocalization W₂
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem biSup_measure_Iic [Preorder α] {s : Set α} (hsc : s.Countable)
    (hst : ∀ x : α, ∃ y ∈ s, x ≤ y) (hdir : DirectedOn (· ≤ ·) s) :
    ⨆ x ∈ s, μ (Iic x) = μ univ
-- Mathlib/Algebra/Polynomial/Reverse.lean
@[simp]
theorem coeff_one_reverse (f : R[X]) : coeff (reverse f) 1 = nextCoeff f
-- Mathlib/MeasureTheory/Function/Egorov.lean
theorem notConvergentSeq_antitone [Preorder ι] : Antitone (notConvergentSeq f g n)
-- Mathlib/Data/Finset/NoncommProd.lean
@[simp]
theorem noncommFoldr_coe (l : List α) (comm) (b : β) :
    noncommFoldr f (l : Multiset α) comm b = l.foldr f b
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_eq_rpow_iff {x y : ℝ≥0} {z : ℝ} (hz : z ≠ 0) : x ^ z = y ^ z ↔ x = y
-- Mathlib/Order/Filter/Curry.lean
theorem prod_mem_curry {α β : Type*} {l : Filter α} {m : Filter β} {s : Set α} {t : Set β}
    (hs : s ∈ l) (ht : t ∈ m) : s ×ˢ t ∈ l.curry m
-- Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean
@[fun_prop]
theorem continuous_rpow_const {q : ℝ} (h : 0 ≤ q) : Continuous (fun x : ℝ => x ^ q)
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem contained_C1 : contained (π (C1 C ho) (ord I · < o)) o
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean
lemma Homeomorph.measurableEmbedding (h : γ ≃ₜ γ₂) : MeasurableEmbedding h
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem natCast_def (n : ℕ) : (n : k[G]) = single (0 : G) (n : k)
-- Mathlib/CategoryTheory/FintypeCat.lean
@[simp]
lemma hom_inv_id_apply {X Y : FintypeCat} (f : X ≅ Y) (x : X) : f.inv (f.hom x) = x
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
theorem closedUnderRestriction' {G : StructureGroupoid H} [ClosedUnderRestriction G]
    {e : PartialHomeomorph H H} (he : e ∈ G) {s : Set H} (hs : IsOpen s) : e.restr s ∈ G
-- Mathlib/Analysis/NormedSpace/PiTensorProduct/InjectiveSeminorm.lean
/-- The canonical continuous multilinear map from `E = Πᵢ Eᵢ` to `⨂[𝕜] i, Eᵢ`.
-/
@[simps!]
noncomputable def tprodL : ContinuousMultilinearMap 𝕜 E (⨂[𝕜] i, E i)
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
theorem orderOf_dvd_natCard {G : Type*} [Group G] (x : G) : orderOf x ∣ Nat.card G
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive]
theorem eq_inv_of_mul_eq_one_left (h : a * b = 1) : a = b⁻¹
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
@[simp]
theorem zeroIsoInitial_inv [HasInitial C] : zeroIsoInitial.inv = (0 : ⊥_ C ⟶ 0)
-- Mathlib/NumberTheory/LucasLehmer.lean
@[simp]
theorem add_fst (x y : X q) : (x + y).1 = x.1 + y.1
-- Mathlib/Data/Multiset/Lattice.lean
theorem le_sup {s : Multiset α} {a : α} (h : a ∈ s) : a ≤ s.sup
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean
private lemma uniformity_eq_seminorm :
    𝓤 (E →SL[σ₁₂] F) = ⨅ r > 0, 𝓟 {f | ‖f.1 - f.2‖ < r}
-- Mathlib/Algebra/Star/StarAlgHom.lean
@[simp]
theorem mk_coe (f : A →⋆ₙₐ[R] B) (h₁ h₂ h₃ h₄ h₅) :
    (⟨⟨⟨⟨f, h₁⟩, h₂, h₃⟩, h₄⟩, h₅⟩ : A →⋆ₙₐ[R] B) = f
-- Mathlib/Analysis/BoxIntegral/Partition/Measure.lean
theorem volume_apply (I : Box ι) :
    (volume : Measure (ι → ℝ)).toBoxAdditive I = ∏ i, (I.upper i - I.lower i)
-- Mathlib/Data/Multiset/Powerset.lean
theorem powersetCardAux_perm {n} {l₁ l₂ : List α} (p : l₁ ~ l₂) :
    powersetCardAux n l₁ ~ powersetCardAux n l₂
-- Mathlib/Analysis/SpecialFunctions/NonIntegrable.lean
/-- The function `fun x ↦ x⁻¹` is not integrable on any interval `(a, +∞)`. -/
theorem not_IntegrableOn_Ioi_inv {a : ℝ} :
    ¬ IntegrableOn (·⁻¹) (Ioi a)
-- Mathlib/Algebra/Group/Subgroup/Finite.lean
@[to_additive card_le_one_iff_eq_bot]
theorem card_le_one_iff_eq_bot [Finite H] : Nat.card H ≤ 1 ↔ H = ⊥
-- Mathlib/Probability/Distributions/Gamma.lean
lemma gammaPDF_eq (a r x : ℝ) :
    gammaPDF a r x = ENNReal.ofReal (if 0 ≤ x then
    r ^ a / (Gamma a) * x ^ (a-1) * exp (-(r * x)) else 0)
-- Mathlib/LinearAlgebra/Matrix/Charpoly/Minpoly.lean
@[simp]
theorem minpoly_toMatrix (b : Basis n R N) (f : N →ₗ[R] N) :
    minpoly R (toMatrix b b f) = minpoly R f
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem swapAt!_def (a : Array α) (i : Nat) (v : α) (h : i < a.size) :
    a.swapAt! i v = (a[i], a.set ⟨i, h⟩ v)
-- Mathlib/LinearAlgebra/Matrix/Diagonal.lean
theorem diagonal_comp_stdBasis (w : n → R) (i : n) :
    (diagonal w).toLin'.comp (LinearMap.stdBasis R (fun _ : n => R) i) =
      w i • LinearMap.stdBasis R (fun _ : n => R) i
-- Mathlib/MeasureTheory/Group/Prod.lean
@[to_additive]
theorem quasiMeasurePreserving_div_left_of_right_invariant [IsMulRightInvariant μ] (g : G) :
    QuasiMeasurePreserving (fun h : G => g / h) μ μ
-- Mathlib/Analysis/Normed/Group/Uniform.lean
@[to_additive (attr := simp)]
theorem dist_div_eq_dist_mul_right (a b c : E) : dist a (b / c) = dist (a * c) b
-- Mathlib/Analysis/Normed/Field/Basic.lean
theorem dist_inv_inv₀ {z w : α} (hz : z ≠ 0) (hw : w ≠ 0) :
    dist z⁻¹ w⁻¹ = dist z w / (‖z‖ * ‖w‖)
-- Mathlib/Topology/Algebra/GroupWithZero.lean
theorem Filter.Tendsto.div_const {x : G₀} (hf : Tendsto f l (𝓝 x)) (y : G₀) :
    Tendsto (fun a => f a / y) l (𝓝 (x / y))
-- Mathlib/CategoryTheory/Comma/Basic.lean
@[ext]
lemma hom_ext (f g : X ⟶ Y) (h₁ : f.left = g.left) (h₂ : f.right = g.right) : f = g
-- Mathlib/Algebra/Polynomial/HasseDeriv.lean
theorem hasseDeriv_C (r : R) (hk : 0 < k) : hasseDeriv k (C r) = 0
-- Mathlib/Data/List/Basic.lean
@[simp 1100]
theorem modifyHead_modifyHead (l : List α) (f g : α → α) :
    (l.modifyHead f).modifyHead g = l.modifyHead (g ∘ f)
-- Mathlib/Analysis/Convex/Topology.lean
/-- A convex set is preconnected. -/
protected theorem Convex.isPreconnected {s : Set E} (h : Convex ℝ s) : IsPreconnected s
-- Mathlib/Data/Matrix/RowCol.lean
@[simp] theorem row_zero [Zero α] : row ι (0 : n → α) = 0
-- Mathlib/CategoryTheory/Limits/Types.lean
@[simp]
theorem Colimit.w_apply' {F : J ⥤ Type v} {j j' : J} {x : F.obj j} (f : j ⟶ j') :
    colimit.ι F j' (F.map f x) = colimit.ι F j x
-- Mathlib/Data/Stream/Init.lean
theorem map_iterate (f : α → α) (a : α) : iterate f (f a) = map f (iterate f a)
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
/-- If every element belongs to at most `n` Finsets, then the sum of their sizes is at most `n`
times how many they are. -/
theorem sum_card_inter_le (h : ∀ a ∈ s, (B.filter (a ∈ ·)).card ≤ n) :
    (∑ t ∈ B, (s ∩ t).card) ≤ s.card * n
-- Mathlib/Combinatorics/SetFamily/Compression/Down.lean
theorem memberSubfamily_inter (a : α) (𝒜 ℬ : Finset (Finset α)) :
    (𝒜 ∩ ℬ).memberSubfamily a = 𝒜.memberSubfamily a ∩ ℬ.memberSubfamily a
-- Mathlib/Analysis/Calculus/Gradient/Basic.lean
theorem DifferentiableWithinAt.hasGradientWithinAt (h : DifferentiableWithinAt 𝕜 f s x) :
    HasGradientWithinAt f (gradientWithin f s x) s x
-- Mathlib/Analysis/Seminorm.lean
protected theorem coe_iSup_eq {ι : Sort*} {p : ι → Seminorm 𝕜 E} (hp : BddAbove (range p)) :
    ↑(⨆ i, p i) = ⨆ i, ((p i : Seminorm 𝕜 E) : E → ℝ)
-- Mathlib/LinearAlgebra/Projection.lean
@[simp]
theorem codRestrict_apply {f : M →ₗ[S] M} (h : IsProj m f) (x : M) : ↑(h.codRestrict x) = f x
-- Mathlib/Algebra/Polynomial/Coeff.lean
@[simp]
theorem coeff_mul_X (p : R[X]) (n : ℕ) : coeff (p * X) (n + 1) = coeff p n
-- Mathlib/Logic/Function/Defs.lean
@[simp] theorem comp_const (f : β → φ) (b : β) : f ∘ const α b = const α (f b)
-- Mathlib/Data/Nat/Nth.lean
@[simp] theorem nth_true (n : ℕ) : nth (fun _ ↦ True) n = n
-- Mathlib/Order/Zorn.lean
theorem zorn_preorder₀ (s : Set α)
    (ih : ∀ c ⊆ s, IsChain (· ≤ ·) c → ∃ ub ∈ s, ∀ z ∈ c, z ≤ ub) :
    ∃ m ∈ s, ∀ z ∈ s, m ≤ z → z ≤ m
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
/-- A variant of `Matrix.det_neg` with scalar multiplication by `Units ℤ` instead of multiplication
by `R`. -/
theorem det_neg_eq_smul (A : Matrix n n R) :
    det (-A) = (-1 : Units ℤ) ^ Fintype.card n • det A
-- Mathlib/Analysis/Complex/AbsMax.lean
/-- **Maximum modulus principle** on a connected set. Let `U` be a (pre)connected open set in a
complex normed space. Let `f : E → F` be a function that is complex differentiable on `U`. Suppose
that `‖f x‖` takes its maximum value on `U` at `c ∈ U`. Then `‖f x‖ = ‖f c‖` for all `x ∈ U`. -/
theorem norm_eqOn_of_isPreconnected_of_isMaxOn {f : E → F} {U : Set E} {c : E}
    (hc : IsPreconnected U) (ho : IsOpen U) (hd : DifferentiableOn ℂ f U) (hcU : c ∈ U)
    (hm : IsMaxOn (norm ∘ f) U c) : EqOn (norm ∘ f) (const E ‖f c‖) U
-- Mathlib/LinearAlgebra/Matrix/Hermitian.lean
theorem IsHermitian.conjTranspose {A : Matrix n n α} (h : A.IsHermitian) : Aᴴ.IsHermitian
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem univ_le_of_forall_fin_meas_le {μ : Measure α} (hm : m ≤ m0) [SigmaFinite (μ.trim hm)]
    (C : ℝ≥0∞) {f : Set α → ℝ≥0∞} (hf : ∀ s, MeasurableSet[m] s → μ s ≠ ∞ → f s ≤ C)
    (h_F_lim :
      ∀ S : ℕ → Set α, (∀ n, MeasurableSet[m] (S n)) → Monotone S → f (⋃ n, S n) ≤ ⨆ n, f (S n)) :
    f univ ≤ C
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[simp]
protected theorem neg_smul : -s • t = -(s • t)
-- Mathlib/ModelTheory/ElementaryMaps.lean
@[simp]
theorem refl_apply (x : M) : refl L M x = x
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem toFinsupp_pow (a : R[X]) (n : ℕ) : (a ^ n).toFinsupp = a.toFinsupp ^ n
-- Mathlib/Analysis/Normed/Ring/Seminorm.lean
@[simp]
theorem apply_one (x : R) : (1 : MulRingSeminorm R) x = if x = 0 then 0 else 1
-- Mathlib/RingTheory/Filtration.lean
theorem _root_.Ideal.stableFiltration_stable (I : Ideal R) (N : Submodule R M) :
    (I.stableFiltration N).Stable
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem X_ne_zero [Nontrivial R] : (X : R[X]) ≠ 0
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
theorem mem_row_iff {μ : YoungDiagram} {i : ℕ} {c : ℕ × ℕ} : c ∈ μ.row i ↔ c ∈ μ ∧ c.fst = i
-- Mathlib/AlgebraicTopology/SimplicialObject.lean
/-- Augment a simplicial object with an object. -/
@[simps]
def augment (X : SimplicialObject C) (X₀ : C) (f : X _[0] ⟶ X₀)
    (w : ∀ (i : SimplexCategory) (g₁ g₂ : ([0] : SimplexCategory) ⟶ i),
      X.map g₁.op ≫ f = X.map g₂.op ≫ f) :
    SimplicialObject.Augmented C
-- Mathlib/RingTheory/AdicCompletion/Basic.lean
@[simp]
theorem transitionMap_comp {m n k : ℕ} (hmn : m ≤ n) (hnk : n ≤ k) :
    transitionMap I M hmn ∘ₗ transitionMap I M hnk = transitionMap I M (hmn.trans hnk)
-- Mathlib/CategoryTheory/Monoidal/Mon_.lean
/-- A monoid object internal to a monoidal category.

When the monoidal category is preadditive, this is also sometimes called an "algebra object".
-/
structure Mon_ where
  X : C
  one : 𝟙_ C ⟶ X
  mul : X ⊗ X ⟶ X
  one_mul : (one ▷ X) ≫ mul = (λ_ X).hom := by aesop_cat
  mul_one : (X ◁ one) ≫ mul = (ρ_ X).hom := by aesop_cat
  -- Obviously there is some flexibility stating this axiom.
  -- This one has left- and right-hand sides matching the statement of `Monoid.mul_assoc`,
  -- and chooses to place the associator on the right-hand side.
  -- The heuristic is that unitors and associators "don't have much weight".
  mul_assoc : (mul ▷ X) ≫ mul = (α_ X X X).hom ≫ (X ◁ mul) ≫ mul := by aesop_cat
-- Mathlib/Topology/Category/TopCat/Yoneda.lean
theorem comp_yonedaPresheaf' : yonedaPresheaf F Y = F.op ⋙ yonedaPresheaf' Y
-- Mathlib/Algebra/BigOperators/Finprod.lean
@[to_additive (attr := simp)]
theorem finprod_false (f : False → M) : ∏ᶠ i, f i = 1
-- Mathlib/Algebra/Algebra/Hom.lean
@[deprecated map_add (since := "2024-06-26")]
protected theorem map_add (r s : A) : φ (r + s) = φ r + φ s
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem mk_le_mk {s t : Set G} (h_one) (h_mul) (h_inv) (h_one') (h_mul') (h_inv') :
    mk ⟨⟨s, h_one⟩, h_mul⟩ h_inv ≤ mk ⟨⟨t, h_one'⟩, h_mul'⟩ h_inv' ↔ s ⊆ t
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
lemma rpow_le_rpow_of_nonpos (hx : 0 < x) (hxy : x ≤ y) (hz : z ≤ 0) : y ^ z ≤ x ^ z
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem contained_C' : contained (C' C ho) o
-- Mathlib/Algebra/GroupWithZero/Hom.lean
lemma comp_assoc (f : α →*₀ β) (g : β →*₀ γ) (h : γ →*₀ δ) :
    (h.comp g).comp f = h.comp (g.comp f)
-- Mathlib/Topology/Algebra/InfiniteSum/Group.lean
@[to_additive]
theorem Multipliable.update (hf : Multipliable f) (b : β) [DecidableEq β] (a : α) :
    Multipliable (update f b a)
-- Mathlib/Analysis/NormedSpace/Int.lean
theorem norm_coe_units (e : ℤˣ) : ‖(e : ℤ)‖ = 1
-- Mathlib/Topology/Order/OrderClosed.lean
@[simp]
theorem closure_Ici (a : α) : closure (Ici a) = Ici a
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem realize_liftAt_one_self {n : ℕ} {φ : L.BoundedFormula α n} {v : α → M}
    {xs : Fin (n + 1) → M} : (φ.liftAt 1 n).Realize v xs ↔ φ.Realize v (xs ∘ castSucc)
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem UniformSpace.comap_inf {α γ} {u₁ u₂ : UniformSpace γ} {f : α → γ} :
    (u₁ ⊓ u₂).comap f = u₁.comap f ⊓ u₂.comap f
-- Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean
theorem volume_singleton {a : ℝ} : volume ({a} : Set ℝ) = 0
-- Mathlib/Topology/Bases.lean
theorem _root_.Set.Finite.isSeparable {s : Set α} (hs : s.Finite) : IsSeparable s
-- Mathlib/Data/Set/Image.lean
theorem surjective_onto_range : Surjective (rangeFactorization f)
-- Mathlib/Algebra/Category/ModuleCat/Simple.lean
theorem simple_iff_isSimpleModule' (M : ModuleCat R) : Simple M ↔ IsSimpleModule R M
-- Mathlib/Algebra/Algebra/Subalgebra/MulOpposite.lean
@[simp]
theorem unop_le_unop_iff {S₁ S₂ : Subalgebra R Aᵐᵒᵖ} : S₁.unop ≤ S₂.unop ↔ S₁ ≤ S₂
-- Mathlib/Order/WellFoundedSet.lean
protected theorem PartiallyWellOrderedOn.prod {t : Set β} (hs : PartiallyWellOrderedOn s r)
    (ht : PartiallyWellOrderedOn t r') :
    PartiallyWellOrderedOn (s ×ˢ t) fun x y : α × β => r x.1 y.1 ∧ r' x.2 y.2
-- Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean
/-- `CliffordAlgebra.reverseEquiv` as an `AlgEquiv` to the opposite algebra -/
@[simps! apply]
def reverseOpEquiv : CliffordAlgebra Q ≃ₐ[R] (CliffordAlgebra Q)ᵐᵒᵖ
-- Mathlib/Algebra/GCDMonoid/Basic.lean
@[simp]
theorem gcd_one_right [NormalizedGCDMonoid α] (a : α) : gcd a 1 = 1
-- Mathlib/Probability/Kernel/MeasurableIntegral.lean
theorem StronglyMeasurable.integral_kernel_prod_left ⦃f : β → α → E⦄
    (hf : StronglyMeasurable (uncurry f)) : StronglyMeasurable fun y => ∫ x, f x y ∂κ y
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
theorem restrict_withDensity' [SFinite μ] (s : Set α) (f : α → ℝ≥0∞) :
    (μ.withDensity f).restrict s = (μ.restrict s).withDensity f
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem isCoprime_mul_unit_left_right : IsCoprime y (x * z) ↔ IsCoprime y z
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem eq_pow_of_mul_eq_pow {a b c : Associates α} (ha : a ≠ 0) (hb : b ≠ 0)
    (hab : ∀ d, d ∣ a → d ∣ b → ¬Prime d) {k : ℕ} (h : a * b = c ^ k) :
    ∃ d : Associates α, a = d ^ k
-- Mathlib/Data/Real/Sqrt.lean
@[continuity, fun_prop]
theorem continuous_sqrt : Continuous sqrt
-- Mathlib/Data/Nat/PartENat.lean
theorem dom_of_le_of_dom {x y : PartENat} : x ≤ y → y.Dom → x.Dom
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
@[simp]
theorem isLittleO_norm_left : (fun x => ‖f' x‖) =o[l] g ↔ f' =o[l] g
-- Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
@[simp (high)]
theorem fork_π_app_walkingParallelPair_one :
    (fork F U).π.app WalkingParallelPair.one = res F U ≫ leftRes F U
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem emod_eq_zero_of_dvd : ∀ {a b : Int}, a ∣ b → b % a = 0
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
/-- The identity morphism on a bimodule object. -/
@[simps]
def id' (M : Bimod A B) : Hom M M
-- Mathlib/NumberTheory/PythagoreanTriples.lean
private theorem coprime_sq_sub_sq_add_of_odd_even {m n : ℤ} (h : Int.gcd m n = 1) (hm : m % 2 = 1)
    (hn : n % 2 = 0) : Int.gcd (m ^ 2 - n ^ 2) (m ^ 2 + n ^ 2) = 1
-- Mathlib/Data/Stream/Init.lean
theorem cons_append_stream (a : α) (l : List α) (s : Stream' α) :
    appendStream' (a::l) s = a::appendStream' l s
-- Mathlib/Order/CompleteBooleanAlgebra.lean
@[simp]
theorem sSup_eq : sSup s = unit
-- Mathlib/Topology/Inseparable.lean
@[simp]
lemma stableUnderSpecialization_compl_iff {s : Set X} :
    StableUnderSpecialization sᶜ ↔ StableUnderGeneralization s
-- Mathlib/NumberTheory/SmoothNumbers.lean
/-- The product of the prime factors of `n` that are in `s` is an `s`-factored number. -/
lemma prod_mem_factoredNumbers (s : Finset ℕ) (n : ℕ) :
    (n.primeFactorsList.filter (· ∈ s)).prod ∈ factoredNumbers s
-- Mathlib/Topology/Bases.lean
theorem isTopologicalBasis_of_subbasis_of_inter {r : Set (Set α)} (hsg : t = generateFrom r)
    (hsi : ∀ ⦃s⦄, s ∈ r → ∀ ⦃t⦄, t ∈ r → s ∩ t ∈ r) : IsTopologicalBasis (insert univ r)
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
/-- Generalized eigenvalues are actually just eigenvalues. -/
@[simp]
theorem hasGenEigenvalue_iff_hasEigenvalue {f : End R M} {μ : R} {k : ℕ} (hk : 0 < k) :
    f.HasGenEigenvalue μ k ↔ f.HasEigenvalue μ
-- Mathlib/Data/Matroid/Dual.lean
theorem dual_injective : Function.Injective (dual : Matroid α → Matroid α)
-- Mathlib/RingTheory/MvPowerSeries/Inverse.lean
protected theorem eq_inv_iff_mul_eq_one {φ ψ : MvPowerSeries σ k} (h : constantCoeff σ k ψ ≠ 0) :
    φ = ψ⁻¹ ↔ φ * ψ = 1
-- Mathlib/Algebra/Quaternion.lean
theorem rank_eq_four [StrongRankCondition R] : Module.rank R ℍ[R] = 4
-- Mathlib/Algebra/Polynomial/Div.lean
theorem eval_divByMonic_pow_rootMultiplicity_ne_zero {p : R[X]} (a : R) (hp : p ≠ 0) :
    eval a (p /ₘ (X - C a) ^ rootMultiplicity a p) ≠ 0
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
@[simp]
theorem inner_rightAngleRotation_right (x y : E) : ⟪x, J y⟫ = -ω x y
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
theorem inv_def (e : P₁ ≃ᵃ[k] P₁) : e⁻¹ = e.symm
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem dist_pow_map_zero_mul_translationNumber_le (n : ℕ) :
    dist ((f ^ n) 0) (n * f.translationNumber) ≤ 1
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
theorem coe_injective : Function.Injective (Coe.coe : MvPolynomial σ R → MvPowerSeries σ R)
-- Mathlib/Algebra/Lie/Weights/Killing.lean
lemma traceForm_eq_zero_of_mem_ker_of_mem_span_coroot {α : Weight K H L} {x y : H}
    (hx : x ∈ α.ker) (hy : y ∈ K ∙ coroot α) :
    traceForm K H L x y = 0
-- Mathlib/Algebra/Algebra/Operations.lean
theorem mem_mul_span_singleton {x y : A} : x ∈ P * span R {y} ↔ ∃ z ∈ P, z * y = x
-- Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
theorem adjunction_homEquiv (X : Scheme) (R : CommRingCatᵒᵖ) :
    ΓSpec.adjunction.homEquiv X R = locallyRingedSpaceAdjunction.homEquiv X.1 R
-- Mathlib/Topology/Instances/CantorSet.lean
lemma quarter_mem_preCantorSet (n : ℕ) : 1/4 ∈ preCantorSet n
-- Mathlib/RingTheory/Ideal/MinimalPrime.lean
theorem Ideal.exists_minimalPrimes_le [J.IsPrime] (e : I ≤ J) : ∃ p ∈ I.minimalPrimes, p ≤ J
-- Mathlib/Topology/Separation.lean
lemma embedding_iff_inducing [TopologicalSpace Y] [T0Space X] {f : X → Y} :
    Embedding f ↔ Inducing f
-- Mathlib/Topology/ContinuousFunction/Basic.lean
@[simp]
theorem coe_trans : (f.trans g : C(α, γ)) = (g : C(β, γ)).comp f
-- Mathlib/LinearAlgebra/QuadraticForm/Isometry.lean
/-- The identity isometry from a quadratic form to itself. -/
@[simps!]
def id (Q : QuadraticMap R M N) : Q →qᵢ Q
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem enumFrom_cons : (a::as).enumFrom i = (i, a) :: as.enumFrom (i+1)
-- Mathlib/RingTheory/Ideal/Over.lean
theorem exists_coeff_ne_zero_mem_comap_of_non_zero_divisor_root_mem {r : S}
    (r_non_zero_divisor : ∀ {x}, x * r = 0 → x = 0) (hr : r ∈ I) {p : R[X]} :
    p ≠ 0 → p.eval₂ f r = 0 → ∃ i, p.coeff i ≠ 0 ∧ p.coeff i ∈ I.comap f
-- Mathlib/Data/ENat/Basic.lean
@[simp]
theorem recTopCoe_zero {C : ℕ∞ → Sort*} (d : C ⊤) (f : ∀ a : ℕ, C a) : @recTopCoe C d f 0 = f 0
-- Mathlib/Data/Set/Function.lean
@[simp]
theorem restrict_extend_compl_range (f : α → β) (g : α → γ) (g' : β → γ) :
    (range f)ᶜ.restrict (extend f g g') = g' ∘ Subtype.val
-- Mathlib/Topology/MetricSpace/PiNat.lean
protected theorem dist_nonneg (x y : ∀ n, E n) : 0 ≤ dist x y
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem preimage_Ici : ((↑) : ℤ → α) ⁻¹' Set.Ici a = Set.Ici ⌈a⌉
-- Mathlib/Combinatorics/Enumerative/Catalan.lean
theorem succ_mul_catalan_eq_centralBinom (n : ℕ) : (n + 1) * catalan n = n.centralBinom
-- Mathlib/GroupTheory/Coxeter/Length.lean
theorem not_isRightDescent_iff {w : W} {i : B} :
    ¬cs.IsRightDescent w i ↔ ℓ (w * s i) = ℓ w + 1
-- Mathlib/AlgebraicGeometry/Pullbacks.lean
@[simp, reassoc]
theorem t'_fst_fst_fst (i j k : 𝒰.J) :
    t' 𝒰 f g i j k ≫ pullback.fst _ _ ≫ pullback.fst _ _ ≫ pullback.fst _ _ =
      pullback.fst _ _ ≫ pullback.snd _ _
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
@[simp]
theorem mem_toSubring (x : K) : x ∈ A.toSubring ↔ x ∈ A
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
/-- Closure of a non-unital subsemiring `S` equals `S`. -/
theorem closure_eq (s : NonUnitalSubsemiring R) : closure (s : Set R) = s
-- Mathlib/Analysis/Normed/Group/Uniform.lean
@[to_additive]
theorem MonoidHomClass.antilipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
    (h : ∀ x, ‖x‖ ≤ K * ‖f x‖) : AntilipschitzWith K f
-- Mathlib/Data/List/Basic.lean
@[simp] theorem head_replicate (n : ℕ) (a : α) (h) : head (replicate n a) h = a
-- Mathlib/LinearAlgebra/PerfectPairing.lean
@[simp] lemma coe_toLinearMap_flip : e.flip = (↑e : N →ₗ[R] Dual R M).flip
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem coeSubmodule_comap :
    (N'.comap f : Submodule R M) = (N' : Submodule R M').comap (f : M →ₗ[R] M')
-- Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
/-- Constant polynomials are weighted homogeneous of degree 0. -/
theorem isWeightedHomogeneous_C (w : σ → M) (r : R) :
    IsWeightedHomogeneous w (C r : MvPolynomial σ R) 0
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
theorem eq_false_iff : {b : Bool} → b = false ↔ b ≠ true
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ico_subset_Icc_union_Ioo : Ico a c ⊆ Icc a b ∪ Ioo b c
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The `s -ᵥ s` lies within the `vectorSpan k s`. -/
theorem vsub_set_subset_vectorSpan (s : Set P) : s -ᵥ s ⊆ ↑(vectorSpan k s)