ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/FieldTheory/Separable.lean
theorem multiplicity_le_one_of_separable {p q : R[X]} (hq : ¬IsUnit q) (hsep : Separable p) :
    multiplicity q p ≤ 1
-- Mathlib/Geometry/Manifold/PartitionOfUnity.lean
/-- Let `M` be a smooth manifold with corners modelled on a finite dimensional real vector space.
Suppose also that `M` is a Hausdorff `σ`-compact topological space. Let `s` be a closed set
in `M` and `U : M → Set M` be a collection of sets such that `U x ∈ 𝓝 x` for every `x ∈ s`.
Then there exists a smooth bump covering of `s` that is subordinate to `U`. -/
theorem exists_isSubordinate [T2Space M] [SigmaCompactSpace M] (hs : IsClosed s)
    (hU : ∀ x ∈ s, U x ∈ 𝓝 x) :
    ∃ (ι : Type uM) (f : SmoothBumpCovering ι I M s), f.IsSubordinate U
-- Mathlib/Data/Stream/Init.lean
theorem any_def (p : α → Prop) (s : Stream' α) : Any p s = ∃ n, p (get s n)
-- Mathlib/CategoryTheory/Types.lean
@[simp]
theorem toEquiv_fun (i : X ≅ Y) : (i.toEquiv : X → Y) = i.hom
-- Mathlib/Data/Real/EReal.lean
lemma mul_div (a b c : EReal) : a * (b / c) = (a * b) / c
-- Mathlib/Order/Filter/Basic.lean
theorem forall_mem_nonempty_iff_neBot {f : Filter α} :
    (∀ s : Set α, s ∈ f → s.Nonempty) ↔ NeBot f
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Basic.lean
protected lemma EdgeDisjointTriangles.farFromTriangleFree (hG : G.EdgeDisjointTriangles)
    (tris_big : ε * (card α ^ 2 : ℕ) ≤ (G.cliqueFinset 3).card) :
    G.FarFromTriangleFree ε
-- Mathlib/Analysis/Convex/Strict.lean
theorem strictConvex_Ici (r : β) : StrictConvex 𝕜 (Ici r)
-- Mathlib/Order/Interval/Set/Disjoint.lean
@[simp]
theorem iUnion_Ioc_eq_Ioi_self_iff {f : ι → α} {a : α} :
    ⋃ i, Ioc a (f i) = Ioi a ↔ ∀ x, a < x → ∃ i, x ≤ f i
-- Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean
/-- **Ruzsa's triangle inequality**. Div-div-mul version. -/
@[to_additive "**Ruzsa's triangle inequality**. Sub-sub-add version."]
theorem card_div_mul_le_card_div_mul_card_mul (A B C : Finset α) :
    (A / C).card * B.card ≤ (A / B).card * (B * C).card
-- Mathlib/Probability/Distributions/Uniform.lean
@[simp]
theorem ofMultiset_apply (a : α) : ofMultiset s hs a = s.count a / (Multiset.card s)
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
@[simp]
theorem map_direction (s : AffineSubspace k P₁) :
    (s.map f).direction = s.direction.map f.linear
-- Mathlib/CategoryTheory/Galois/Examples.lean
/-- A nonempty finite `G`-set is connected if and only if the `G`-action is transitive. -/
theorem Action.isConnected_iff_transitive (X : Action FintypeCat (MonCat.of G)) [Nonempty X.V] :
    IsConnected X ↔ MulAction.IsPretransitive G X.V
-- Mathlib/Data/Complex/Exponential.lean
@[simp]
theorem abs_cos_add_sin_mul_I (x : ℝ) : abs (cos x + sin x * I) = 1
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem map_nhds_eq (x : H) : map I (𝓝 x) = 𝓝[range I] I x
-- Mathlib/Topology/ContinuousOn.lean
theorem continuous_if {p : α → Prop} {f g : α → β} [∀ a, Decidable (p a)]
    (hp : ∀ a ∈ frontier { x | p x }, f a = g a) (hf : ContinuousOn f (closure { x | p x }))
    (hg : ContinuousOn g (closure { x | ¬p x })) :
    Continuous fun a => if p a then f a else g a
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
protected theorem eq_ediv_of_mul_eq_right {a b c : Int}
    (H1 : a ≠ 0) (H2 : a * b = c) : b = c / a
-- Mathlib/Analysis/Convex/EGauge.lean
@[simp] lemma egauge_empty (x : E) : egauge 𝕜 ∅ x = ∞
-- Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean
theorem nhds_basis_closed_balanced [RegularSpace E] :
    (𝓝 (0 : E)).HasBasis (fun s : Set E => s ∈ 𝓝 (0 : E) ∧ IsClosed s ∧ Balanced 𝕜 s) id
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
protected theorem IsTrail.takeUntil {u v w : V} {p : G.Walk v w} (hc : p.IsTrail)
    (h : u ∈ p.support) : (p.takeUntil u h).IsTrail
-- Mathlib/Topology/IsLocalHomeomorph.lean
/-- An injective local homeomorphism is an open embedding. -/
theorem openEmbedding_of_injective (hf : IsLocalHomeomorph f) (hi : f.Injective) :
    OpenEmbedding f
-- Mathlib/Order/BooleanAlgebra.lean
@[simp]
theorem compl_eq_top : xᶜ = ⊤ ↔ x = ⊥
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem continuous_posPart [Fact (1 ≤ p)] : Continuous fun f : Lp ℝ p μ => posPart f
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean
/-- The second modified cyclotomic polyomial is `X + 1` if the characteristic of `R` is not `2`. -/
@[simp]
theorem cyclotomic'_two (R : Type*) [CommRing R] [IsDomain R] (p : ℕ) [CharP R p] (hp : p ≠ 2) :
    cyclotomic' 2 R = X + 1
-- Mathlib/Algebra/ModEq.lean
protected theorem add_right_cancel' (c : α) : a + c ≡ b + c [PMOD p] → a ≡ b [PMOD p]
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
protected theorem norm_compl_sum_single (hp : 0 < p.toReal) (f : lp E p) (s : Finset α) :
    ‖f - ∑ i ∈ s, lp.single p i (f i)‖ ^ p.toReal = ‖f‖ ^ p.toReal - ∑ i ∈ s, ‖f i‖ ^ p.toReal
-- Mathlib/Data/Nat/Fib/Basic.lean
@[simp] lemma fib_eq_zero : ∀ {n}, fib n = 0 ↔ n = 0
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
@[simp] theorem decide_eq_false_iff_not (p : Prop) {_ : Decidable p} : (decide p = false) ↔ ¬p
-- Mathlib/GroupTheory/GroupAction/ConjAct.lean
theorem toConjAct_smul (g h : G) : toConjAct g • h = g * h * g⁻¹
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean
theorem le_bound : l ≤ bound ε l
-- Mathlib/Data/Rat/Defs.lean
theorem coe_int_num_of_den_eq_one {q : ℚ} (hq : q.den = 1) : (q.num : ℚ) = q
-- Mathlib/Analysis/Seminorm.lean
theorem coe_comp (p : Seminorm 𝕜₂ E₂) (f : E →ₛₗ[σ₁₂] E₂) : ⇑(p.comp f) = p ∘ f
-- Mathlib/Order/UpperLower/Basic.lean
theorem ordConnected_iff_upperClosure_inter_lowerClosure :
    s.OrdConnected ↔ ↑(upperClosure s) ∩ ↑(lowerClosure s) = s
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem toSesqForm_apply_norm_le {f : E →L[𝕜] E'} {v : E'} : ‖toSesqForm f v‖ ≤ ‖f‖ * ‖v‖
-- Mathlib/MeasureTheory/Integral/VitaliCaratheodory.lean
/-- Given an almost everywhere measurable function `f` with values in `ℝ≥0` in a sigma-finite space,
there exists a lower semicontinuous function `g > f` with integral arbitrarily close to that of `f`.
Formulation in terms of `lintegral`.
Auxiliary lemma for Vitali-Carathéodory theorem `exists_lt_lower_semicontinuous_integral_lt`. -/
theorem exists_lt_lowerSemicontinuous_lintegral_ge_of_aemeasurable [SigmaFinite μ] (f : α → ℝ≥0)
    (fmeas : AEMeasurable f μ) {ε : ℝ≥0∞} (ε0 : ε ≠ 0) :
    ∃ g : α → ℝ≥0∞,
      (∀ x, (f x : ℝ≥0∞) < g x) ∧ LowerSemicontinuous g ∧ (∫⁻ x, g x ∂μ) ≤ (∫⁻ x, f x ∂μ) + ε
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp] -- Should be replaced with `LinearIsometry.isComplete_image_iff` when `lean4#3107` is fixed.
theorem isComplete_image_iff' (f : LinearIsometry σ₁₂ E E₂) {s : Set E} :
    IsComplete (f '' s) ↔ IsComplete s
-- Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean
private theorem candidates_symm (fA : f ∈ candidates X Y) : f (x, y) = f (y, x)
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem sign_of_cycleType' (σ : Perm α) :
    sign σ = (σ.cycleType.map fun n => -(-1 : ℤˣ) ^ n).prod
-- Mathlib/RingTheory/Localization/Basic.lean
theorem map_smul (x : S) (z : R) : map Q g hy (z • x : S) = g z • map Q g hy x
-- Mathlib/GroupTheory/Nilpotent.lean
theorem lowerCentralSeries_pi_le (n : ℕ) :
    lowerCentralSeries (∀ i, Gs i) n ≤ Subgroup.pi Set.univ
      fun i => lowerCentralSeries (Gs i) n
-- Mathlib/LinearAlgebra/UnitaryGroup.lean
theorem mem_orthogonalGroup_iff {A : Matrix n n β} :
    A ∈ Matrix.orthogonalGroup n β ↔ A * star A = 1
-- Mathlib/Topology/Order/Hom/Esakia.lean
@[simp]
theorem id_comp (f : EsakiaHom α β) : (EsakiaHom.id β).comp f = f
-- Mathlib/Topology/MetricSpace/ThickenedIndicator.lean
theorem thickenedIndicator.coeFn_eq_comp {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) :
    ⇑(thickenedIndicator δ_pos E) = ENNReal.toNNReal ∘ thickenedIndicatorAux δ E
