ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Sites/Coherent/SheafComparison.lean
lemma eq_induced : haveI := F.reflects_precoherent
    coherentTopology C =
      F.inducedTopology (coherentTopology _)
-- Mathlib/Data/Int/Defs.lean
protected lemma add_le_iff_le_sub : a + b ≤ c ↔ a ≤ c - b
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem tmul_smul [DistribMulAction R' N] [CompatibleSMul R R' M N] (r : R') (x : M) (y : N) :
    x ⊗ₜ (r • y) = r • x ⊗ₜ[R] y
-- Mathlib/Data/Set/Prod.lean
/-- A function is `Function.const α a` for some `a` if and only if `∀ x y, f x = f y`. -/
theorem range_const_eq_diagonal {α β : Type*} [hβ : Nonempty β] :
    range (const α) = {f : α → β | ∀ x y, f x = f y}
-- Mathlib/RingTheory/SimpleModule.lean
theorem sSup_simples_eq_top : sSup { m : Submodule R M | IsSimpleModule R m } = ⊤
-- Mathlib/Algebra/Module/Defs.lean
theorem smul_right_inj [NoZeroSMulDivisors R M] {c : R} (hc : c ≠ 0) {x y : M} :
    c • x = c • y ↔ x = y
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
@[simp]
lemma neg_zero : (-0 : W.Point) = 0
-- Mathlib/Topology/Compactification/OnePoint.lean
@[continuity]
theorem continuous_coe : Continuous ((↑) : X → OnePoint X)
-- Mathlib/Analysis/Analytic/CPolynomial.lean
theorem CPolynomialOn.analyticOn {s : Set E} (hf : CPolynomialOn 𝕜 f s) : AnalyticOn 𝕜 f s
-- Mathlib/MeasureTheory/Integral/CircleIntegral.lean
theorem integral_sub_inv_smul_sub_smul (f : ℂ → E) (c w : ℂ) (R : ℝ) :
    (∮ z in C(c, R), (z - w)⁻¹ • (z - w) • f z) = ∮ z in C(c, R), f z
-- Mathlib/Analysis/BoundedVariation.lean
theorem comp_eq_of_antitoneOn (f : α → E) {t : Set β} (φ : β → α) (hφ : AntitoneOn φ t) :
    eVariationOn (f ∘ φ) t = eVariationOn f (φ '' t)
-- Mathlib/Data/Nat/Digits.lean
@[simp]
theorem ofDigits_nil {b : ℕ} : ofDigits b [] = 0
-- Mathlib/Topology/Algebra/Module/WeakDual.lean
theorem map_apply (f : E →L[𝕜] F) (x : E) : WeakSpace.map f x = f x
-- Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean
theorem balancedCore_eq_iInter (hs : (0 : E) ∈ s) :
    balancedCore 𝕜 s = ⋂ (r : 𝕜) (_ : 1 ≤ ‖r‖), r • s
-- Mathlib/FieldTheory/KummerExtension.lean
lemma ne_zero_of_irreducible_X_pow_sub_C' {n : ℕ} (hn : n ≠ 1) {a : K}
    (H : Irreducible (X ^ n - C a)) : a ≠ 0
-- Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean
@[simp]
theorem Gamma1_mem' (N : ℕ) (γ : Gamma0 N) : γ ∈ Gamma1' N ↔ (Gamma0Map N) γ = 1
-- Mathlib/Topology/Connected/Clopen.lean
/-- Preconnected sets are either contained in or disjoint to any given clopen set. -/
theorem disjoint_or_subset_of_isClopen {s t : Set α} (hs : IsPreconnected s) (ht : IsClopen t) :
    Disjoint s t ∨ s ⊆ t
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
lemma FractionalIdeal.le_inv_comm {I J : FractionalIdeal A⁰ K} (hI : I ≠ 0) (hJ : J ≠ 0) :
    I ≤ J⁻¹ ↔ J ≤ I⁻¹
-- Mathlib/RingTheory/Idempotents.lean
lemma OrthogonalIdempotents.map :
    OrthogonalIdempotents (f ∘ e)
-- Mathlib/Probability/StrongLaw.lean
theorem truncation_nonneg {f : α → ℝ} (A : ℝ) {x : α} (h : 0 ≤ f x) : 0 ≤ truncation f A x
-- Mathlib/Algebra/Order/Monovary.lean
@[simp]
lemma monovaryOn_inv_left₀ (hf : ∀ i ∈ s, 0 < f i) : MonovaryOn f⁻¹ g s ↔ AntivaryOn f g s
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem nonempty_Icc : (Icc a b).Nonempty ↔ a ≤ b
-- Mathlib/Order/CompleteLattice.lean
@[simp]
theorem iSup_bot : (⨆ _ : ι, ⊥ : α) = ⊥
-- Mathlib/Analysis/Normed/Field/Basic.lean
/-- A seminormed commutative ring is a commutative ring endowed with a seminorm which satisfies
the inequality `‖x y‖ ≤ ‖x‖ ‖y‖`. -/
class SeminormedCommRing (α : Type*) extends SeminormedRing α where
  /-- Multiplication is commutative. -/
  mul_comm : ∀ x y : α, x * y = y * x
-- Mathlib/Logic/Equiv/Option.lean
@[simp]
theorem optionSubtype_apply_apply
    [DecidableEq β] (x : β)
    (e : { e : Option α ≃ β // e none = x })
    (a : α)
    (h) : optionSubtype x e a = ⟨(e : Option α ≃ β) a, h⟩
-- .lake/packages/lean4/src/lean/Init/Omega/Constraint.lean
theorem scale_sat {c : Constraint} (k) (w : c.sat t) : (scale k c).sat (k * t)
-- Mathlib/Algebra/ContinuedFractions/Translations.lean
theorem num_eq_conts_a : g.nums n = (g.conts n).a
-- Mathlib/Topology/Separation.lean
@[simp]
theorem exists_isCompact_superset_iff {s : Set X} :
    (∃ K, IsCompact K ∧ s ⊆ K) ↔ IsCompact (closure s)
-- Mathlib/Data/Matroid/Basic.lean
theorem indep_iff_not_dep : M.Indep I ↔ ¬M.Dep I ∧ I ⊆ M.E
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem ContDiffOn.mono (h : ContDiffOn 𝕜 n f s) {t : Set E} (hst : t ⊆ s) : ContDiffOn 𝕜 n f t
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
theorem biprod.isoProd_inv {X Y : C} [HasBinaryBiproduct X Y] :
    (biprod.isoProd X Y).inv = biprod.lift prod.fst prod.snd
-- Mathlib/Deprecated/Subgroup.lean
theorem subset_normalClosure : s ⊆ normalClosure s
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem neg_add_lt_of_lt_add {a b c : Int} (h : a < b + c) : -b + a < c
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem ext_iff {a b : Fin n} : a = b ↔ a.1 = b.1
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- Swapping the first and third points in an oriented angle negates the sign of that angle. -/
theorem oangle_swap₁₃_sign (p₁ p₂ p₃ : P) : -(∡ p₁ p₂ p₃).sign = (∡ p₃ p₂ p₁).sign
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem fract_ofNat_add (n : ℕ) [n.AtLeastTwo] (a : α) :
    fract ((no_index (OfNat.ofNat n)) + a) = fract a
-- Mathlib/RingTheory/ChainOfDivisors.lean
theorem map_prime_of_factor_orderIso {m p : Associates M} {n : Associates N} (hn : n ≠ 0)
    (hp : p ∈ normalizedFactors m) (d : Set.Iic m ≃o Set.Iic n) :
    Prime (d ⟨p, dvd_of_mem_normalizedFactors hp⟩ : Associates N)
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem mem_toFinset : a ∈ l.toFinset ↔ a ∈ l
-- Mathlib/Analysis/Calculus/Deriv/Slope.lean
/-- If `f` has derivative `f'` within `(x, +∞)` at `x`, then for any `r > ‖f'‖` the ratio
`(‖f z‖ - ‖f x‖) / (z - x)` is frequently less than `r` as `z → x+0`.
In other words, the limit inferior of this ratio as `z` tends to `x+0`
is less than or equal to `‖f'‖`.

See also

* `HasDerivWithinAt.limsup_norm_slope_le` for a stronger version using
  limit superior and any set `s`;
* `HasDerivWithinAt.liminf_right_norm_slope_le` for a stronger version using
  `‖f z - f xp‖` instead of `‖f z‖ - ‖f x‖`. -/
theorem HasDerivWithinAt.liminf_right_slope_norm_le (hf : HasDerivWithinAt f f' (Ici x) x)
    (hr : ‖f'‖ < r) : ∃ᶠ z in 𝓝[>] x, (z - x)⁻¹ * (‖f z‖ - ‖f x‖) < r
-- Mathlib/Data/Matrix/Notation.lean
theorem ofNat_fin_two (n : ℕ) [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n) : Matrix (Fin 2) (Fin 2) α) =
      !![OfNat.ofNat n, 0; 0, OfNat.ofNat n]
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem blsub_eq_lsub' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r]
    (f : ι → Ordinal.{max u v}) : blsub.{_, v} _ (bfamilyOfFamily' r f) = lsub.{_, v} f
-- Mathlib/Data/Nat/Find.lean
@[simp] lemma le_find_iff (h : ∃ n : ℕ, p n) (n : ℕ) : n ≤ Nat.find h ↔ ∀ m < n, ¬ p m
-- Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean
theorem boundedBy_eq (s : Set α) (m_empty : m ∅ = 0) (m_mono : ∀ ⦃t : Set α⦄, s ⊆ t → m s ≤ m t)
    (m_subadd : ∀ s : ℕ → Set α, m (⋃ i, s i) ≤ ∑' i, m (s i)) : boundedBy m s = m s
-- Mathlib/Order/Filter/Prod.lean
theorem Eventually.prod_inr {lb : Filter β} {p : β → Prop} (h : ∀ᶠ x in lb, p x) (la : Filter α) :
    ∀ᶠ x in la ×ˢ lb, p (x : α × β).2
-- Mathlib/Data/Int/Defs.lean
/-- See `Int.inductionOn'` for an induction in both directions. -/
protected lemma le_induction {P : ℤ → Prop} {m : ℤ} (h0 : P m)
    (h1 : ∀ n : ℤ, m ≤ n → P n → P (n + 1)) (n : ℤ) : m ≤ n → P n
-- Mathlib/Data/Complex/Exponential.lean
lemma exp_nsmul (x : ℂ) (n : ℕ) : exp (n • x) = exp x ^ n
-- Mathlib/NumberTheory/MulChar/Basic.lean
/-- The trivial multiplicative character. It takes the value `0` on non-units and
the value `1` on units. -/
@[simps]
noncomputable def trivial : MulChar R R'
-- Mathlib/Data/Finset/Basic.lean
theorem subset_coe_filter_of_subset_forall (s : Finset α) {t : Set α} (h₁ : t ⊆ s)
    (h₂ : ∀ x ∈ t, p x) : t ⊆ s.filter p
-- Mathlib/Order/Minimal.lean
theorem map_mem_minimals (ha : a ∈ minimals r x) : f a ∈ minimals s (f '' x)
-- Mathlib/RingTheory/ReesAlgebra.lean
theorem adjoin_monomial_eq_reesAlgebra :
    Algebra.adjoin R (Submodule.map (monomial 1 : R →ₗ[R] R[X]) I : Set R[X]) = reesAlgebra I
-- Mathlib/Combinatorics/SimpleGraph/Trails.lean
theorem IsEulerian.card_filter_odd_degree [Fintype V] [DecidableRel G.Adj] {u v : V}
    {p : G.Walk u v} (ht : p.IsEulerian) {s}
    (h : s = (Finset.univ : Finset V).filter fun v => Odd (G.degree v)) :
    s.card = 0 ∨ s.card = 2
-- Mathlib/FieldTheory/KummerExtension.lean
theorem X_pow_sub_C_irreducible_iff_of_odd {n : ℕ} (hn : Odd n) {a : K} :
    Irreducible (X ^ n - C a) ↔ (∀ d, d ∣ n → d ≠ 1 → ∀ b : K, b ^ d ≠ a)
-- Mathlib/LinearAlgebra/Dual.lean
@[simp]
theorem LinearEquiv.dualMap_symm {f : M₁ ≃ₗ[R] M₂} :
    (LinearEquiv.dualMap f).symm = LinearEquiv.dualMap f.symm
-- Mathlib/Data/Set/Pointwise/Interval.lean
theorem image_mul_right_Icc {a b c : α} (hab : a ≤ b) (hc : 0 ≤ c) :
    (fun x => x * c) '' Icc a b = Icc (a * c) (b * c)
-- Mathlib/Order/Interval/Set/Disjoint.lean
@[simp]
theorem iUnion_Icc_right (a : α) : ⋃ b, Icc a b = Ici a
-- Mathlib/Algebra/Group/Defs.lean
/-- A mixin for left cancellative addition. -/
class IsLeftCancelAdd (G : Type u) [Add G] : Prop where
  /-- Addition is left cancellative. -/
  protected add_left_cancel : ∀ a b c : G, a + b = a + c → b = c
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
@[simp]
theorem isVonNBounded_union {s t : Set E} :
    IsVonNBounded 𝕜 (s ∪ t) ↔ IsVonNBounded 𝕜 s ∧ IsVonNBounded 𝕜 t
-- Mathlib/Analysis/Fourier/FourierTransform.lean
lemma fourierIntegralInv_eq' (f : V → E) (w : V) :
    𝓕⁻ f w = ∫ v, Complex.exp ((↑(2 * π * ⟪v, w⟫) * Complex.I)) • f v
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
lemma mem_of_mem_measurableAtom {x y : β} (h : y ∈ measurableAtom x) {s : Set β}
    (hs : MeasurableSet s) (hxs : x ∈ s) : y ∈ s
-- Mathlib/Algebra/Lie/Subalgebra.lean
@[simp]
theorem mem_mk_iff (S : Set L) (h₁ h₂ h₃ h₄) {x : L} :
    x ∈ (⟨⟨⟨⟨S, h₁⟩, h₂⟩, h₃⟩, h₄⟩ : LieSubalgebra R L) ↔ x ∈ S
-- Mathlib/Order/Filter/AtTopBot.lean
/-- The `atTop` filter for an open interval `Ici a` comes from the `atTop` filter in the ambient
order. -/
theorem atTop_Ici_eq [SemilatticeSup α] (a : α) : atTop = comap ((↑) : Ici a → α) atTop
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem Prime.pred_pos {p : ℕ} (pp : Prime p) : 0 < pred p
-- Mathlib/Algebra/CubicDiscriminant.lean
@[simp]
theorem natDegree_of_c_eq_zero (ha : P.a = 0) (hb : P.b = 0) (hc : P.c = 0) :
    P.toPoly.natDegree = 0
-- Mathlib/RingTheory/PrincipalIdealDomain.lean
theorem _root_.isRelPrime_iff_isCoprime : IsRelPrime x y ↔ IsCoprime x y
-- Mathlib/Data/TypeVec.lean
theorem splitFun_comp {α₀ α₁ α₂ : TypeVec (n + 1)} (f₀ : drop α₀ ⟹ drop α₁)
    (f₁ : drop α₁ ⟹ drop α₂) (g₀ : last α₀ → last α₁) (g₁ : last α₁ → last α₂) :
    splitFun (f₁ ⊚ f₀) (g₁ ∘ g₀) = splitFun f₁ g₁ ⊚ splitFun f₀ g₀
-- Mathlib/Algebra/GroupWithZero/Units/Equiv.lean
theorem _root_.mulRight_bijective₀ (a : G) (ha : a ≠ 0) : Function.Bijective ((· * a) : G → G)
-- Mathlib/Data/Real/EReal.lean
@[simp]
theorem top_ne_zero : (⊤ : EReal) ≠ 0
-- Mathlib/Data/List/DropRight.lean
@[simp]
theorem rdropWhile_nil : rdropWhile p ([] : List α) = []
-- Mathlib/Order/Basic.lean
@[simp]
theorem update_lt_update_iff : update x i a < update x i b ↔ a < b
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem compl_bot : (⊥ : α)ᶜ = ⊤
-- Mathlib/Algebra/DirectSum/Ring.lean
private theorem mul_assoc (a b c : ⨁ i, A i) : a * b * c = a * (b * c)
-- Mathlib/Analysis/BoundedVariation.lean
theorem eq_of_eqOn {f f' : α → E} {s : Set α} (h : EqOn f f' s) :
    eVariationOn f s = eVariationOn f' s
-- .lake/packages/batteries/Batteries/Classes/Order.lean
theorem LTCmp.eq_compareOfLessAndEq
    [LT α] [DecidableEq α] [BEq α] [LawfulBEq α] [BEqCmp cmp] [LTCmp cmp]
    (x y : α) [Decidable (x < y)] : cmp x y = compareOfLessAndEq x y
-- Mathlib/Algebra/CharP/Algebra.lean
/-- A nontrivial `ℚ`-algebra has characteristic zero.

This cannot be a (local) instance because it would immediately form a loop with the
instance `algebraRat`. It's probably easier to go the other way: prove `CharZero R` and
automatically receive an `Algebra ℚ R` instance.
-/
theorem algebraRat.charZero [Ring R] [Algebra ℚ R] : CharZero R
-- Mathlib/Data/ZMod/Basic.lean
theorem val_mul_le {n : ℕ} (a b : ZMod n) : (a * b).val ≤ a.val * b.val
-- Mathlib/CategoryTheory/Abelian/Pseudoelements.lean
/-- In the category `Module R`, if `x` and `y` are pseudoequal, then the range of the associated
morphisms is the same. -/
theorem ModuleCat.eq_range_of_pseudoequal {R : Type*} [CommRing R] {G : ModuleCat R} {x y : Over G}
    (h : PseudoEqual G x y) : LinearMap.range x.hom = LinearMap.range y.hom
-- Mathlib/GroupTheory/SpecificGroups/Dihedral.lean
theorem exponent : Monoid.exponent (DihedralGroup n) = lcm n 2
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem DifferentiableWithinAt.congr_of_eventuallyEq (h : DifferentiableWithinAt 𝕜 f s x)
    (h₁ : f₁ =ᶠ[𝓝[s] x] f) (hx : f₁ x = f x) : DifferentiableWithinAt 𝕜 f₁ s x
-- Mathlib/Order/Disjoint.lean
@[symm]
theorem Codisjoint.symm ⦃a b : α⦄ : Codisjoint a b → Codisjoint b a
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem eLpNorm_lt_top (f : Lp E p μ) : eLpNorm f p μ < ∞
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem mem_pointwise_smul_iff_inv_smul_mem {g : G} {S : ValuationSubring K} {x : K} :
    x ∈ g • S ↔ g⁻¹ • x ∈ S
-- Mathlib/Data/ENat/Basic.lean
theorem one_le_iff_ne_zero : 1 ≤ n ↔ n ≠ 0
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
theorem map_add_swap [DecidableEq ι] {i j : ι} (hij : i ≠ j) :
    f v + f (v ∘ Equiv.swap i j) = 0
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem isLocallyFiniteMeasure_of_le [TopologicalSpace α] {_m : MeasurableSpace α} {μ ν : Measure α}
    [H : IsLocallyFiniteMeasure μ] (h : ν ≤ μ) : IsLocallyFiniteMeasure ν
-- Mathlib/CategoryTheory/Limits/Final.lean
/-- The hypotheses also imply that `F` is final, see `final_of_comp_full_faithful`. -/
theorem final_of_comp_full_faithful' [Full G] [Faithful G] [Final (F ⋙ G)] : Final G
-- Mathlib/Analysis/LocallyConvex/Basic.lean
@[deprecated Balanced.zero_insert_interior (since := "2024-02-03")]
theorem balanced_zero_union_interior (hA : Balanced 𝕜 A) : Balanced 𝕜 ((0 : Set E) ∪ interior A)
-- Mathlib/LinearAlgebra/Prod.lean
theorem disjoint_inl_inr : Disjoint (range <| inl R M M₂) (range <| inr R M M₂)
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
theorem normSq_denom_pos (g : GL(2, ℝ)⁺) (z : ℍ) : 0 < Complex.normSq (denom g z)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
@[simp] lemma innerₗ_apply (v w : F) : innerₗ F v w = ⟪v, w⟫_ℝ
-- Mathlib/Data/Part.lean
@[simp]
theorem mod_get_eq [Mod α] (a b : Part α) (hab : Dom (a % b)) :
    (a % b).get hab = a.get (left_dom_of_mod_dom hab) % b.get (right_dom_of_mod_dom hab)
-- Mathlib/Data/Finset/Basic.lean
theorem erase_sdiff_distrib (s t : Finset α) (a : α) : (s \ t).erase a = s.erase a \ t.erase a
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem le_max_right (a b : Int) : b ≤ max a b
-- Mathlib/RingTheory/AdicCompletion/Exactness.lean
/-- `AdicCompletion` over a Noetherian ring is exact on finitely generated modules. -/
theorem map_exact : Function.Exact (map I f) (map I g)
-- Mathlib/Analysis/Analytic/Basic.lean
lemma changeOriginSeriesTerm_changeOriginIndexEquiv_symm (n t) :
    let s := changeOriginIndexEquiv.symm ⟨n, t⟩
    p.changeOriginSeriesTerm s.1 s.2.1 s.2.2 s.2.2.2 (fun _ ↦ x) (fun _ ↦ y) =
    p n (t.piecewise (fun _ ↦ x) fun _ ↦ y)
-- Mathlib/Topology/Algebra/InfiniteSum/Ring.lean
/-- The family `(k, l) : ℕ × ℕ ↦ f k * g l` is summable if and only if the family
`(n, k, l) : Σ (n : ℕ), antidiagonal n ↦ f k * g l` is summable. -/
theorem summable_mul_prod_iff_summable_mul_sigma_antidiagonal :
    (Summable fun x : A × A ↦ f x.1 * g x.2) ↔
      Summable fun x : Σn : A, antidiagonal n ↦ f (x.2 : A × A).1 * g (x.2 : A × A).2
-- Mathlib/Order/Hom/Basic.lean
/-- `Subtype.val` as a bundled monotone function.  -/
@[simps (config := .asFn)]
def Subtype.val (p : α → Prop) : Subtype p →o α
-- Mathlib/Algebra/Divisibility/Units.lean
theorem isUnit_of_dvd_one {a : α} (h : a ∣ 1) : IsUnit (a : α)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- Subtracting the first vector passed to `oangle` from the second vector then swapping the
vectors does not change the sign of the angle. -/
@[simp]
theorem oangle_sign_sub_right_swap (x y : V) : (o.oangle y (y - x)).sign = (o.oangle x y).sign
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
/-- If `B : M → N → Pₗ` is `R`-`S` bilinear and `R'` and `S'` are compatible scalar multiplications,
then the restriction of scalars is a `R'`-`S'` bilinear map. -/
@[simps!]
def restrictScalars (Q : QuadraticMap R M N) : QuadraticMap S M N
-- Mathlib/Geometry/Euclidean/Circumcenter.lean
/-- Two n-simplices among cospherical points in an n-dimensional
subspace have the same circumcenter. -/
theorem circumcenter_eq_of_cospherical_subset {s : AffineSubspace ℝ P} {ps : Set P} (h : ps ⊆ s)
    [Nonempty s] {n : ℕ} [FiniteDimensional ℝ s.direction] (hd : finrank ℝ s.direction = n)
    (hc : Cospherical ps) {sx₁ sx₂ : Simplex ℝ P n} (hsx₁ : Set.range sx₁.points ⊆ ps)
    (hsx₂ : Set.range sx₂.points ⊆ ps) : sx₁.circumcenter = sx₂.circumcenter
-- Mathlib/CategoryTheory/Equivalence.lean
@[reassoc, simp]
theorem fun_inv_map (e : C ≌ D) (X Y : D) (f : X ⟶ Y) :
    e.functor.map (e.inverse.map f) = e.counit.app X ≫ f ≫ e.counitInv.app Y
-- Mathlib/Topology/FiberBundle/Basic.lean
theorem inducing_totalSpaceMk_of_inducing_comp (b : B)
    (h : Inducing (a.pretrivializationAt b ∘ TotalSpace.mk b)) :
    @Inducing _ _ _ a.totalSpaceTopology (TotalSpace.mk b)
-- Mathlib/CategoryTheory/Functor/KanExtension/Basic.lean
lemma isLeftKanExtension_iff_precomp (α : F ⟶ L ⋙ F') :
    F'.IsLeftKanExtension α ↔ F'.IsLeftKanExtension
      (whiskerLeft G α ≫ (Functor.associator _ _ _).inv)
-- Mathlib/Order/Bounds/Basic.lean
lemma bddAbove_prod {s : Set (α × β)} :
    BddAbove s ↔ BddAbove (Prod.fst '' s) ∧ BddAbove (Prod.snd '' s)
-- Mathlib/Topology/ContinuousOn.lean
theorem nhdsWithin_inter' (a : α) (s t : Set α) : 𝓝[s ∩ t] a = 𝓝[s] a ⊓ 𝓟 t
-- Mathlib/FieldTheory/Perfect.lean
@[simp]
theorem frobeniusEquiv_symm_pow_p (x : R) : ((frobeniusEquiv R p).symm x) ^ p = x
-- Mathlib/Analysis/SpecialFunctions/Stirling.lean
theorem log_stirlingSeq_formula (n : ℕ) :
    log (stirlingSeq n) = Real.log n ! - 1 / 2 * Real.log (2 * n) - n * log (n / exp 1)
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_eq_self_of_ae_mem {_m0 : MeasurableSpace α} ⦃s : Set α⦄ ⦃μ : Measure α⦄
    (hs : ∀ᵐ x ∂μ, x ∈ s) : μ.restrict s = μ
-- Mathlib/Data/Real/Hyperreal.lean
@[simp, norm_cast]
theorem coe_pos {x : ℝ} : 0 < (x : ℝ*) ↔ 0 < x
-- Mathlib/Algebra/Lie/Weights/Basic.lean
/-- See also `LieModule.iInf_lowerCentralSeries_eq_posFittingComp`. -/
lemma iSup_ucs_eq_weightSpace_zero [IsNoetherian R M] :
    ⨆ k, (⊥ : LieSubmodule R L M).ucs k = weightSpace M (0 : L → R)
-- Mathlib/Analysis/NormedSpace/ENorm.lean
@[simp, norm_cast]
theorem coe_max (e₁ e₂ : ENorm 𝕜 V) : ⇑(e₁ ⊔ e₂) = fun x => max (e₁ x) (e₂ x)
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem beth_limit {o : Ordinal} : o.IsLimit → beth o = ⨆ a : Iio o, beth a
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
/-- Radon-Nikodym derivative of the scalar multiple of a measure.
See also `rnDeriv_smul_left_of_ne_top`, which has no hypothesis on `μ` but requires finite `ν`. -/
theorem rnDeriv_smul_left_of_ne_top' (ν μ : Measure α) [SigmaFinite ν] [SigmaFinite μ]
    {r : ℝ≥0∞} (hr : r ≠ ∞) :
    (r • ν).rnDeriv μ =ᵐ[μ] r • ν.rnDeriv μ
-- Mathlib/Topology/ContinuousOn.lean
theorem continuousOn_prod_of_discrete_right [DiscreteTopology β] {f : α × β → γ} {s : Set (α × β)} :
    ContinuousOn f s ↔ ∀ b, ContinuousOn (f ⟨·, b⟩) {a | (a, b) ∈ s}
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem extend_coe : ⇑(f.extend I) = I ∘ f
-- Mathlib/FieldTheory/Adjoin.lean
theorem subsingleton_of_finrank_adjoin_eq_one (h : ∀ x : E, finrank F F⟮x⟯ = 1) :
    Subsingleton (IntermediateField F E)
-- Mathlib/Data/QPF/Multivariate/Basic.lean
theorem liftpPreservation_iff_uniform : q.LiftPPreservation ↔ q.IsUniform
-- Mathlib/Algebra/Module/Submodule/Basic.lean
@[mono]
theorem toAddSubmonoid_mono : Monotone (toAddSubmonoid : Submodule R M → AddSubmonoid M)
-- Mathlib/Tactic/NormNum/Ineq.lean
theorem isInt_le_false [OrderedRing α] [Nontrivial α] {a b : α} {a' b' : ℤ}
    (ha : IsInt a a') (hb : IsInt b b') (h : decide (b' < a')) : ¬a ≤ b
-- Mathlib/RingTheory/Etale/Basic.lean
theorem of_equiv [FormallyEtale R A] (e : A ≃ₐ[R] B) : FormallyEtale R B
-- Mathlib/Logic/Basic.lean
theorem not_forall_not : (¬∀ x, ¬p x) ↔ ∃ x, p x
-- Mathlib/Algebra/Order/AddGroupWithTop.lean
@[simp]
theorem add_top (a : α) : a + ⊤ = ⊤
-- Mathlib/RingTheory/Kaehler/Basic.lean
@[simp]
theorem KaehlerDifferential.map_D (x : A) :
    KaehlerDifferential.map R S A B (KaehlerDifferential.D R A x) =
      KaehlerDifferential.D S B (algebraMap A B x)
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
@[simp]
theorem basicOpen_zero : basicOpen 𝒜 (0 : A) = ⊥
-- Mathlib/Algebra/Module/LinearMap/End.lean
@[simp]
theorem _root_.Module.End.ofNat_apply (n : ℕ) [n.AtLeastTwo] (m : M) :
    (no_index (OfNat.ofNat n) : Module.End R M) m = OfNat.ofNat n • m
-- Mathlib/Algebra/Order/Sub/Canonical.lean
/-- See `lt_tsub_iff_left_of_le_of_le` for a weaker statement in a partial order. -/
theorem tsub_lt_tsub_iff_left_of_le (h : b ≤ a) : a - b < a - c ↔ c < b
-- Mathlib/Algebra/Polynomial/Splits.lean
theorem splits_of_degree_le_one {f : K[X]} (hf : degree f ≤ 1) : Splits i f
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp]
theorem top_add (a : WithTop α) : ⊤ + a = ⊤
-- Mathlib/Data/DFinsupp/WellFounded.lean
theorem Lex.acc_of_single_erase [DecidableEq ι] {x : Π₀ i, α i} (i : ι)
    (hs : Acc (DFinsupp.Lex r s) <| single i (x i)) (hu : Acc (DFinsupp.Lex r s) <| x.erase i) :
    Acc (DFinsupp.Lex r s) x
-- Mathlib/Data/Num/Lemmas.lean
theorem neg_zero : (-0 : ZNum) = 0
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
theorem compl (h : NullMeasurableSet s μ) : NullMeasurableSet sᶜ μ
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
@[simp]
theorem nmul_zero (a) : a ⨳ 0 = 0
-- Mathlib/Topology/MetricSpace/Thickening.lean
theorem mem_thickening_iff_infEdist_lt : x ∈ thickening δ s ↔ infEdist x s < ENNReal.ofReal δ
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma uIcc_subset_uIcc_left (h : x ∈ [[a, b]]) : [[a, x]] ⊆ [[a, b]]
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem integral_univ : ∫ x in univ, f x ∂μ = ∫ x, f x ∂μ
-- Mathlib/Analysis/Convex/Function.lean
/-- A linear map is concave. -/
theorem LinearMap.concaveOn (f : E →ₗ[𝕜] β) {s : Set E} (hs : Convex 𝕜 s) : ConcaveOn 𝕜 s f
-- Mathlib/Topology/Algebra/Ring/Basic.lean
@[ext]
theorem ext {f g : RingTopology α} (h : f.IsOpen = g.IsOpen) : f = g
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[deprecated Subalgebra.finite_sup (since := "2024-04-11")]
theorem Subalgebra.finiteDimensional_sup {K L : Type*} [Field K] [CommRing L] [Algebra K L]
    (E1 E2 : Subalgebra K L) [FiniteDimensional K E1] [FiniteDimensional K E2] :
    FiniteDimensional K (E1 ⊔ E2 : Subalgebra K L)
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem liftAddHom_tmul (f : M →+ N →+ P)
    (hf : ∀ (r : R) (m : M) (n : N), f (r • m) n = f m (r • n)) (m : M) (n : N) :
    liftAddHom f hf (m ⊗ₜ n) = f m n
-- Mathlib/Algebra/Polynomial/Derivative.lean
@[simp]
theorem iterate_derivative_comp_one_sub_X (p : R[X]) (k : ℕ) :
    derivative^[k] (p.comp (1 - X)) = (-1) ^ k * (derivative^[k] p).comp (1 - X)
-- Mathlib/Algebra/Quaternion.lean
/-- The cardinality of a quaternion algebra, as a type. -/
theorem mk_quaternionAlgebra : #(ℍ[R,c₁,c₂]) = #R ^ 4
-- Mathlib/Data/Finset/Union.lean
lemma filter_biUnion (s : Finset α) (f : α → Finset β) (p : β → Prop) [DecidablePred p] :
    (s.biUnion f).filter p = s.biUnion fun a ↦ (f a).filter p
-- Mathlib/Algebra/Order/Hom/Ring.lean
@[simp]
theorem trans_apply (f : α ≃+*o β) (g : β ≃+*o γ) (a : α) : f.trans g a = g (f a)