ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
/-- Multiplicativity of a continuous alternating map along all coordinates at the same time,
writing `f (fun i ↦ c i • m i)` as `(∏ i, c i) • f m`. -/
theorem map_smul_univ [Fintype ι] (c : ι → R) (m : ι → M) :
    (f fun i => c i • m i) = (∏ i, c i) • f m
-- Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean
/-- If `C` has an object such that every morphism *from* it is an isomorphism, then `C`
has strict terminal objects. -/
theorem hasStrictTerminalObjects_of_terminal_is_strict (I : C) (h : ∀ (A) (f : I ⟶ A), IsIso f) :
    HasStrictTerminalObjects C
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem mul_eq_of_eq_div' (h : b = c / a) : a * b = c
-- Mathlib/AlgebraicTopology/SplitSimplicialObject.lean
@[ext]
theorem hom_ext {S₁ S₂ : Split C} (Φ₁ Φ₂ : S₁ ⟶ S₂) (h : ∀ n : ℕ, Φ₁.f n = Φ₂.f n) : Φ₁ = Φ₂
-- Mathlib/CategoryTheory/Localization/Resolution.lean
lemma nonempty_leftResolution_iff_op (X₂ : C₂) :
    Nonempty (Φ.LeftResolution X₂) ↔ Nonempty (Φ.op.RightResolution (Opposite.op X₂))
-- Mathlib/CategoryTheory/DifferentialObject.lean
/-- The composition of morphisms of differential objects. -/
@[simps]
def comp {X Y Z : DifferentialObject S C} (f : Hom X Y) (g : Hom Y Z) : Hom X Z
-- Mathlib/Logic/Basic.lean
theorem exists_apply_eq (a : α) (b : β) : ∃ f : α → β, f a = b
-- .lake/packages/lean4/src/lean/Init/Data/Nat/SOM.lean
theorem Poly.denote_insertSorted (ctx : Context) (k : Nat) (m : Mon) (p : Poly) : (p.insertSorted k m).denote ctx = p.denote ctx + k * m.denote ctx
-- Mathlib/Order/RelClasses.lean
@[simp]
theorem not_bounded_iff {r : α → α → Prop} (s : Set α) : ¬Bounded r s ↔ Unbounded r s
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Chebyshev.lean
/-- The `n`-th Chebyshev polynomial of the second kind evaluates on `cos θ` to the
value `sin ((n + 1) * θ) / sin θ`. -/
@[simp]
theorem U_real_cos : (U ℝ n).eval (cos θ) * sin θ = sin ((n + 1) * θ)
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem add_tmul (m₁ m₂ : M) (n : N) : (m₁ + m₂) ⊗ₜ n = m₁ ⊗ₜ n + m₂ ⊗ₜ[R] n
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem diag_neg [Neg α] (A : Matrix n n α) : diag (-A) = -diag A
-- Mathlib/CategoryTheory/Noetherian.lean
/-- A category is noetherian if it is essentially small and all objects are noetherian. -/
class Noetherian extends EssentiallySmall C : Prop where
  noetherianObject : ∀ X : C, NoetherianObject X