-- Mathlib/Analysis/NormedSpace/Real.lean
@[simp]
theorem range_nnnorm : range (nnnorm : E → ℝ≥0) = univ
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem HasMFDerivAt.mul' (hp : HasMFDerivAt I 𝓘(𝕜, F') p z p')
    (hq : HasMFDerivAt I 𝓘(𝕜, F') q z q') :
    HasMFDerivAt I 𝓘(𝕜, F') (p * q) z (p z • q' + p'.smulRight (q z) : E →L[𝕜] F')
-- Mathlib/RingTheory/FinitePresentation.lean
theorem of_finitePresentation {f : A →+* B} (hf : f.FinitePresentation) : f.FiniteType
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- If `E / F` is a field extension of exponential characteristic `q`, if `{ u_i }` is a
family of separable elements of `E` which is `F`-linearly independent, then `{ u_i ^ (q ^ n) }`
is also `F`-linearly independent for any natural number `n`. -/
theorem LinearIndependent.map_pow_expChar_pow_of_isIntegral'
    (hsep : ∀ i : ι, IsSeparable F (v i))
    (h : LinearIndependent F v) : LinearIndependent F (v · ^ q ^ n)
-- Mathlib/GroupTheory/PGroup.lean
theorem iff_orderOf [hp : Fact p.Prime] : IsPGroup p G ↔ ∀ g : G, ∃ k : ℕ, orderOf g = p ^ k
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem valuation_lt_one_iff (a : A) : a ∈ LocalRing.maximalIdeal A ↔ A.valuation a < 1
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
@[simp]
theorem mk0_val (u : G₀ˣ) (h : (u : G₀) ≠ 0) : mk0 (u : G₀) h = u
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Valid'.merge_aux {l r o₁ o₂} (hl : Valid' o₁ l o₂) (hr : Valid' o₁ r o₂)
    (sep : l.All fun x => r.All fun y => x < y) :
    Valid' o₁ (@merge α l r) o₂ ∧ size (merge l r) = size l + size r
-- Mathlib/CategoryTheory/Sites/Subsheaf.lean
@[simp]
theorem top_subpresheaf_obj (U) : (⊤ : Subpresheaf F).obj U = ⊤
-- Mathlib/Computability/Primrec.lean
theorem optionToList : Primrec (Option.toList : Option α → List α)
-- Mathlib/Order/UpperLower/Basic.lean
theorem OrderEmbedding.image_Ici (e : α ↪o β) (he : IsUpperSet (range e)) (a : α) :
    e '' Ici a = Ici (e a)
-- Mathlib/MeasureTheory/Measure/Portmanteau.lean
theorem exists_null_frontiers_thickening (μ : Measure Ω) [SFinite μ] (s : Set Ω) :
    ∃ rs : ℕ → ℝ,
      Tendsto rs atTop (𝓝 0) ∧ ∀ n, 0 < rs n ∧ μ (frontier (Metric.thickening (rs n) s)) = 0
-- Mathlib/Order/Interval/Multiset.lean
@[simp] lemma mem_Ici : x ∈ Ici a ↔ a ≤ x
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
theorem isFiniteMeasure_withDensity {f : α → ℝ≥0∞} (hf : ∫⁻ a, f a ∂μ ≠ ∞) :
    IsFiniteMeasure (μ.withDensity f)
-- Mathlib/Algebra/Ring/NegOnePow.lean
lemma negOnePow_succ (n : ℤ) : (n + 1).negOnePow = - n.negOnePow
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem mul_add_mod_self (x y z : Ordinal) : (x * y + z) % x = z % x
-- Mathlib/Order/Interval/Set/OrderEmbedding.lean
@[simp] theorem preimage_Iio : e ⁻¹' Iio (e x) = Iio x
-- Mathlib/Analysis/Calculus/LocalExtr/LineDeriv.lean
theorem IsMinOn.hasLineDerivWithinAt_eq_zero (h : IsMinOn f s a)
    (hd : HasLineDerivWithinAt ℝ f f' s a b) (h' : ∀ᶠ t : ℝ in 𝓝 0, a + t • b ∈ s) : f' = 0
-- Mathlib/NumberTheory/PellMatiyasevic.lean
theorem pellZd_add (m) : ∀ n, pellZd a1 (m + n) = pellZd a1 m * pellZd a1 n
-- Mathlib/Probability/Martingale/Basic.lean
theorem smul_nonneg {f : ι → Ω → F} {c : ℝ} (hc : 0 ≤ c) (hf : Submartingale f ℱ μ) :
    Submartingale (c • f) ℱ μ
-- Mathlib/Algebra/CharP/ExpChar.lean
theorem iterateFrobenius_add_apply :
    iterateFrobenius R p (m + n) x = iterateFrobenius R p m (iterateFrobenius R p n x)
-- Mathlib/Data/Fin/Basic.lean
theorem castPred_zero' [NeZero n] (h := Fin.ext_iff.not.2 last_pos'.ne) :
    castPred (0 : Fin (n + 1)) h = 0
