ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
@[simp]
theorem unitors_equal : (λ_ (𝟙 a)).hom = (ρ_ (𝟙 a)).hom
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
theorem mul_def (e e' : P₁ ≃ᵃ[k] P₁) : e * e' = e'.trans e
-- Mathlib/Analysis/Convex/Between.lean
theorem Sbtw.trans_wbtw_left_ne [NoZeroSMulDivisors R V] {w x y z : P} (h₁ : Sbtw R w y z)
    (h₂ : Wbtw R w x y) : x ≠ z
-- Mathlib/Order/Category/LinOrd.lean
theorem linOrd_dual_comp_forget_to_Lat :
    LinOrd.dual ⋙ forget₂ LinOrd Lat = forget₂ LinOrd Lat ⋙ Lat.dual
-- Mathlib/Topology/Metrizable/Basic.lean
/-- Given an embedding of a topological space into a metrizable space, the source space is also
metrizable. -/
theorem _root_.Embedding.metrizableSpace [MetrizableSpace Y] {f : X → Y} (hf : Embedding f) :
    MetrizableSpace X
-- Mathlib/Topology/Basic.lean
theorem mem_closure_iff :
    x ∈ closure s ↔ ∀ o, IsOpen o → x ∈ o → (o ∩ s).Nonempty
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
theorem singletonChartedSpace_chartAt_eq {f : α → H} (h : OpenEmbedding f) {x : α} :
    ⇑(@chartAt H _ α _ h.singletonChartedSpace x) = f
-- Mathlib/Data/List/Join.lean
@[simp]
theorem join_filter_not_isEmpty  :
    ∀ {L : List (List α)}, join (L.filter fun l => !l.isEmpty) = L.join
-- Mathlib/Analysis/Convex/Segment.lean
theorem image_mk_segment_right (x : E) (y₁ y₂ : F) :
    (fun y => (x, y)) '' [y₁ -[𝕜] y₂] = [(x, y₁) -[𝕜] (x, y₂)]
-- Mathlib/Data/Set/NAry.lean
@[simp]
theorem image2_eq_empty_iff : image2 f s t = ∅ ↔ s = ∅ ∨ t = ∅
-- Mathlib/Algebra/Module/Equiv/Basic.lean
theorem neg_apply (x : M) : neg R x = -x
-- Mathlib/RingTheory/Algebraic.lean
theorem AlgHom.bijective [FiniteDimensional K L] (ϕ : L →ₐ[K] L) : Function.Bijective ϕ
-- Mathlib/Algebra/DirectSum/Ring.lean
theorem mulHom_apply (a b : ⨁ i, A i) : mulHom A a b = a * b
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem hasFiniteIntegral_coeFn (f : α →₁[μ] β) : HasFiniteIntegral f μ
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Basic.lean
lemma EdgeDisjointTriangles.card_edgeFinset_le (hG : G.EdgeDisjointTriangles) :
    3 * (G.cliqueFinset 3).card ≤ G.edgeFinset.card
-- Mathlib/Algebra/Homology/DerivedCategory/Ext.lean
lemma hasExt_iff [HasDerivedCategory.{w'} C] :
    HasExt.{w} C ↔ ∀ (X Y : C) (n : ℤ), Small.{w}
      ((DerivedCategory.singleFunctor C 0).obj X ⟶
        (((DerivedCategory.singleFunctor C 0).obj Y)⟦n⟧))
-- Mathlib/Data/Finset/Card.lean
@[simp]
theorem card_range (n : ℕ) : (range n).card = n
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
protected theorem add_lt_add_iff_left [CovariantClass α α (· + ·) (· < ·)]
    [ContravariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊥) : a + b < a + c ↔ b < c
-- Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean
/-- If `I` is initial, then `X ⨯ I` is isomorphic to it. -/
@[simps! hom]
noncomputable def mulIsInitial (X : C) [HasBinaryProduct X I] (hI : IsInitial I) : X ⨯ I ≅ I
-- Mathlib/Analysis/Analytic/Polynomial.lean
theorem AnalyticOn.aeval_polynomial (hf : AnalyticOn 𝕜 f s) (p : A[X]) :
    AnalyticOn 𝕜 (fun x ↦ aeval (f x) p) s
-- Mathlib/Computability/TMToPartrec.lean
theorem head_supports {S k q} (H : (q : Λ').Supports S) : (head k q).Supports S
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean
/-- If the angle between two vectors is π, the inner product equals the negative product
of the norms. -/
theorem inner_eq_neg_mul_norm_of_angle_eq_pi {x y : V} (h : angle x y = π) :
    ⟪x, y⟫ = -(‖x‖ * ‖y‖)
-- Mathlib/CategoryTheory/Monad/Algebra.lean
@[simp]
theorem comp_f {A A' A'' : Coalgebra G} (f : A ⟶ A') (g : A' ⟶ A'') : (f ≫ g).f = f.f ≫ g.f
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- A subfamily of an orthonormal family (i.e., a composition with an injective map) is an
orthonormal family. -/
theorem Orthonormal.comp {ι' : Type*} {v : ι → E} (hv : Orthonormal 𝕜 v) (f : ι' → ι)
    (hf : Function.Injective f) : Orthonormal 𝕜 (v ∘ f)
-- Mathlib/CategoryTheory/MorphismProperty/Basic.lean
lemma MorphismProperty.le_def {P Q : MorphismProperty C} :
    P ≤ Q ↔ ∀ {X Y : C} (f : X ⟶ Y), P f → Q f
-- Mathlib/Order/Interval/Set/Basic.lean
lemma subsingleton_Icc_of_ge (hba : b ≤ a) : Set.Subsingleton (Icc a b)
-- Mathlib/Analysis/Normed/Group/Constructions.lean
@[simp] lemma nnnorm_ofAdd (x : E) : ‖ofAdd x‖₊ = ‖x‖₊
-- Mathlib/CategoryTheory/Triangulated/TStructure/Basic.lean
/-- Given a t-structure `t` on a pretriangulated category `C`, the property `t.IsLE X n`
holds if `X : C` is `≤ n` for the t-structure. -/
class IsLE (X : C) (n : ℤ) : Prop where
  le : t.LE n X
-- Mathlib/Algebra/AddConstMap/Basic.lean
/-- Change constants `a` and `b` in `(f : G →+c[a, b] H)` to improve definitional equalities. -/
@[simps (config := .asFn)]
def replaceConsts (f : G →+c[a, b] H) (a' b') (ha : a = a') (hb : b = b') :
    G →+c[a', b'] H
-- Mathlib/Topology/MetricSpace/IsometricSMul.lean
@[to_additive (attr := simp)]
theorem nndist_mul_right [PseudoMetricSpace M] [Mul M] [IsometricSMul Mᵐᵒᵖ M] (a b c : M) :
    nndist (a * c) (b * c) = nndist a b
-- Mathlib/Algebra/Quaternion.lean
@[simp, norm_cast]
theorem coe_imI : (x : ℍ[R,c₁,c₂]).imI = 0
-- Mathlib/Algebra/BigOperators/Fin.lean
@[to_additive]
theorem prod_univ_def [CommMonoid β] {n : ℕ} (f : Fin n → β) :
    ∏ i, f i = ((List.finRange n).map f).prod
-- Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean
@[simp]
theorem comp_val_c {X Y Z : LocallyRingedSpace.{u}} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f.1 ≫ g.1).c = g.val.c ≫ (Presheaf.pushforward _ g.val.base).map f.val.c
-- Mathlib/Analysis/Convex/Cone/Proper.lean
@[simp]
theorem mem_comap {f : E →L[ℝ] F} {S : ProperCone ℝ F} {x : E} : x ∈ S.comap f ↔ f x ∈ S
-- Mathlib/Analysis/NormedSpace/AddTorsor.lean
@[simp]
theorem dist_lineMap_left (p₁ p₂ : P) (c : 𝕜) : dist (lineMap p₁ p₂ c) p₁ = ‖c‖ * dist p₁ p₂
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem toReal_coe_eq_self_add_two_pi_iff {θ : ℝ} :
    (θ : Angle).toReal = θ + 2 * π ↔ θ ∈ Set.Ioc (-3 * π) (-π)
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem add_imJ : (a + b).imJ = a.imJ + b.imJ
-- Mathlib/Logic/Function/ULift.lean
@[simp] theorem PLift.down_inj {a b : PLift α} : a.down = b.down ↔ a = b
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem ball_subset_interior_closedBall : ball x ε ⊆ interior (closedBall x ε)
-- Mathlib/CategoryTheory/Sums/Associator.lean
@[simp]
theorem inverseAssociator_obj_inr_inr (X) : (inverseAssociator C D E).obj (inr (inr X)) = inr X
-- Mathlib/RingTheory/Polynomial/Pochhammer.lean
theorem ascPochhammer_eval_zero {n : ℕ} : (ascPochhammer S n).eval 0 = if n = 0 then 1 else 0
-- Mathlib/Data/Stream/Init.lean
@[simp]
theorem head_iterate (f : α → α) (a : α) : head (iterate f a) = a
-- Mathlib/Data/Set/Prod.lean
@[simp]
theorem pi_univ_ite (s : Set ι) [DecidablePred (· ∈ s)] (t : ∀ i, Set (α i)) :
    (pi univ fun i => if i ∈ s then t i else univ) = s.pi t
-- Mathlib/Data/Set/Function.lean
theorem MapsTo.union_union (h₁ : MapsTo f s₁ t₁) (h₂ : MapsTo f s₂ t₂) :
    MapsTo f (s₁ ∪ s₂) (t₁ ∪ t₂)
-- Mathlib/CategoryTheory/Elements.lean
@[simp]
theorem map_snd {F : C ⥤ Type w} {p q : F.Elements} (f : p ⟶ q) : (F.map f.val) p.2 = q.2
-- Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean
lemma rnDeriv_le_one_of_le (hμν : μ ≤ ν) [SigmaFinite ν] : μ.rnDeriv ν ≤ᵐ[ν] 1
-- Mathlib/LinearAlgebra/Dimension/Free.lean
@[simp]
theorem basisUnique_repr_eq_zero_iff {ι : Type*} [Unique ι]
    {h : finrank R M = 1} {v : M} {i : ι} :
    (basisUnique ι h).repr v i = 0 ↔ v = 0
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Dvd.lean
theorem emod_pos_of_not_dvd {a b : Nat} (h : ¬ a ∣ b) : 0 < b % a
-- Mathlib/Algebra/BigOperators/Group/Multiset.lean
@[to_additive]
theorem prod_hom [CommMonoid β] (s : Multiset α) {F : Type*} [FunLike F α β]
    [MonoidHomClass F α β] (f : F) :
    (s.map f).prod = f s.prod
-- Mathlib/RingTheory/PowerSeries/Basic.lean
@[simp, norm_cast]
theorem coe_inj : (φ : PowerSeries R) = ψ ↔ φ = ψ
-- Mathlib/GroupTheory/Perm/Basic.lean
theorem swap_mul_eq_mul_swap (f : Perm α) (x y : α) : swap x y * f = f * swap (f⁻¹ x) (f⁻¹ y)
-- Mathlib/Condensed/TopCatAdjunction.lean
lemma topCatAdjunctionCounit_bijective (X : TopCat.{u+1}) :
    Function.Bijective (topCatAdjunctionCounit X)
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean
@[simp]
theorem val_add : ∀ y1 y2 : HomogeneousLocalization 𝒜 x, (y1 + y2).val = y1.val + y2.val
-- Mathlib/Order/Monotone/Basic.lean
protected theorem Monotone.comp (hg : Monotone g) (hf : Monotone f) : Monotone (g ∘ f)
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem inv_le_of_inv_le (ha : 0 < a) (h : a⁻¹ ≤ b) : b⁻¹ ≤ a
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
/-- When `S.g = 0`, this is the canonical isomorphism `S.cycles ≅ S.X₂` induced by `S.iCycles`. -/
@[simps! hom]
noncomputable def cyclesIsoX₂ (hg : S.g = 0) : S.cycles ≅ S.X₂
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
/-- The identity function is locally Lipschitz. -/
protected lemma id : LocallyLipschitz (@id α)
-- Mathlib/Order/Interval/Set/Basic.lean
theorem not_mem_Ioi_self : a ∉ Ioi a
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem degree_map_eq_of_injective (hf : Injective f) (p : R[X]) : degree (p.map f) = degree p
-- Mathlib/Order/LiminfLimsup.lean
theorem IsBounded.isCobounded_le [Preorder α] [NeBot f] (h : f.IsBounded (· ≥ ·)) :
    f.IsCobounded (· ≤ ·)
-- Mathlib/AlgebraicGeometry/Limits.lean
theorem Scheme.eq_emptyTo {X : Scheme.{u}} (f : ∅ ⟶ X) : f = Scheme.emptyTo X
-- Mathlib/Algebra/Homology/Embedding/Basic.lean
lemma mem_next [e.IsTruncGE] {j : ι} {k' : ι'} (h : c'.Rel (e.f j) k') : ∃ k, e.f k = k'
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem lt_def {a b : Fin n} : a < b ↔ a.1 < b.1
-- Mathlib/GroupTheory/GroupAction/DomAct/Basic.lean
@[to_additive (attr := simp)]
lemma symm_mk_pow [Monoid M] (a : Mᵈᵐᵃ) (n : ℕ) : mk.symm (a ^ n) = mk.symm a ^ n
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
theorem LineDifferentiableWithinAt.mono_of_mem (h : LineDifferentiableWithinAt 𝕜 f s x v)
    (hst : s ∈ 𝓝[t] x) : LineDifferentiableWithinAt 𝕜 f t x v
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
@[simp]
lemma homologyMap'_id (h : S.HomologyData) :
    homologyMap' (𝟙 S) h h = 𝟙 _
-- Mathlib/Data/Finset/Pointwise.lean
theorem vsub_union : s -ᵥ (t₁ ∪ t₂) = s -ᵥ t₁ ∪ (s -ᵥ t₂)
-- Mathlib/CategoryTheory/Bicategory/Extension.lean
/-- Construct a morphism between whiskered extensions. -/
@[simps! right]
def whiskerHom (i : s ⟶ t) {x : B} (h : c ⟶ x) :
    s.whisker h ⟶ t.whisker h
-- Mathlib/LinearAlgebra/Prod.lean
@[simp]
theorem fst_prod (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) : (fst R M₂ M₃).comp (prod f g) = f
-- Mathlib/Data/Nat/Factorization/Basic.lean
/-- If `n` is a nonzero natural number and `p ≠ 1`, then there are natural numbers `e`
and `n'` such that `n'` is not divisible by `p` and `n = p^e * n'`. -/
theorem exists_eq_pow_mul_and_not_dvd {n : ℕ} (hn : n ≠ 0) (p : ℕ) (hp : p ≠ 1) :
    ∃ e n' : ℕ, ¬p ∣ n' ∧ n = p ^ e * n'
-- Mathlib/AlgebraicGeometry/Noetherian.lean
/-- Let `R` be a ring, and `f i` a finite collection of elements of `R` generating the unit ideal.
If the localization of `R` at each `f i` is noetherian, so is `R`.

We follow the proof given in [Har77], Proposition II.3.2 -/
theorem isNoetherianRing_of_away : IsNoetherianRing R
-- Mathlib/NumberTheory/LSeries/Convolution.lean
/-- The product of two arithmetic functions defines the same function as the Dirichlet convolution
of the functions defined by them. -/
lemma ArithmeticFunction.coe_mul {R : Type*} [Semiring R] (f g : ArithmeticFunction R) :
    f ⍟ g = ⇑(f * g)
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean
theorem mono {m'} (hf : AEStronglyMeasurable' m f μ) (hm : m ≤ m') :
    AEStronglyMeasurable' m' f μ
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem setLIntegral_le_lintegral (s : Set α) (f : α → ℝ≥0∞) :
    ∫⁻ x in s, f x ∂μ ≤ ∫⁻ x, f x ∂μ
-- Mathlib/Topology/Sets/Opens.lean
protected theorem nonempty_coe {U : Opens α} : (U : Set α).Nonempty ↔ ∃ x, x ∈ U
-- Mathlib/Topology/Compactness/Compact.lean
/-- Cantor's intersection theorem for `sInter`:
the intersection of a directed family of nonempty compact closed sets is nonempty. -/
theorem IsCompact.nonempty_sInter_of_directed_nonempty_isCompact_isClosed
    {S : Set (Set X)} [hS : Nonempty S] (hSd : DirectedOn (· ⊇ ·) S) (hSn : ∀ U ∈ S, U.Nonempty)
    (hSc : ∀ U ∈ S, IsCompact U) (hScl : ∀ U ∈ S, IsClosed U) : (⋂₀ S).Nonempty
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
theorem closure_singleton (x) : closure ({x} : Set (PrimeSpectrum R)) = zeroLocus x.asIdeal
-- Mathlib/Deprecated/Subgroup.lean
@[to_additive]
theorem normalizer_isSubgroup (s : Set G) : IsSubgroup (normalizer s)
-- Mathlib/Analysis/Convex/Side.lean
theorem sSameSide_lineMap_right {s : AffineSubspace R P} {x y : P} (hx : x ∈ s) (hy : y ∉ s) {t : R}
    (ht : 0 < t) : s.SSameSide y (lineMap x y t)
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
theorem IsVonNBounded.of_sub_right (hst : IsVonNBounded 𝕜 (s - t)) (hs : s.Nonempty) :
    IsVonNBounded 𝕜 t
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
theorem of_isBilimit {b : BinaryBicone X Y} (h : b.IsBilimit) :
    IsPullback b.fst b.snd (0 : X ⟶ 0) (0 : Y ⟶ 0)
-- Mathlib/Algebra/Group/Commute/Units.lean
@[to_additive]
theorem Commute.isUnit_mul_iff (h : Commute a b) : IsUnit (a * b) ↔ IsUnit a ∧ IsUnit b
-- Mathlib/Topology/Sheaves/Stalks.lean
theorem stalk_mono_of_mono {F G : Sheaf C X} (f : F ⟶ G) [Mono f] :
    ∀ x, Mono <| (stalkFunctor C x).map f.1
-- Mathlib/RingTheory/Noetherian.lean
/-- A module is Noetherian iff every nonempty set of submodules has a maximal submodule among them.
-/
theorem set_has_maximal_iff_noetherian :
    (∀ a : Set <| Submodule R M, a.Nonempty → ∃ M' ∈ a, ∀ I ∈ a, ¬M' < I) ↔ IsNoetherian R M
-- Mathlib/Analysis/Normed/Group/Constructions.lean
@[to_additive Prod.nnnorm_def']
lemma Prod.nnorm_def (x : E × F) : ‖x‖₊ = max ‖x.1‖₊ ‖x.2‖₊
-- Mathlib/NumberTheory/EllipticDivisibilitySequence.lean
@[simp]
lemma normEDS_neg (n : ℤ) : normEDS b c d (-n) = -normEDS b c d n
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
/-- Corollary of the Chinese remainder theorem: given elements `x i : R / P i ^ e i`,
we can choose a representative `y : R` such that `y ≡ x i (mod P i ^ e i)`. -/
theorem IsDedekindDomain.exists_representative_mod_finset {ι : Type*} {s : Finset ι}
    (P : ι → Ideal R) (e : ι → ℕ) (prime : ∀ i ∈ s, Prime (P i))
    (coprime : ∀ᵉ (i ∈ s) (j ∈ s), i ≠ j → P i ≠ P j) (x : ∀ i : s, R ⧸ P i ^ e i) :
    ∃ y, ∀ (i) (hi : i ∈ s), Ideal.Quotient.mk (P i ^ e i) y = x ⟨i, hi⟩
-- Mathlib/Data/Real/EReal.lean
@[simp] theorem abs_bot : (⊥ : EReal).abs = ⊤
-- Mathlib/LinearAlgebra/Dual.lean
theorem dualAnnihilator_dualAnnihilator_eq_map (W : Subspace K V) [FiniteDimensional K W] :
    W.dualAnnihilator.dualAnnihilator = W.map (Dual.eval K V)
-- Mathlib/CategoryTheory/FintypeCat.lean
@[ext]
lemma hom_ext {X Y : FintypeCat} (f g : X ⟶ Y) (h : ∀ x, f x = g x) : f = g
-- Mathlib/Geometry/Manifold/Algebra/Monoid.lean
@[to_additive]
theorem contMDiffAt_finprod
    (lf : LocallyFinite fun i ↦ mulSupport <| f i) (h : ∀ i, ContMDiffAt I' I n (f i) x₀) :
    ContMDiffAt I' I n (fun x ↦ ∏ᶠ i, f i x) x₀
-- Mathlib/LinearAlgebra/AffineSpace/ContinuousAffineEquiv.lean
lemma constVAdd_coe [ContinuousConstVAdd V₁ P₁] (v : V₁) :
    (constVAdd k P₁ v).toAffineEquiv = .constVAdd k P₁ v
-- Mathlib/Order/SuccPred/Basic.lean
@[simp]
theorem Ioo_succ_right (a b : α) : Ioo a (succ b) = Ioc a b
-- Mathlib/Analysis/NormedSpace/Real.lean
theorem norm_smul_of_nonneg {t : ℝ} (ht : 0 ≤ t) (x : E) : ‖t • x‖ = t * ‖x‖
-- Mathlib/LinearAlgebra/LinearIndependent.lean
/-- An alternative characterization of a maximal linearly independent family,
quantifying over types (in the same universe as `M`) into which the indexing family injects.
-/
theorem LinearIndependent.maximal_iff {ι : Type w} {R : Type u} [Ring R] [Nontrivial R] {M : Type v}
    [AddCommGroup M] [Module R M] {v : ι → M} (i : LinearIndependent R v) :
    i.Maximal ↔
      ∀ (κ : Type v) (w : κ → M) (_i' : LinearIndependent R w) (j : ι → κ) (_h : w ∘ j = v),
        Surjective j
-- Mathlib/Order/BooleanAlgebra.lean
@[simp] lemma compl_lt_compl_iff_lt : yᶜ < xᶜ ↔ x < y
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive]
theorem nnnorm_div_le (a b : E) : ‖a / b‖₊ ≤ ‖a‖₊ + ‖b‖₊
-- Mathlib/FieldTheory/Separable.lean
theorem Algebra.isSeparable_tower_bot_of_isSeparable [h : Algebra.IsSeparable F E] :
    Algebra.IsSeparable F K
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem top_apply (a : α) : (⊤ : sInfHom α β) a = ⊤
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem mul_le_mul_of_nonneg_left {a b c : Int}
    (h₁ : a ≤ b) (h₂ : 0 ≤ c) : c * a ≤ c * b
-- Mathlib/FieldTheory/Separable.lean
theorem separable_prod_X_sub_C_iff {ι : Sort _} [Fintype ι] {f : ι → F} :
    (∏ i, (X - C (f i))).Separable ↔ Function.Injective f
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
theorem adj_of_length_eq_one {u v : V} : ∀ {p : G.Walk u v}, p.length = 1 → G.Adj u v
-- Mathlib/Topology/Inseparable.lean
theorem ker_nhds_eq_specializes : (𝓝 x).ker = {y | y ⤳ x}
-- Mathlib/CategoryTheory/Opposites.lean
@[simp]
theorem Quiver.Hom.unop_op' {X Y : Cᵒᵖ} {x} :
    @Quiver.Hom.unop C _ X Y no_index (Opposite.op (unop := x)) = x
-- Mathlib/Data/Real/Hyperreal.lean
theorem infinitePos_mul_of_infiniteNeg_not_infinitesimal_neg {x y : ℝ*} :
    InfiniteNeg x → ¬Infinitesimal y → y < 0 → InfinitePos (x * y)
-- Mathlib/MeasureTheory/Constructions/Prod/Integral.lean
/-- Double integrals commute with subtraction. -/
theorem integral_integral_sub ⦃f g : α × β → E⦄ (hf : Integrable f (μ.prod ν))
    (hg : Integrable g (μ.prod ν)) :
    (∫ x, ∫ y, f (x, y) - g (x, y) ∂ν ∂μ) = (∫ x, ∫ y, f (x, y) ∂ν ∂μ) - ∫ x, ∫ y, g (x, y) ∂ν ∂μ
-- Mathlib/Order/UpperLower/Basic.lean
@[simp, norm_cast]
theorem coe_prod : ((s ×ˢ t : LowerSet (α × β)) : Set (α × β)) = (s : Set α) ×ˢ t
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem LinearIndependent.total_comp_repr :
    (Finsupp.total ι M R v).comp hv.repr = Submodule.subtype _
-- .lake/packages/batteries/Batteries/Data/List/Basic.lean
@[csimp] theorem modifyNth_eq_modifyNthTR : @modifyNth = @modifyNthTR
-- Mathlib/RingTheory/DedekindDomain/FiniteAdeleRing.lean
/-- The inclusion of `R_hat` in `K_hat` as a homomorphism of additive monoids. -/
@[simps]
def Coe.addMonoidHom : AddMonoidHom (R_hat R K) (K_hat R K)
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem not_cons (x : BitVec w) (b : Bool) : ~~~(cons b x) = cons (!b) (~~~x)
-- Mathlib/RingTheory/Polynomial/Basic.lean
theorem mem_leadingCoeffNth_zero (x) : x ∈ I.leadingCoeffNth 0 ↔ C x ∈ I
-- Mathlib/CategoryTheory/Idempotents/Karoubi.lean
@[reassoc (attr := simp)]
theorem comp_p {P Q : Karoubi C} (f : Hom P Q) : f.f ≫ Q.p = f.f
-- Mathlib/Algebra/Order/GroupWithZero/Canonical.lean
@[simp, norm_cast] lemma one_le_coe [One α] : 1 ≤ (a : WithZero α) ↔ 1 ≤ a
-- Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean
protected lemma IsBigO.sqrt (hfg : f =O[l] g) (hg : 0 ≤ᶠ[l] g) :
    (Real.sqrt <| f ·) =O[l] (Real.sqrt <| g ·)
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem Bool.and_false (b : Bool) : (b && false) = false
-- Mathlib/Algebra/Lie/Weights/Chain.lean
lemma exists₂_weightSpace_smul_add_eq_bot :
    ∃ᵉ (p < (0 : ℤ)) (q > (0 : ℤ)),
      weightSpace M (p • χ₁ + χ₂) = ⊥ ∧
      weightSpace M (q • χ₁ + χ₂) = ⊥
-- Mathlib/Data/Set/Finite.lean
@[simp]
theorem card_insert {a : α} (s : Set α) [Fintype s] (h : a ∉ s)
    {d : Fintype.{u} (insert a s : Set α)} : @Fintype.card _ d = Fintype.card s + 1
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
@[simp]
theorem mk'_apply {f : M → M₂} (lin : IsLinearMap R f) (x : M) : mk' f lin x = f x
-- Mathlib/Order/LiminfLimsup.lean
@[simp]
theorem bliminf_sup_le_and_aux_left : bliminf u f p ≤ bliminf u f fun x => p x ∧ q x
-- Mathlib/Topology/Homotopy/Product.lean
theorem pi_lift (γ : ∀ i, Path (as i) (bs i)) :
    (Path.Homotopic.pi fun i => ⟦γ i⟧) = ⟦Path.pi γ⟧
-- Mathlib/Data/Set/Card.lean
@[simp] theorem encard_empty : (∅ : Set α).encard = 0
-- Mathlib/Data/Set/Lattice.lean
theorem seq_subset {s : Set (α → β)} {t : Set α} {u : Set β} :
    seq s t ⊆ u ↔ ∀ f ∈ s, ∀ a ∈ t, (f : α → β) a ∈ u
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem _root_.ContinuousOn.angle_sign_comp {α : Type*} [TopologicalSpace α] {f : α → Angle}
    {s : Set α} (hf : ContinuousOn f s) (hs : ∀ z ∈ s, f z ≠ 0 ∧ f z ≠ π) :
    ContinuousOn (sign ∘ f) s
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
theorem Trivialization.smoothOn_iff {f : M → TotalSpace F E} {s : Set M}
    (he : MapsTo f s e.source) :
    SmoothOn IM (IB.prod 𝓘(𝕜, F)) f s ↔
      SmoothOn IM IB (fun x => (f x).proj) s ∧ SmoothOn IM 𝓘(𝕜, F) (fun x ↦ (e (f x)).2) s
-- Mathlib/Topology/Algebra/Module/Basic.lean
protected theorem surjective (e : M₁ ≃SL[σ₁₂] M₂) : Function.Surjective e
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem coeff_sum {X : Type*} (s : Finset X) (f : X → MvPolynomial σ R) (m : σ →₀ ℕ) :
    coeff m (∑ x ∈ s, f x) = ∑ x ∈ s, coeff m (f x)
-- Mathlib/LinearAlgebra/Determinant.lean
@[simp]
theorem det_symm (f : M ≃ₗ[R] M) : LinearEquiv.det f.symm = LinearEquiv.det f⁻¹
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
theorem withDensity_ae_eq {β : Type} {f g : α → β} {d : α → ℝ≥0∞}
    (hd : AEMeasurable d μ) (h_ae_nonneg : ∀ᵐ x ∂μ, d x ≠ 0) :
    f =ᵐ[μ.withDensity d] g ↔ f =ᵐ[μ] g
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
@[simp]
theorem zmodEquivZPowers_symm_apply_pow (i : ℕ) :
    h.zmodEquivZPowers.symm (Additive.ofMul (⟨ζ ^ i, i, rfl⟩ : Subgroup.zpowers ζ)) = i
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The `vectorSpan` is the span of the pairwise subtractions with a given point on the right,
excluding the subtraction of that point from itself. -/
theorem vectorSpan_eq_span_vsub_finset_right_ne [DecidableEq P] [DecidableEq V] {s : Finset P}
    {p : P} (hp : p ∈ s) :
    vectorSpan k (s : Set P) = Submodule.span k ((s.erase p).image (· -ᵥ p))
-- Mathlib/Algebra/GeomSum.lean
theorem geom_sum_alternating_of_le_neg_one [StrictOrderedRing α] (hx : x + 1 ≤ 0) (n : ℕ) :
    if Even n then (∑ i ∈ range n, x ^ i) ≤ 0 else 1 ≤ ∑ i ∈ range n, x ^ i
-- Mathlib/Algebra/MonoidAlgebra/Grading.lean
theorem mem_grade_iff (m : M) (a : R[M]) : a ∈ grade R m ↔ a.support ⊆ {m}
-- Mathlib/Algebra/DirectSum/Decomposition.lean
@[simp]
theorem decompose_symm_sub (x y : ⨁ i, ℳ i) :
    (decompose ℳ).symm (x - y) = (decompose ℳ).symm x - (decompose ℳ).symm y
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma isUnit_dblZ_of_Y_ne {P Q : Fin 3 → F} (hP : W.Equation P) (hQ : W.Equation Q) (hPz : P z ≠ 0)
    (hx : P x * Q z ^ 2 = Q x * P z ^ 2) (hy : P y * Q z ^ 3 ≠ Q y * P z ^ 3) : IsUnit (W.dblZ P)
-- Mathlib/Data/Rat/Floor.lean
protected theorem floor_def' (a : ℚ) : a.floor = a.num / a.den
-- Mathlib/Algebra/DirectSum/Decomposition.lean
@[simp] theorem decomposeLinearEquiv_symm_apply (m : ⨁ i, ℳ i) :
    (decomposeLinearEquiv ℳ).symm m = (decompose ℳ).symm m
-- Mathlib/RingTheory/Flat/CategoryTheory.lean
lemma iff_rTensor_preserves_shortComplex_exact :
    Flat R M ↔
    ∀ (C : ShortComplex $ ModuleCat R) (_ : C.Exact), (C.map (tensorRight M) |>.Exact)
-- Mathlib/Topology/MetricSpace/Basic.lean
@[simp] theorem dist_toMul (a b : Additive X) : dist (toMul a) (toMul b) = dist a b
-- Mathlib/AlgebraicTopology/DoldKan/Normalized.lean
@[reassoc (attr := simp)]
theorem PInftyToNormalizedMooreComplex_naturality {X Y : SimplicialObject A} (f : X ⟶ Y) :
    AlternatingFaceMapComplex.map f ≫ PInftyToNormalizedMooreComplex Y =
      PInftyToNormalizedMooreComplex X ≫ NormalizedMooreComplex.map f
-- Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean
theorem restrict_iInf {ι} [Nonempty ι] (s : Set α) (m : ι → OuterMeasure α) :
    restrict s (⨅ i, m i) = ⨅ i, restrict s (m i)
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem ofFin_lt (x : Fin (2^n)) (y : BitVec n) :
  BitVec.ofFin x < y ↔ x < y.toFin
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
@[simp]
theorem pow_toGerm (f : α →ₘ[μ] γ) (n : ℕ) : (f ^ n).toGerm = f.toGerm ^ n