-- Mathlib/Analysis/Normed/Operator/Banach.lean
theorem frontier_preimage (hsurj : Surjective f) (s : Set F) :
    frontier (f ⁻¹' s) = f ⁻¹' frontier s
-- Mathlib/LinearAlgebra/Pi.lean
theorem pi_mono {s : Set ι} (h : ∀ i ∈ s, p i ≤ q i) : pi s p ≤ pi s q
-- Mathlib/Algebra/Polynomial/UnitTrinomial.lean
theorem coeff_isUnit (hp : p.IsUnitTrinomial) {k : ℕ} (hk : k ∈ p.support) :
    IsUnit (p.coeff k)
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
theorem IsBilimit.binary_total {X Y : C} {b : BinaryBicone X Y} (i : b.IsBilimit) :
    b.fst ≫ b.inl + b.snd ≫ b.inr = 𝟙 b.pt
-- Mathlib/Logic/Nonempty.lean
@[simp]
theorem nonempty_psigma {α} {β : α → Sort*} : Nonempty (PSigma β) ↔ ∃ a : α, Nonempty (β a)
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
/-- If the union of s is unbounded and s is smaller than the cofinality,
  then s has an unbounded member -/
theorem unbounded_of_unbounded_iUnion {α β : Type u} (r : α → α → Prop) [wo : IsWellOrder α r]
    (s : β → Set α) (h₁ : Unbounded r <| ⋃ x, s x) (h₂ : #β < StrictOrder.cof r) :
    ∃ x : β, Unbounded r (s x)
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[simp]
theorem coe_moebius_mul_coe_zeta [Ring R] : (μ * ζ : ArithmeticFunction R) = 1
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem Measurable.eq_mp {β} [MeasurableSpace β] {i i' : δ} (h : i = i') {f : β → π i}
    (hf : Measurable f) : Measurable fun x => (congr_arg π h).mp (f x)
-- Mathlib/Logic/Equiv/Basic.lean
/-- `PUnit` is a right identity for dependent type product up to an equivalence. -/
@[simps]
def sigmaPUnit (α) : (_ : α) × PUnit ≃ α
-- Mathlib/Order/LiminfLimsup.lean
theorem sup_limsup [NeBot f] (a : α) : a ⊔ limsup u f = limsup (fun x => a ⊔ u x) f
-- Mathlib/Analysis/Analytic/Meromorphic.lean
/-- Compatibility of notions of `order` for analytic and meromorphic functions. -/
lemma _root_.AnalyticAt.meromorphicAt_order {f : 𝕜 → E} {x : 𝕜} (hf : AnalyticAt 𝕜 f x) :
    hf.meromorphicAt.order = hf.order.map (↑)
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem coe_top [Top β] : ⇑(⊤ : InfHom α β) = ⊤
-- Mathlib/Analysis/Convex/Segment.lean
@[simp]
theorem mem_segment_translate (a : E) {x b c} : a + x ∈ [a + b -[𝕜] a + c] ↔ x ∈ [b -[𝕜] c]
-- Mathlib/LinearAlgebra/DirectSum/Finsupp.lean
@[simp]
lemma finsuppScalarRight_symm_apply_single (i : ι) (m : M) :
    (finsuppScalarRight R M ι).symm (Finsupp.single i m) =
      m ⊗ₜ[R] (Finsupp.single i 1)
-- Mathlib/Topology/MetricSpace/ThickenedIndicator.lean
theorem indicator_le_thickenedIndicator {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) :
    (E.indicator fun _ => (1 : ℝ≥0)) ≤ thickenedIndicator δ_pos E
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive (attr := simp)]
theorem coe_map (f : F) (S : Submonoid M) : (S.map f : Set N) = f '' S
-- Mathlib/Algebra/RingQuot.lean
theorem sub_quot {R : Type uR} [Ring R] (r : R → R → Prop) {a b} :
    (⟨Quot.mk _ a⟩ - ⟨Quot.mk _ b⟩ : RingQuot r) = ⟨Quot.mk _ (a - b)⟩
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem Bool.not_eq_false' (b : Bool) : ((!b) = false) = (b = true)
-- Mathlib/Order/Ideal.lean
protected theorem lower (s : Ideal P) : IsLowerSet (s : Set P)
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
protected theorem zsmul_mem {R : Type u} {A : Type v} [CommRing R] [Ring A] [Algebra R A]
    (S : Subalgebra R A) {x : A} (hx : x ∈ S) (n : ℤ) : n • x ∈ S
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
/-- A morphism in `SimplexCategory` is a monomorphism precisely when it is an injective function
-/
theorem mono_iff_injective {n m : SimplexCategory} {f : n ⟶ m} :
    Mono f ↔ Function.Injective f.toOrderHom
-- Mathlib/RingTheory/Coalgebra/Hom.lean
@[simp]
theorem comp_id : φ.comp (CoalgHom.id R A) = φ
-- Mathlib/Topology/UniformSpace/Equiv.lean
/-- Uniform isomorphism between `α² = Fin 2 → α` and `α × α`. -/
-- Porting note: made `α` explicit
@[simps! (config := .asFn)]
def finTwoArrow (α : Type*) [UniformSpace α] : (Fin 2 → α) ≃ᵤ α × α
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
@[fun_prop]
protected theorem differentiableOn : DifferentiableOn 𝕜 iso s
-- Mathlib/Order/Partition/Finpartition.lean
@[simp]
theorem mem_avoid : c ∈ (P.avoid b).parts ↔ ∃ d ∈ P.parts, ¬d ≤ b ∧ d \ b = c
-- Mathlib/CategoryTheory/Endofunctor/Algebra.lean
@[simp]
theorem id_f : (𝟙 _ : A ⟶ A).1 = 𝟙 A.1
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem writtenInExtChartAt_extChartAt_symm {x : M} {y : E} (h : y ∈ (extChartAt I x).target) :
    writtenInExtChartAt 𝓘(𝕜, E) I (extChartAt I x x) (extChartAt I x).symm y = y
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem continuous_iff'_right [TopologicalSpace β] {f : β → α} :
    Continuous f ↔ ∀ b, Tendsto (fun x => (f b, f x)) (𝓝 b) (𝓤 α)
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem eLpNorm_indicator_eq_eLpNorm_restrict {f : α → F} (hs : MeasurableSet s) :
    eLpNorm (s.indicator f) p μ = eLpNorm f p (μ.restrict s)
-- Mathlib/Analysis/NormedSpace/Multilinear/Curry.lean
@[simp]
theorem ContinuousMultilinearMap.curry0_apply (x : G') (m : Fin 0 → G) :
    ContinuousMultilinearMap.curry0 𝕜 G x m = x
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive (attr := simp) smul_ite]
lemma ite_pow (p : Prop) [Decidable p] (a b : α) (c : β) :
    (if p then a else b) ^ c = if p then a ^ c else b ^ c
-- Mathlib/Data/Sum/Basic.lean
@[simp] theorem isSome_getRight?_iff_isRight : x.getRight?.isSome ↔ x.isRight
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
theorem HasStrictFDerivAt.neg (h : HasStrictFDerivAt f f' x) :
    HasStrictFDerivAt (fun x => -f x) (-f') x
-- Mathlib/SetTheory/Surreal/Multiplication.lean
lemma ih1_neg_right : IH1 x y → IH1 x (-y)
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
theorem sub_mem_orthogonal_of_inner_right {x y : E} (h : ∀ v : K, ⟪(v : E), x⟫ = ⟪(v : E), y⟫) :
    x - y ∈ Kᗮ
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem edges_cons {u v w : V} (h : G.Adj u v) (p : G.Walk v w) :
    (cons h p).edges = s(u, v) :: p.edges
-- Mathlib/Topology/FiberBundle/Constructions.lean
@[simp]
theorem trivialization_source : (trivialization B F).source = univ
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
@[simp]
theorem dimH_bUnion {s : Set ι} (hs : s.Countable) (t : ι → Set X) :
    dimH (⋃ i ∈ s, t i) = ⨆ i ∈ s, dimH (t i)
-- Mathlib/FieldTheory/Separable.lean
theorem separable_def' (f : R[X]) : f.Separable ↔ ∃ a b : R[X], a * f + b * (derivative f) = 1
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Mono.lean
theorem fst_eq_snd_of_mono_eq [Mono f] : pullback.fst f f = pullback.snd f f
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
theorem neighborSet_compl (G : SimpleGraph V) (v : V) :
    Gᶜ.neighborSet v = (G.neighborSet v)ᶜ \ {v}
-- Mathlib/Dynamics/PeriodicPts.lean
@[simp]
theorem periodicOrbit_eq_nil_iff_not_periodic_pt :
    periodicOrbit f x = Cycle.nil ↔ x ∉ periodicPts f
-- Mathlib/CategoryTheory/Monoidal/Category.lean
/-- The associator as a natural isomorphism. -/
@[simps!]
def associatorNatIso : leftAssocTensor C ≅ rightAssocTensor C
-- Mathlib/Algebra/Polynomial/Monomial.lean
theorem card_support_le_one_iff_monomial {f : R[X]} :
    Finset.card f.support ≤ 1 ↔ ∃ n a, f = monomial n a
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem eLpNorm_const (c : F) (h0 : p ≠ 0) (hμ : μ ≠ 0) :
    eLpNorm (fun _ : α => c) p μ = (‖c‖₊ : ℝ≥0∞) * μ Set.univ ^ (1 / ENNReal.toReal p)
-- Mathlib/Algebra/GCDMonoid/Basic.lean
@[simp]
theorem lcm_mul_right [NormalizedGCDMonoid α] (a b c : α) :
    lcm (b * a) (c * a) = lcm b c * normalize a
-- Mathlib/Data/Finset/Lattice.lean
@[simp]
protected theorem le_sup_iff (ha : ⊥ < a) : a ≤ s.sup f ↔ ∃ b ∈ s, a ≤ f b
-- Mathlib/Data/Real/EReal.lean
@[simp]
lemma preimage_coe_Iic (y : ℝ) : Real.toEReal ⁻¹' Iic y = Iic y
-- Mathlib/Algebra/DirectSum/Ring.lean
/-- Families of `AddMonoidHom`s preserving `DirectSum.One.one` and `DirectSum.Mul.mul`
are isomorphic to `RingHom`s on `⨁ i, A i`. This is a stronger version of `DFinsupp.liftAddHom`.
-/
@[simps]
def liftRingHom :
    { f : ∀ {i}, A i →+ R //
        f GradedMonoid.GOne.one = 1 ∧
          ∀ {i j} (ai : A i) (aj : A j), f (GradedMonoid.GMul.mul ai aj) = f ai * f aj } ≃
      ((⨁ i, A i) →+* R)
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
theorem LinearMap.toMatrix₂'_mul (B : (n → R) →ₗ[R] (m → R) →ₗ[R] R) (M : Matrix m m' R) :
    toMatrix₂' R B * M = toMatrix₂' R (B.compl₂ <| toLin' M)
-- .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean
theorem Heap.WF.merge' (h₁ : s₁.WF le n) (h₂ : s₂.WF le n) :
    (merge le s₁ s₂).WF le n ∧ ((s₁.rankGT n ↔ s₂.rankGT n) → (merge le s₁ s₂).rankGT n)
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc, simp]
theorem id_whiskerLeft {X Y : C} (f : X ⟶ Y) :
    𝟙_ C ◁ f = (λ_ X).hom ≫ f ≫ (λ_ Y).inv
-- Mathlib/Algebra/Field/Basic.lean
theorem neg_inv : -a⁻¹ = (-a)⁻¹
-- Mathlib/RingTheory/OreLocalization/Basic.lean
@[to_additive]
protected theorem one_def : (1 : R[S⁻¹]) = 1 /ₒ 1
-- Mathlib/Analysis/Calculus/InverseFunctionTheorem/ApproximatesLinearOn.lean
@[simp]
theorem toPartialHomeomorph_target (hf : ApproximatesLinearOn f (f' : E →L[𝕜] F) s c)
    (hc : Subsingleton E ∨ c < N⁻¹) (hs : IsOpen s) :
    (hf.toPartialHomeomorph f s hc hs).target = f '' s
-- Mathlib/Data/Real/ConjExponents.lean
theorem sub_one_pos : 0 < p - 1
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive (attr := simp) le_add_iff_nonneg_left]
theorem le_mul_iff_one_le_left' [CovariantClass α α (swap (· * ·)) (· ≤ ·)]
    [ContravariantClass α α (swap (· * ·)) (· ≤ ·)] (a : α) {b : α} :
    a ≤ b * a ↔ 1 ≤ b
-- Mathlib/Data/Complex/Exponential.lean
@[simp]
theorem ofReal_sin_ofReal_re (x : ℝ) : ((sin x).re : ℂ) = sin x
-- Mathlib/Order/SuccPred/Limit.lean
theorem not_isSuccLimit_iff_exists_covBy (a : α) : ¬IsSuccLimit a ↔ ∃ b, b ⋖ a
-- Mathlib/Data/Nat/Totient.lean
/-- Euler's product formula for the totient function. -/
theorem totient_eq_div_primeFactors_mul (n : ℕ) :
    φ n = (n / ∏ p ∈ n.primeFactors, p) * ∏ p ∈ n.primeFactors, (p - 1)
-- Mathlib/Algebra/GroupWithZero/Invertible.lean
@[simp]
theorem inv_mul_cancel_of_invertible (a : α) [Invertible a] : a⁻¹ * a = 1
-- Mathlib/RingTheory/Unramified/Derivations.lean
theorem FormallyUnramified.iff_subsingleton_kaehlerDifferential :
    FormallyUnramified R S ↔ Subsingleton (Ω[S⁄R])
-- Mathlib/Order/Interval/Set/Basic.lean
theorem right_mem_Icc : b ∈ Icc a b ↔ a ≤ b
-- Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean
/-- Invertibility in the exterior algebra is the same as invertibility of the base ring. -/
@[simps!]
def invertibleAlgebraMapEquiv (r : R) :
    Invertible (algebraMap R (ExteriorAlgebra R M) r) ≃ Invertible r
-- Mathlib/SetTheory/Cardinal/ENat.lean
lemma toENat_nat (n : ℕ) : toENat n = n
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem le_of_add_le_add_right {a b c : Nat} : a + b ≤ c + b → a ≤ c
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem real_inner_eq_re_inner (x y : E) :
    @Inner.inner ℝ E (Inner.rclikeToReal 𝕜 E) x y = re ⟪x, y⟫
-- Mathlib/Algebra/CharP/Two.lean
theorem list_sum_mul_self (l : List R) : l.sum * l.sum = (List.map (fun x => x * x) l).sum
-- Mathlib/Data/Set/Basic.lean
theorem Nonempty.to_subtype : s.Nonempty → Nonempty (↥s)
-- Mathlib/Probability/Independence/ZeroOne.lean
theorem measure_zero_or_one_of_measurableSet_limsup (h_le : ∀ n, s n ≤ m0) (h_indep : iIndep s μ)
    (hf : ∀ t, p t → tᶜ ∈ f) (hns : Directed (· ≤ ·) ns) (hnsp : ∀ a, p (ns a))
    (hns_univ : ∀ n, ∃ a, n ∈ ns a) {t : Set Ω} (ht_tail : MeasurableSet[limsup s f] t) :
    μ t = 0 ∨ μ t = 1
-- Mathlib/Data/Real/Hyperreal.lean
theorem not_infinite_mul {x y : ℝ*} (hx : ¬Infinite x) (hy : ¬Infinite y) : ¬Infinite (x * y)
-- Mathlib/Logic/Nonempty.lean
@[simp]
theorem nonempty_pprod {α β} : Nonempty (PProd α β) ↔ Nonempty α ∧ Nonempty β
-- Mathlib/Algebra/Group/Hom/Instances.lean
@[to_additive]
theorem ext_iff₂ {_ : MulOneClass M} {_ : MulOneClass N} {_ : CommMonoid P} {f g : M →* N →* P} :
    f = g ↔ ∀ x y, f x y = g x y
-- Mathlib/LinearAlgebra/LinearDisjoint.lean
/-- The `Submodule.LinearDisjoint.rank_le_one_of_commute_of_flat_of_self`
for commutative rings. -/
theorem rank_le_one_of_flat_of_self (H : M.LinearDisjoint M) [Module.Flat R M] :
    Module.rank R M ≤ 1
-- Mathlib/ModelTheory/Encoding.lean
theorem listDecode_encode_list (l : List (L.Term α)) :
    listDecode (l.bind listEncode) = l
-- Mathlib/Analysis/Convex/Function.lean
theorem OrderIso.concaveOn_symm (f : α ≃o β) (hf : ConvexOn 𝕜 univ f) :
    ConcaveOn 𝕜 univ f.symm
-- Mathlib/Algebra/GroupWithZero/WithZero.lean
lemma unzero_mul {x y : WithZero α} (hxy : x * y ≠ 0) :
    unzero hxy = unzero (left_ne_zero_of_mul hxy) * unzero (right_ne_zero_of_mul hxy)
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem UniformSpace.Core.ext :
    ∀ {u₁ u₂ : UniformSpace.Core α}, u₁.uniformity = u₂.uniformity → u₁ = u₂
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma comap_surjective [Algebra k K] [Algebra.IsAlgebraic k K] :
    Function.Surjective (comap · (algebraMap k K))
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem comp_assoc (f : FrameHom γ δ) (g : FrameHom β γ) (h : FrameHom α β) :
    (f.comp g).comp h = f.comp (g.comp h)
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem ContMDiffWithinAt.insert (h : ContMDiffWithinAt I I' n f s x) :
    ContMDiffWithinAt I I' n f (insert x s) x
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- If `u` is a uniform structures on `β` and `f : γ → β`, then
`𝒰(α, γ, comap f u) = comap (fun g ↦ f ∘ g) 𝒰(α, γ, u₁)`. -/
protected theorem comap_eq {f : γ → β} :
    𝒰(α, γ, ‹UniformSpace β›.comap f) = 𝒰(α, β, _).comap (f ∘ ·)
-- Mathlib/Order/SupClosed.lean
lemma SupClosed.inter (hs : SupClosed s) (ht : SupClosed t) : SupClosed (s ∩ t)
-- Mathlib/Algebra/Polynomial/Reverse.lean
@[simp]
theorem coeff_reflect (N : ℕ) (f : R[X]) (i : ℕ) : coeff (reflect N f) i = f.coeff (revAt N i)
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
theorem isUnit_iff {z : ℤ_[p]} : IsUnit z ↔ ‖z‖ = 1
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
theorem differentiableAt_exp {x : ℂ} : DifferentiableAt 𝕜 exp x
-- Mathlib/RingTheory/HahnSeries/Addition.lean
theorem min_orderTop_le_orderTop_add {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R} :
    min x.orderTop y.orderTop ≤ (x + y).orderTop
-- Mathlib/Algebra/BigOperators/Finprod.lean
@[to_additive]
theorem finprod_mem_finset_eq_prod (f : α → M) (s : Finset α) : ∏ᶠ i ∈ s, f i = ∏ i ∈ s, f i
-- Mathlib/NumberTheory/Padics/PadicVal.lean
theorem dvd_iff_padicValNat_ne_zero {p n : ℕ} [Fact p.Prime] (hn0 : n ≠ 0) :
    p ∣ n ↔ padicValNat p n ≠ 0
-- Mathlib/NumberTheory/ZetaValues.lean
theorem antideriv_bernoulliFun (k : ℕ) (x : ℝ) :
    HasDerivAt (fun x => bernoulliFun (k + 1) x / (k + 1)) (bernoulliFun k x) x
-- Mathlib/Order/Category/BddDistLat.lean
/-- Constructs an equivalence between bounded distributive lattices from an order isomorphism
between them. -/
@[simps]
def Iso.mk {α β : BddDistLat.{u}} (e : α ≃o β) : α ≅ β
-- Mathlib/Analysis/Convex/Cone/InnerDual.lean
theorem innerDualCone_union (s t : Set H) :
    (s ∪ t).innerDualCone = s.innerDualCone ⊓ t.innerDualCone
-- Mathlib/Algebra/Ring/Divisibility/Lemmas.lean
lemma dvd_mul_sub_mul_mul_right_of_dvd {p a b c d x y : R}
    (h1 : p ∣ a * x + b * y) (h2 : p ∣ c * x + d * y) : p ∣ (a * d - b * c) * y
-- Mathlib/Data/Nat/Squarefree.lean
theorem squarefree_two : Squarefree 2
-- Mathlib/Algebra/Order/Ring/Basic.lean
theorem one_le_sq_iff {a : R} (ha : 0 ≤ a) : 1 ≤ a ^ 2 ↔ 1 ≤ a
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem bddAbove_range_comp {ι : Type u} {f : ι → Cardinal.{v}} (hf : BddAbove (range f))
    (g : Cardinal.{v} → Cardinal.{max v w}) : BddAbove (range (g ∘ f))
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem mapMatrix_trans (f : α ≃ₗ[R] β) (g : β ≃ₗ[R] γ) :
    f.mapMatrix.trans g.mapMatrix = ((f.trans g).mapMatrix : Matrix m n α ≃ₗ[R] _)
-- Mathlib/Algebra/Order/Hom/Monoid.lean
@[to_additive (attr := simp)]
theorem cancel_left {g : β →*o γ} {f₁ f₂ : α →*o β} (hg : Function.Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂
-- Mathlib/Data/Finset/Sym.lean
theorem not_isDiag_mk_of_mem_offDiag {a : α × α} (h : a ∈ s.offDiag) :
    ¬ (Sym2.mk a).IsDiag
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem pi_of_empty {α : Type*} [Fintype α] [IsEmpty α] {β : α → Type*}
    {m : ∀ a, MeasurableSpace (β a)} (μ : ∀ a : α, Measure (β a)) (x : ∀ a, β a := isEmptyElim) :
    Measure.pi μ = dirac x
-- Mathlib/Geometry/Manifold/ContMDiff/NormedSpace.lean
theorem ContMDiffWithinAt.smul {f : M → 𝕜} {g : M → V} (hf : ContMDiffWithinAt I 𝓘(𝕜) n f s x)
    (hg : ContMDiffWithinAt I 𝓘(𝕜, V) n g s x) :
    ContMDiffWithinAt I 𝓘(𝕜, V) n (fun p => f p • g p) s x
-- Mathlib/Topology/Instances/Matrix.lean
theorem Continuous.matrix_elem {A : X → Matrix m n R} (hA : Continuous A) (i : m) (j : n) :
    Continuous fun x => A x i j
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma add_of_not_equiv {P Q : Fin 3 → R} (h : ¬P ≈ Q) : W'.add P Q = W'.addXYZ P Q
-- Mathlib/Algebra/Module/Submodule/Bilinear.lean
theorem map₂_le_map₂_right {f : M →ₗ[R] N →ₗ[R] P} {p : Submodule R M} {q₁ q₂ : Submodule R N}
    (h : q₁ ≤ q₂) : map₂ f p q₁ ≤ map₂ f p q₂
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
theorem measurable_biInf {ι} (s : Set ι) {f : ι → δ → α} (hs : s.Countable)
    (hf : ∀ i ∈ s, Measurable (f i)) : Measurable fun b => ⨅ i ∈ s, f i b
-- Mathlib/LinearAlgebra/LinearDisjoint.lean
/-- The zero module is linearly disjoint with any other submodules. -/
theorem bot_right : M.LinearDisjoint (⊥ : Submodule R S)
-- Mathlib/Logic/Unique.lean
@[ext]
protected theorem subsingleton_unique' : ∀ h₁ h₂ : Unique α, h₁ = h₂
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem exists_ne_one_of_prod_ne_one (h : ∏ x ∈ s, f x ≠ 1) : ∃ a ∈ s, f a ≠ 1
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem symm_symm (f : M ≃[L] N) :
    f.symm.symm = f
-- Mathlib/RepresentationTheory/Rep.lean
theorem hom_comm_apply {A B : Rep k G} (f : A ⟶ B) (g : G) (x : A) :
    f.hom (A.ρ g x) = B.ρ g (f.hom x)
-- Mathlib/Algebra/Lie/Subalgebra.lean
theorem mem_range_self (x : L) : f x ∈ f.range
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem eta : ∀ x : PSet, mk x.Type x.Func = x
-- Mathlib/Algebra/Homology/ShortComplex/PreservesHomology.lean
lemma RightHomologyData.mapOpcyclesIso_eq [S.HasRightHomology]
    [F.PreservesRightHomologyOf S] :
    S.mapOpcyclesIso F = (hr.map F).opcyclesIso ≪≫ F.mapIso hr.opcyclesIso.symm
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
lemma topology_eq : ‹_› = upperSet α
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
theorem comp_right_hasFDerivWithinAt_iff {f : F → G} {s : Set F} {x : E} {f' : F →L[𝕜] G} :
    HasFDerivWithinAt (f ∘ iso) (f'.comp (iso : E →L[𝕜] F)) (iso ⁻¹' s) x ↔
      HasFDerivWithinAt f f' s (iso x)
-- Mathlib/Data/Finset/Lattice.lean
protected theorem inf'_comm {t : Finset γ} (hs : s.Nonempty) (ht : t.Nonempty) (f : β → γ → α) :
    (s.inf' hs fun b => t.inf' ht (f b)) = t.inf' ht fun c => s.inf' hs fun b => f b c
-- Mathlib/Order/Filter/Basic.lean
theorem _root_.Function.Commute.filter_map {f g : α → α} (h : Function.Commute f g) :
    Function.Commute (map f) (map g)
-- Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean
@[reassoc (attr := simp)]
theorem diagonal_snd : diagonal f ≫ pullback.snd _ _ = 𝟙 _
-- Mathlib/Data/Finmap.lean
theorem Disjoint.symm_iff (x y : Finmap β) : Disjoint x y ↔ Disjoint y x
-- .lake/packages/lean4/src/lean/Init/WF.lean
theorem revLexAccessible {b} (acb : Acc s b) (aca : (a : α) → Acc r a): (a : α) → Acc (RevLex r s) ⟨a, b⟩
-- Mathlib/Algebra/Order/Field/Unbundled/Basic.lean
lemma one_div_pos : 0 < 1 / a ↔ 0 < a
-- Mathlib/Data/Multiset/Lattice.lean
@[simp]
theorem sup_union (s₁ s₂ : Multiset α) : (s₁ ∪ s₂).sup = s₁.sup ⊔ s₂.sup
-- Mathlib/Algebra/CharP/Quotient.lean
/-- `CharP.quotient_iff`, but stated in terms of inclusions of ideals. -/
theorem quotient_iff_le_ker_natCast {R : Type*} [CommRing R] (n : ℕ) [CharP R n] (I : Ideal R) :
    CharP (R ⧸ I) n ↔ I.comap (Nat.castRingHom R) ≤ RingHom.ker (Nat.castRingHom R)
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean
theorem convexBodySum_convex : Convex ℝ (convexBodySum K B)
-- Mathlib/CategoryTheory/Sites/LocallySurjective.lean
lemma isLocallySurjective_of_isLocallySurjective
    {F₁ F₂ F₃ : Cᵒᵖ ⥤ A} (f₁ : F₁ ⟶ F₂) (f₂ : F₂ ⟶ F₃)
    [IsLocallySurjective J (f₁ ≫ f₂)] :
    IsLocallySurjective J f₂
-- Mathlib/RingTheory/Ideal/Over.lean
theorem IntegralClosure.comap_lt_comap {I J : Ideal (integralClosure R S)} [I.IsPrime]
    (I_lt_J : I < J) :
    I.comap (algebraMap R (integralClosure R S)) < J.comap (algebraMap R (integralClosure R S))
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
theorem X_pow_dvd_iff {s : σ} {n : ℕ} {φ : MvPowerSeries σ R} :
    (X s : MvPowerSeries σ R) ^ n ∣ φ ↔ ∀ m : σ →₀ ℕ, m s < n → coeff R m φ = 0
-- Mathlib/FieldTheory/PerfectClosure.lean
@[simp]
theorem mk_inv (x : ℕ × K) : (mk K p x)⁻¹ = mk K p (x.1, x.2⁻¹)
-- Mathlib/CategoryTheory/Pi/Basic.lean
/-- The projections of `Functor.pi' F` are isomorphic to the functors of the family `F` -/
@[simps!]
def pi'CompEval {A : Type*} [Category A] (F : ∀ i, A ⥤ C i) (i : I) :
    pi' F ⋙ Pi.eval C i ≅ F i
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem lt_succ_of_lt (h : a < b) : a < succ b
-- Mathlib/RingTheory/PowerSeries/Trunc.lean
theorem degree_trunc_lt (f : R⟦X⟧) (n) : (trunc n f).degree < n
-- Mathlib/Algebra/CharP/Defs.lean
lemma natCast_eq_natCast' (h : a ≡ b [MOD p]) : (a : R) = b
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
theorem biprod.inlCokernelCofork_π : Cofork.π (biprod.inlCokernelCofork X Y) = biprod.snd
-- Mathlib/Analysis/NormedSpace/Int.lean
@[simp]
theorem toNat_add_toNat_neg_eq_norm (n : ℤ) : ↑n.toNat + ↑(-n).toNat = ‖n‖
-- Mathlib/Data/Nat/Defs.lean
protected lemma pow_lt_pow_right (ha : 1 < a) (h : m < n) : a ^ m < a ^ n