-- Mathlib/Analysis/Complex/Polynomial/Basic.lean
/-- An irreducible real polynomial has natural degree at most two. -/
lemma Irreducible.natDegree_le_two {p : ℝ[X]} (hp : Irreducible p) : natDegree p ≤ 2
-- Mathlib/Topology/Algebra/Module/Basic.lean
protected theorem injective (e : M₁ ≃SL[σ₁₂] M₂) : Function.Injective e
-- Mathlib/Data/NNRat/Defs.lean
lemma divNat_inj (h₁ : d₁ ≠ 0) (h₂ : d₂ ≠ 0) : divNat n₁ d₁ = divNat n₂ d₂ ↔ n₁ * d₂ = n₂ * d₁
-- Mathlib/Data/Multiset/Functor.lean
@[simp]
theorem bind_def {α β} : (· >>= ·) = @bind α β
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
/-- **Gelfand's formula**: Given an element `a : A` of a complex Banach algebra, the
`spectralRadius` of `a` is the limit of the sequence `‖a ^ n‖₊ ^ (1 / n)`. -/
theorem pow_nnnorm_pow_one_div_tendsto_nhds_spectralRadius (a : A) :
    Tendsto (fun n : ℕ => (‖a ^ n‖₊ : ℝ≥0∞) ^ (1 / n : ℝ)) atTop (𝓝 (spectralRadius ℂ a))
-- Mathlib/Analysis/Complex/Basic.lean
theorem _root_.RCLike.re_eq_complex_re : ⇑(RCLike.re : ℂ →+ ℝ) = Complex.re
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp high]
theorem coe_symm_comp_coe (e : M₁ ≃SL[σ₁₂] M₂) :
    (e.symm : M₂ →SL[σ₂₁] M₁).comp (e : M₁ →SL[σ₁₂] M₂) = ContinuousLinearMap.id R₁ M₁
-- Mathlib/RingTheory/TensorProduct/Basic.lean
theorem productMap_right_apply (b : B) :
    productMap f g (1 ⊗ₜ b) = g b
-- Mathlib/Algebra/Order/Interval/Basic.lean
@[simp]
theorem length_nonneg : 0 ≤ s.length
-- Mathlib/RingTheory/PowerSeries/Basic.lean
@[simp]
theorem coeff_one (n : ℕ) : coeff R n (1 : R⟦X⟧) = if n = 0 then 1 else 0
-- Mathlib/Topology/Compactification/OnePoint.lean
theorem ne_infty_iff_exists {x : OnePoint X} : x ≠ ∞ ↔ ∃ y : X, (y : OnePoint X) = x
-- Mathlib/Order/UpperLower/Basic.lean
protected theorem compl_sup (s t : LowerSet α) : (s ⊔ t).compl = s.compl ⊔ t.compl
-- Mathlib/Analysis/Complex/Conformal.lean
theorem isConformalMap_complex_linear {map : ℂ →L[ℂ] E} (nonzero : map ≠ 0) :
    IsConformalMap (map.restrictScalars ℝ)
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem blockDiagonal'_sub [AddGroup α] (M N : ∀ i, Matrix (m' i) (n' i) α) :
    blockDiagonal' (M - N) = blockDiagonal' M - blockDiagonal' N
-- Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean
theorem isEquivalent_zero_iff_eventually_zero : u ~[l] 0 ↔ u =ᶠ[l] 0
-- Mathlib/Analysis/Convex/Cone/Basic.lean
/-- The strictly positive cone of an ordered module is always salient. -/
theorem salient_strictlyPositive : Salient (strictlyPositive 𝕜 E)
-- Mathlib/Algebra/MvPolynomial/Supported.lean
theorem exists_restrict_to_vars (R : Type*) [CommRing R] {F : MvPolynomial σ ℤ}
    (hF : ↑F.vars ⊆ s) : ∃ f : (s → R) → R, ∀ x : σ → R, f (x ∘ (↑) : s → R) = aeval x F
-- Mathlib/LinearAlgebra/LinearPMap.lean
theorem inverse_range : LinearMap.range (inverse f).toFun = f.domain
-- Mathlib/Data/Nat/ModEq.lean
@[gcongr]
protected theorem mul_left (c : ℕ) (h : a ≡ b [MOD n]) : c * a ≡ c * b [MOD n]
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[simp]
theorem cos_sq_add_sin_sq (θ : Real.Angle) : cos θ ^ 2 + sin θ ^ 2 = 1
-- Mathlib/Probability/Process/Stopping.lean
theorem stoppedProcess_eq_of_mem_finset [LinearOrder ι] [AddCommMonoid E] {s : Finset ι} (n : ι)
    (hbdd : ∀ ω, τ ω < n → τ ω ∈ s) : stoppedProcess u τ n = Set.indicator {a | n ≤ τ a} (u n) +
      ∑ i ∈ s.filter (· < n), Set.indicator {ω | τ ω = i} (u i)
-- Mathlib/Algebra/Order/CauSeq/Completion.lean
theorem zero_ne_one : (0 : (Cauchy abv)) ≠ 1
-- Mathlib/Topology/Order/LawsonTopology.lean
lemma isLawson_le_isScott : L ≤ S
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
@[simp] theorem Matrix.mulVecLin_transpose [Fintype m] (M : Matrix m n R) :
    Mᵀ.mulVecLin = M.vecMulLinear
-- Mathlib/Data/Set/NAry.lean
theorem Nonempty.image2 : s.Nonempty → t.Nonempty → (image2 f s t).Nonempty
-- Mathlib/LinearAlgebra/Matrix/Determinant/Misc.lean
/-- Let `M` be a `(n+1) × n` matrix whose column sums to zero. Then all the matrices obtained by
deleting one column have the same determinant up to a sign. -/
theorem submatrix_succAbove_det_eq_negOnePow_submatrix_succAbove_det' {n : ℕ}
    (M : Matrix (Fin n) (Fin (n + 1)) R) (hv : ∀ i, ∑ j, M i j = 0) (j₁ j₂ : Fin (n + 1)) :
    (M.submatrix id (Fin.succAbove j₁)).det =
      Int.negOnePow (j₁ - j₂) • (M.submatrix id (Fin.succAbove j₂)).det
-- Mathlib/Order/Interval/Finset/Basic.lean
/-- `Finset.cons` version of `Finset.Ioo_insert_left`. -/
theorem Ico_eq_cons_Ioo (h : a < b) : Ico a b = (Ioo a b).cons a left_not_mem_Ioo
-- Mathlib/Algebra/Module/Equiv/Defs.lean
protected theorem map_add (a b : M) : e (a + b) = e a + e b
-- Mathlib/Data/ULift.lean
@[simp]
theorem «forall» {p : PLift α → Prop} : (∀ x, p x) ↔ ∀ x : α, p (PLift.up x)
-- Mathlib/CategoryTheory/Iso.lean
@[reassoc]
theorem map_hom_inv (F : C ⥤ D) {X Y : C} (f : X ⟶ Y) [IsIso f] :
    F.map f ≫ F.map (inv f) = 𝟙 (F.obj X)
-- Mathlib/Analysis/Calculus/FDeriv/Linear.lean
@[simp]
protected theorem ContinuousLinearMap.fderiv : fderiv 𝕜 e x = e
-- Mathlib/Algebra/Group/Invertible/Defs.lean
@[simp]
theorem mul_invOf_mul_self_cancel' [Monoid α] (a b : α) {_ : Invertible b} : a * ⅟ b * b = a
-- Mathlib/Combinatorics/HalesJewett.lean
theorem apply_def (l : Line α ι) (x : α) : l x = fun i => (l.idxFun i).getD x
-- Mathlib/Data/Complex/Exponential.lean
nonrec theorem sin_sub_sin : sin x - sin y = 2 * sin ((x - y) / 2) * cos ((x + y) / 2)
-- Mathlib/Data/Finset/Lattice.lean
theorem sup'_union [DecidableEq β] {s₁ s₂ : Finset β} (h₁ : s₁.Nonempty) (h₂ : s₂.Nonempty)
    (f : β → α) :
    (s₁ ∪ s₂).sup' (h₁.mono subset_union_left) f = s₁.sup' h₁ f ⊔ s₂.sup' h₂ f
-- Mathlib/FieldTheory/IsPerfectClosure.lean
/-- If `L / K` is a `p`-radical field extension, then it is purely inseparable. -/
theorem IsPRadical.isPurelyInseparable [IsPRadical (algebraMap K L) p] :
    IsPurelyInseparable K L
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
@[simp]
lemma δ_shift (a m : ℤ) :
    δ n m (γ.shift a) = a.negOnePow • (δ n m γ).shift a
-- Mathlib/Tactic/CancelDenoms/Core.lean
theorem mul_subst {α} [CommRing α] {n1 n2 k e1 e2 t1 t2 : α}
    (h1 : n1 * e1 = t1) (h2 : n2 * e2 = t2) (h3 : n1 * n2 = k) : k * (e1 * e2) = t1 * t2
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
protected theorem add_mul (φ₁ φ₂ φ₃ : MvPowerSeries σ R) : (φ₁ + φ₂) * φ₃ = φ₁ * φ₃ + φ₂ * φ₃
-- Mathlib/Order/Interval/Finset/Defs.lean
@[simp]
theorem mem_uIcc : x ∈ uIcc a b ↔ a ⊓ b ≤ x ∧ x ≤ a ⊔ b
-- Mathlib/Data/Complex/Module.lean
theorem realPart_smul (z : ℂ) (a : A) : ℜ (z • a) = z.re • ℜ a - z.im • ℑ a
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem exists_of_lt_mex {ι} {f : ι → Ordinal} {a} (ha : a < mex f) : ∃ i, f i = a
-- Mathlib/Topology/CompactOpen.lean
/-- If `g : C(Y, Z)` is a topological embedding,
then the composition `ContinuousMap.comp g : C(X, Y) → C(X, Z)` is an embedding too. -/
theorem embedding_comp (g : C(Y, Z)) (hg : Embedding g) : Embedding (g.comp : C(X, Y) → C(X, Z))
-- Mathlib/Data/SetLike/Basic.lean
@[simp, norm_cast]
theorem coe_sort_coe : ((p : Set B) : Type _) = p
-- Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean
/-- The `n+1`-th iterated derivative can be obtained by taking the `n`-th derivative of the
derivative. -/
theorem iteratedDeriv_succ' : iteratedDeriv (n + 1) f = iteratedDeriv n (deriv f)
-- Mathlib/SetTheory/Lists.lean
theorem Equiv.trans : ∀ {l₁ l₂ l₃ : Lists α}, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
-- Mathlib/RingTheory/IsAdjoinRoot.lean
@[simp]
theorem lift_self_apply (h : IsAdjoinRoot S f) (x : S) :
    h.lift (algebraMap R S) h.root h.aeval_root x = x
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- Subtracting a multiple of the first vector passed to `oangle` from the second vector does
not change the sign of the angle. -/
@[simp]
theorem oangle_sign_sub_smul_right (x y : V) (r : ℝ) :
    (o.oangle x (y - r • x)).sign = (o.oangle x y).sign
-- Mathlib/Probability/Independence/Conditional.lean
theorem CondIndepFun.neg_right {_mβ : MeasurableSpace β} {_mβ' : MeasurableSpace β'} [Neg β']
    [MeasurableNeg β'] (hfg : CondIndepFun m' hm' f g μ)  :
    CondIndepFun m' hm' f (-g) μ
-- Mathlib/Geometry/Euclidean/Circumcenter.lean
/-- All points have distance from the circumcenter equal to the
circumradius. -/
@[simp]
theorem dist_circumcenter_eq_circumradius {n : ℕ} (s : Simplex ℝ P n) (i : Fin (n + 1)) :
    dist (s.points i) s.circumcenter = s.circumradius
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
lemma map_rootsOfUnity {S F} [CommRing S] [IsDomain S] [FunLike F R S] [MonoidHomClass F R S]
    {ζ : R} {n : ℕ+} (hζ : IsPrimitiveRoot ζ n) {f : F} (hf : Function.Injective f) :
    (rootsOfUnity n R).map (Units.map f) = rootsOfUnity n S
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIocMod_add_left (a b : α) : toIocMod hp a (p + b) = toIocMod hp a b
-- Mathlib/Analysis/Calculus/TangentCone.lean
theorem uniqueDiffOn_Iic (a : ℝ) : UniqueDiffOn ℝ (Iic a)
-- Mathlib/Data/Set/Finite.lean
theorem Finite.of_prod_right (h : (s ×ˢ t : Set (α × β)).Finite) : s.Nonempty → t.Finite
-- Mathlib/Analysis/Calculus/IteratedDeriv/Lemmas.lean
theorem iteratedDerivWithin_const_smul (c : R) (hf : ContDiffOn 𝕜 n f s) :
    iteratedDerivWithin n (c • f) s x = c • iteratedDerivWithin n f s x
-- Mathlib/Probability/Kernel/Composition.lean
theorem compProd_eq_sum_compProd_right (κ : Kernel α β) (η : Kernel (α × β) γ)
    [IsSFiniteKernel η] : κ ⊗ₖ η = Kernel.sum fun n => κ ⊗ₖ seq η n
-- Mathlib/Data/Complex/Basic.lean
lemma im_mul_ofReal (z : ℂ) (r : ℝ) : (z * r).im = z.im *  r
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.sup_principal (hl : l.HasBasis p s) (t : Set α) :
    (l ⊔ 𝓟 t).HasBasis p fun i => s i ∪ t
-- Mathlib/Topology/Algebra/Module/WeakDual.lean
theorem continuousLinearMapToWeakSpace_bijective :
    Function.Bijective (continuousLinearMapToWeakSpace 𝕜 E)
-- Mathlib/Geometry/Manifold/VectorBundle/FiberwiseLinear.lean
/-- Compute the source of the composition of two partial homeomorphisms induced by fiberwise linear
equivalences. -/
theorem source_trans_partialHomeomorph (hU : IsOpen U)
    (hφ : ContinuousOn (fun x => φ x : B → F →L[𝕜] F) U)
    (h2φ : ContinuousOn (fun x => (φ x).symm : B → F →L[𝕜] F) U) (hU' : IsOpen U')
    (hφ' : ContinuousOn (fun x => φ' x : B → F →L[𝕜] F) U')
    (h2φ' : ContinuousOn (fun x => (φ' x).symm : B → F →L[𝕜] F) U') :
    (FiberwiseLinear.partialHomeomorph φ hU hφ h2φ ≫ₕ
          FiberwiseLinear.partialHomeomorph φ' hU' hφ' h2φ').source =
      (U ∩ U') ×ˢ univ
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem fract_add_int (a : α) (m : ℤ) : fract (a + m) = fract a
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem smoothAt_pi_space :
    SmoothAt I 𝓘(𝕜, ∀ i, Fi i) φ x ↔ ∀ i, SmoothAt I 𝓘(𝕜, Fi i) (fun x => φ x i) x
-- Mathlib/Order/RelIso/Basic.lean
protected theorem isTrans : ∀ (_ : r ↪r s) [IsTrans β s], IsTrans α r
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem tendstoLocallyUniformly_iff_forall_tendsto :
    TendstoLocallyUniformly F f p ↔
      ∀ x, Tendsto (fun y : ι × α => (f y.2, F y.1 y.2)) (p ×ˢ 𝓝 x) (𝓤 β)
-- Mathlib/Data/Set/Lattice.lean
theorem inter_iInter_nat_succ (u : ℕ → Set α) : (u 0 ∩ ⋂ i, u (i + 1)) = ⋂ i, u i
-- Mathlib/Analysis/Normed/Ring/SeminormFromBounded.lean
/-- If `f : R → ℝ` is a nonnegative, multiplicatively bounded, subadditive function that preserves
  zero and negation, then `seminormFromBounded' f` is a norm if and only if `f⁻¹' {0} = {0}`. -/
theorem seminormFromBounded_is_norm_iff (f_zero : f 0 = 0) (f_nonneg : 0 ≤ f)
    (f_mul : ∀ x y : R, f (x * y) ≤ c * f x * f y)
    (f_add : ∀ a b, f (a + b) ≤ f a + f b) (f_neg : ∀ x : R, f (-x) = f x) :
    (∀ x : R, (seminormFromBounded f_zero f_nonneg f_mul f_add f_neg).toFun x = 0 → x = 0) ↔
      f ⁻¹' {0} = {0}
-- Mathlib/Tactic/NormNum/DivMod.lean
lemma isInt_ediv_neg {a b q q' : ℤ} (h : IsInt (a / -b) q) (hq : -q = q') : IsInt (a / b) q'
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem DifferentiableAt.const_mul (ha : DifferentiableAt 𝕜 a x) (b : 𝔸) :
    DifferentiableAt 𝕜 (fun y => b * a y) x
-- Mathlib/CategoryTheory/EqToHom.lean
theorem comp_eqToHom_iff {X Y Y' : C} (p : Y = Y') (f : X ⟶ Y) (g : X ⟶ Y') :
    f ≫ eqToHom p = g ↔ f = g ≫ eqToHom p.symm
-- Mathlib/Data/ZMod/Basic.lean
lemma ringEquivCongr_ringEquivCongr_apply {a b c : ℕ} (hab : a = b) (hbc : b = c) (x : ZMod a) :
    ringEquivCongr hbc (ringEquivCongr hab x) = ringEquivCongr (hab.trans hbc) x
-- Mathlib/Topology/Category/Stonean/Limits.lean
@[reassoc (attr := simp)]
lemma finiteCoproduct.ι_desc {B : Stonean.{u}} (e : (a : α) → (X a ⟶ B)) (a : α) :
    finiteCoproduct.ι X a ≫ finiteCoproduct.desc X e = e a
-- Mathlib/Algebra/Homology/Localization.lean
lemma homologyFunctor_inverts_quasiIso (i : ι) :
    (quasiIso C c).IsInvertedBy (homologyFunctor C c i)