ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Category/ModuleCat/Free.lean
/-- Given an exact sequence `X₁ ⟶ X₂ ⟶ X₃ ⟶ 0` of `R`-modules and spanning
    families `v : ι → X₁` and `w : ι' → X₃`, we get a spanning family `ι ⊕ ι' → X₂` -/
theorem span_rightExact {w : ι' → S.X₃} (hv : ⊤ ≤ span R (range v))
    (hw : ⊤ ≤ span R (range w)) (hE : Epi S.g) :
    ⊤ ≤ span R (range (Sum.elim (S.f ∘ v) (S.g.toFun.invFun ∘ w)))
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
/-- The distance is symmetric.

This holds independent of `p` and does not require `[Fact (1 ≤ p)]`. We keep it separate
from `WithLp.instProdPseudoEMetricSpace` so it can be used also for `p < 1`. -/
theorem prod_edist_comm (f g : WithLp p (α × β)) : edist f g = edist g f
-- Mathlib/Algebra/Tropical/Basic.lean
theorem rightInverse_trop : Function.RightInverse (trop : R → Tropical R) untrop
-- Mathlib/CategoryTheory/Sites/Coverage.lean
@[simp]
lemma sup_covering (x y : Coverage C) (B : C) :
    (x ⊔ y).covering B = x.covering B ∪ y.covering B
-- Mathlib/Data/Multiset/Sum.lean
theorem mem_disjSum : x ∈ s.disjSum t ↔ (∃ a, a ∈ s ∧ inl a = x) ∨ ∃ b, b ∈ t ∧ inr b = x
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive (attr := ext)]
theorem ext' {f g : GroupTopology α} (h : f.IsOpen = g.IsOpen) : f = g
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem subtype_Ici_eq : Ici a = (Ici (a : α)).subtype p
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
theorem mem_support_iff_exists_append {V : Type u} {G : SimpleGraph V} {u v w : V}
    {p : G.Walk u v} : w ∈ p.support ↔ ∃ (q : G.Walk u w) (r : G.Walk w v), p = q.append r
-- Mathlib/Order/Category/Preord.lean
/-- The equivalence between `Preord` and itself induced by `OrderDual` both ways. -/
@[simps functor inverse]
def dualEquiv : Preord ≌ Preord
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem addCases_left {m n : Nat} {motive : Fin (m + n) → Sort _} {left right} (i : Fin m) :
    addCases (motive := motive) left right (Fin.castAdd n i) = left i
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem type_ne_zero_iff_nonempty [IsWellOrder α r] : type r ≠ 0 ↔ Nonempty α
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem reverse_nil : reverse ([] : List α) = []
-- Mathlib/Algebra/Module/Submodule/Basic.lean
theorem smul_mem_iff (s0 : s ≠ 0) : s • x ∈ p ↔ x ∈ p
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem mul_mem_sup {S T : Subgroup G} {x y : G} (hx : x ∈ S) (hy : y ∈ T) : x * y ∈ S ⊔ T
-- Mathlib/CategoryTheory/Galois/Basic.lean
/-- An object that is neither initial or connected has a non-trivial subobject. -/
lemma has_non_trivial_subobject_of_not_isConnected_of_not_initial (X : C) (hc : ¬ IsConnected X)
    (hi : IsInitial X → False) :
    ∃ (Y : C) (v : Y ⟶ X), (IsInitial Y → False) ∧ Mono v ∧ (¬ IsIso v)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem ofReal_normSq_eq_inner_self (x : F) : (normSqF x : 𝕜) = ⟪x, x⟫
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
theorem arg_eq_nhds_of_re_pos (hx : 0 < x.re) : arg =ᶠ[𝓝 x] fun x => Real.arcsin (x.im / abs x)
-- Mathlib/Dynamics/FixedPoints/Basic.lean
protected theorem perm_inv (h : IsFixedPt e x) : IsFixedPt (⇑e⁻¹) x
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem sum_rpow_le_norm_rpow (hp : 0 < p.toReal) (f : lp E p) (s : Finset α) :
    ∑ i ∈ s, ‖f i‖ ^ p.toReal ≤ ‖f‖ ^ p.toReal
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isLittleO_const_id_atTop (c : E'') : (fun _x : ℝ => c) =o[atTop] id
-- Mathlib/Topology/Algebra/UniformGroup.lean
@[to_additive]
theorem uniformEmbedding_translate_mul (a : α) : UniformEmbedding fun x : α => x * a
-- Mathlib/Data/Nat/Bitwise.lean
@[simp]
theorem land_bit : ∀ a m b n, bit a m &&& bit b n = bit (a && b) (m &&& n)
-- Mathlib/Algebra/Module/ULift.lean
/-- The `R`-linear equivalence between `ULift M` and `M`.

This is a linear version of `AddEquiv.ulift`. -/
@[simps apply symm_apply]
def moduleEquiv [Semiring R] [AddCommMonoid M] [Module R M] : ULift.{w} M ≃ₗ[R] M
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem div_eq_zero_of_lt {a b : Ordinal} (h : a < b) : a / b = 0
-- Mathlib/Analysis/Calculus/UniformLimitsDeriv.lean
/-- `(d/dx) lim_{n → ∞} f n x = lim_{n → ∞} f' n x` when the `f' n` converge
_uniformly_ to their limit. -/
theorem hasFDerivAt_of_tendstoUniformly [NeBot l] (hf' : TendstoUniformly f' g' l)
    (hf : ∀ n : ι, ∀ x : E, HasFDerivAt (f n) (f' n x) x)
    (hfg : ∀ x : E, Tendsto (fun n => f n x) l (𝓝 (g x))) : ∀ x : E, HasFDerivAt g (g' x) x
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem lift_lt_univ (c : Cardinal) : lift.{u + 1, u} c < univ.{u, u + 1}
-- Mathlib/Probability/Distributions/Uniform.lean
theorem hasPDF {X : Ω → E} {s : Set E} (hns : μ s ≠ 0) (hnt : μ s ≠ ∞)
    (hu : IsUniform X s ℙ μ) : HasPDF X ℙ μ
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem exists_eq_add_one_of_ne_zero : ∀ {n}, n ≠ 0 → Exists fun k => n = k + 1
-- Mathlib/RingTheory/PowerSeries/Inverse.lean
theorem eq_mul_inv_iff_mul_eq {φ₁ φ₂ φ₃ : k⟦X⟧} (h : constantCoeff k φ₃ ≠ 0) :
    φ₁ = φ₂ * φ₃⁻¹ ↔ φ₁ * φ₃ = φ₂
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
theorem comap_inf (s t : NonUnitalSubsemiring S) (f : F) :
    (comap f (s ⊓ t) : NonUnitalSubsemiring R) = comap f s ⊓ comap f t
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[deprecated getElem_map (since := "2024-06-12")]
theorem get_map (f : α → β) {l n} :
    get (map f l) n = f (get l ⟨n, length_map l f ▸ n.2⟩)
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
@[simp] theorem prev_zero (s : String) : prev s 0 = 0
-- Mathlib/Order/Synonym.lean
@[simp] lemma Lex.exists {p : Lex α → Prop} : (∃ a, p a) ↔ ∃ a, p (toLex a)
-- Mathlib/ModelTheory/Definability.lean
theorem definable_finset_inf {ι : Type*} {f : ι → Set (α → M)} (hf : ∀ i, A.Definable L (f i))
    (s : Finset ι) : A.Definable L (s.inf f)
-- Mathlib/Analysis/Convex/Gauge.lean
theorem gauge_def : gauge s x = sInf ({ r ∈ Set.Ioi (0 : ℝ) | x ∈ r • s })
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
@[simp]
theorem sphere_union_ball : sphere x ε ∪ ball x ε = closedBall x ε
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma isZero₂_iff_isIso₃ : IsZero T.obj₂ ↔ IsIso T.mor₃
-- Mathlib/Order/Interval/Multiset.lean
theorem nodup_Ioc : (Ioc a b).Nodup
-- Mathlib/Topology/Maps/Proper/Basic.lean
/-- A closed embedding is proper. -/
lemma isProperMap_of_closedEmbedding (hf : ClosedEmbedding f) : IsProperMap f
-- Mathlib/Algebra/Order/Interval/Set/Group.lean
theorem pairwise_disjoint_Ioc_intCast : Pairwise (Disjoint on fun n : ℤ => Ioc (n : α) (n + 1))
-- Mathlib/Algebra/Homology/ShortComplex/Abelian.lean
/-- The canonical `LeftHomologyData` of a short complex `S` in an abelian category, for
which the `H` field is `Abelian.coimage (kernel.ι S.g ≫ cokernel.π S.f)`. -/
@[simps]
noncomputable def ofAbelian : S.LeftHomologyData
-- Mathlib/Analysis/Complex/Isometry.lean
@[simp]
theorem rotationOf_rotation (a : circle) : rotationOf (rotation a) = a
-- Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean
theorem NonUnitalSubring.toSubring_toNonUnitalSubring (S : NonUnitalSubring R) (h1 : (1 : R) ∈ S) :
    (NonUnitalSubring.toSubring S h1).toNonUnitalSubring = S
-- Mathlib/Analysis/Convex/Extreme.lean
theorem IsExtreme.extremePoints_subset_extremePoints (hAB : IsExtreme 𝕜 A B) :
    B.extremePoints 𝕜 ⊆ A.extremePoints 𝕜
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem map_bot (f : A →ₐ[R] B) : (⊥ : Subalgebra R A).map f = ⊥
-- Mathlib/AlgebraicGeometry/Scheme.lean
lemma preimage_iSup {ι} (U : ι → Opens Y) : f ⁻¹ᵁ iSup U = ⨆ i, f ⁻¹ᵁ U i
-- Mathlib/Data/Set/Countable.lean
theorem Countable.sUnion_iff {s : Set (Set α)} (hs : s.Countable) :
    (⋃₀ s).Countable ↔ ∀ a ∈ s, a.Countable
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
@[simp]
theorem coe_toAddSubgroup (s : NonUnitalSubring R) : (s.toAddSubgroup : Set R) = s
-- Mathlib/Data/Matroid/Constructions.lean
@[simp] theorem restrict_empty (M : Matroid α) : M ↾ (∅ : Set α) = emptyOn α
-- Mathlib/Data/Finset/Basic.lean
theorem inter_inter_distrib_left (s t u : Finset α) : s ∩ (t ∩ u) = s ∩ t ∩ (s ∩ u)
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[to_additive Iio_add_Iic_subset]
theorem Iio_mul_Iic_subset' (a b : α) : Iio a * Iic b ⊆ Iio (a * b)
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Bilinear.lean
@[simp]
theorem bilinearComp_apply (f : E →SL[σ₁₃] F →SL[σ₂₃] G) (gE : E' →SL[σ₁'] E) (gF : F' →SL[σ₂'] F)
    (x : E') (y : F') : f.bilinearComp gE gF x y = f (gE x) (gF y)
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
@[simp]
theorem orderTop_one [MulZeroOneClass R] [Nontrivial R] : orderTop (1 : HahnSeries Γ R) = 0
-- Mathlib/Algebra/Group/Center.lean
@[to_additive subset_addCentralizer_addCentralizer]
lemma subset_centralizer_centralizer : S ⊆ S.centralizer.centralizer
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)]
theorem prod_mk_fst_snd (x : M ∗ N) : (fst x, snd x) = toProd x
-- Mathlib/Analysis/NormedSpace/AddTorsor.lean
theorem lipschitzWith_lineMap (p₁ p₂ : P) : LipschitzWith (nndist p₁ p₂) (lineMap p₁ p₂ : 𝕜 → P)
-- Mathlib/Analysis/Calculus/Deriv/Slope.lean
theorem hasDerivWithinAt_iff_tendsto_slope :
    HasDerivWithinAt f f' s x ↔ Tendsto (slope f x) (𝓝[s \ {x}] x) (𝓝 f')
-- Mathlib/Geometry/Manifold/Algebra/Monoid.lean
@[to_additive]
nonrec theorem Smooth.mul (hf : Smooth I' I f) (hg : Smooth I' I g) : Smooth I' I (f * g)
-- Mathlib/CategoryTheory/EpiMono.lean
/-- A split mono category is a category in which every monomorphism is split. -/
class SplitMonoCategory : Prop where
  /-- All monos are split -/
  isSplitMono_of_mono : ∀ {X Y : C} (f : X ⟶ Y) [Mono f], IsSplitMono f
-- Mathlib/Algebra/Associated/Basic.lean
theorem DvdNotUnit.not_associated [CancelCommMonoidWithZero α] {p q : α} (h : DvdNotUnit p q) :
    ¬Associated p q
-- Mathlib/Data/Set/Subsingleton.lean
@[simp]
theorem not_nontrivial_singleton {x} : ¬({x} : Set α).Nontrivial
-- Mathlib/Order/UpperLower/Basic.lean
theorem subset_upperClosure : s ⊆ upperClosure s
-- Mathlib/Init/Data/List/Basic.lean
@[simp] theorem headI_cons [Inhabited α] {h : α} {t : List α} : (h :: t).headI = h
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_mul_const' (r : ℝ≥0∞) (f : α → ℝ≥0∞) (hr : r ≠ ∞) :
    ∫⁻ a, f a * r ∂μ = (∫⁻ a, f a ∂μ) * r
-- Mathlib/RingTheory/PrincipalIdealDomain.lean
theorem gcd_eq_sum : ∃ a b : R, a * x + b * y = gcd x y
-- Mathlib/Data/Seq/WSeq.lean
theorem LiftRel.symm (R : α → α → Prop) (H : Symmetric R) : Symmetric (LiftRel R)
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
lemma ciInf_le_of_le' (c : ι) : f c ≤ a → iInf f ≤ a
-- Mathlib/Algebra/MonoidAlgebra/Degree.lean
theorem sup_support_add_le : (f + g).support.sup degb ≤ f.support.sup degb ⊔ g.support.sup degb
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem typein_surj (r : α → α → Prop) [IsWellOrder α r] {o} (h : o < type r) :
    ∃ a, typein r a = o
-- Mathlib/Combinatorics/SimpleGraph/Density.lean
theorem card_interedges_add_card_interedges_compl (h : Disjoint s t) :
    (G.interedges s t).card + (Gᶜ.interedges s t).card = s.card * t.card
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem prodComm_symm (α β) : (prodComm α β).symm = prodComm β α
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem toDual_compl (a : α) : toDual aᶜ = ￢toDual a
-- .lake/packages/batteries/Batteries/Data/List/Pairwise.lean
theorem pairwise_iff_getElem : Pairwise R l ↔
    ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length) (_hij : i < j), R l[i] l[j]
-- Mathlib/Order/Interval/Set/Image.lean
@[simp] lemma preimage_subtype_val_Iic (a : {x // p x}) : (↑) ⁻¹' (Iic a.1) = Iic a
-- Mathlib/Topology/Category/UniformSpace.lean
@[simp]
theorem coe_id (X : UniformSpaceCat) : (𝟙 X : X → X) = id
-- Mathlib/Order/Interval/Finset/Defs.lean
@[simp, norm_cast]
theorem coe_Ici (a : α) : (Ici a : Set α) = Set.Ici a
-- Mathlib/Data/Part.lean
@[to_additive (attr := simp)]
theorem div_get_eq [Div α] (a b : Part α) (hab : Dom (a / b)) :
    (a / b).get hab = a.get (left_dom_of_div_dom hab) / b.get (right_dom_of_div_dom hab)
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
theorem independent_genEigenspace [NoZeroSMulDivisors R M] (f : End R M) :
    CompleteLattice.Independent (fun μ ↦ ⨆ k, f.genEigenspace μ k)
-- Mathlib/Order/SupClosed.lean
lemma InfClosed.preimage [FunLike F β α] [InfHomClass F β α] (hs : InfClosed s) (f : F) :
    InfClosed (f ⁻¹' s)
-- Mathlib/Algebra/Order/Field/Basic.lean
@[gcongr]
lemma div_le_div_of_nonneg_left (ha : 0 ≤ a) (hc : 0 < c) (h : c ≤ b) : a / b ≤ a / c
-- Mathlib/Data/Finset/Lattice.lean
@[simp]
protected theorem compl_sup (s : Finset ι) (f : ι → α) : (s.sup f)ᶜ = s.inf fun i => (f i)ᶜ
-- Mathlib/CategoryTheory/Triangulated/Opposite.lean
lemma mem_distinguishedTriangles_iff' (T : Triangle Cᵒᵖ) :
    T ∈ distinguishedTriangles C ↔
      ∃ (T' : Triangle C) (_ : T' ∈ distTriang C),
        Nonempty (T ≅ (triangleOpEquivalence C).functor.obj (Opposite.op T'))
-- Mathlib/Probability/Kernel/Composition.lean
theorem prodMkLeft_apply' (κ : Kernel α β) (ca : γ × α) (s : Set β) :
    prodMkLeft γ κ ca s = κ ca.snd s
-- Mathlib/Algebra/Category/Grp/Basic.lean
@[to_additive (attr := simp)] theorem MonoidHom.comp_id_grp
    {G : Grp.{u}} {H : Type u} [Group H] (f : G →* H) : f.comp (𝟙 G) = f
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
/-- Variant of `AlgebraicGeometry.localRingHom_comp_stalkIso` for `Spec.map`. -/
@[elementwise]
lemma Scheme.localRingHom_comp_stalkIso {R S : CommRingCat.{u}} (f : R ⟶ S) (p : PrimeSpectrum S) :
    (StructureSheaf.stalkIso R (PrimeSpectrum.comap f p)).hom ≫
      (CommRingCat.ofHom <| Localization.localRingHom
        (PrimeSpectrum.comap f p).asIdeal p.asIdeal f rfl) ≫
      (StructureSheaf.stalkIso S p).inv = (Spec.map f).stalkMap p
-- Mathlib/Topology/Sequences.lean
/-- If a set is equal to its sequential closure, then it is sequentially closed. -/
theorem isSeqClosed_of_seqClosure_eq {s : Set X} (hs : seqClosure s = s) : IsSeqClosed s
-- Mathlib/Analysis/Normed/Order/Lattice.lean
theorem norm_inf_le_add (x y : α) : ‖x ⊓ y‖ ≤ ‖x‖ + ‖y‖
-- Mathlib/Algebra/Group/Units.lean
@[to_additive (attr := simp)]
theorem unit_spec (h : IsUnit a) : ↑h.unit = a
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
lemma inf_mul_right [SemilatticeInf β] [OrderTop β] (s t : Finset α) (f : α → β) :
    inf (s * t) f = inf t fun y ↦ inf s (f <| · * y)
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem rTensor_comp_lTensor (f : M →ₗ[R] P) (g : N →ₗ[R] Q) :
    (f.rTensor Q).comp (g.lTensor M) = map f g
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem get?_size {a : Array α} : a[a.size]? = none
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem subsemiringClosure_toAddSubmonoid :
    M.subsemiringClosure.toAddSubmonoid = AddSubmonoid.closure (M : Set R)
-- Mathlib/Condensed/TopComparison.lean
/--
`TopCat.toCondensedSet` yields a functor from `TopCat.{u+1}` to `CondensedSet.{u}`.
-/
@[simps]
noncomputable def topCatToCondensedSet : TopCat.{u+1} ⥤ CondensedSet.{u}
-- Mathlib/Algebra/Polynomial/Roots.lean
@[simp]
theorem nthRoots_two_eq_zero_iff {r : R} : nthRoots 2 r = 0 ↔ ¬IsSquare r
-- Mathlib/Algebra/Order/ToIntervalMod.lean
private theorem toIxxMod_trans {x₁ x₂ x₃ x₄ : α}
    (h₁₂₃ : toIcoMod hp x₁ x₂ ≤ toIocMod hp x₁ x₃ ∧ ¬toIcoMod hp x₃ x₂ ≤ toIocMod hp x₃ x₁)
    (h₂₃₄ : toIcoMod hp x₂ x₄ ≤ toIocMod hp x₂ x₃ ∧ ¬toIcoMod hp x₃ x₄ ≤ toIocMod hp x₃ x₂) :
    toIcoMod hp x₁ x₄ ≤ toIocMod hp x₁ x₃ ∧ ¬toIcoMod hp x₃ x₄ ≤ toIocMod hp x₃ x₁
-- Mathlib/Topology/Instances/ENNReal.lean
theorem biSup_add' {ι : Sort*} {p : ι → Prop} (h : ∃ i, p i) {f : ι → ℝ≥0∞} :
    (⨆ (i) (_ : p i), f i) + a = ⨆ (i) (_ : p i), f i + a
-- Mathlib/Tactic/ComputeDegree.lean
theorem natDegree_intCast_le (n : ℤ) : natDegree (n : R[X]) ≤ 0
-- Mathlib/RingTheory/WittVector/Basic.lean
@[simp]
theorem ghostMap_apply (x : 𝕎 R) (n : ℕ) : ghostMap x n = ghostComponent n x
-- Mathlib/RingTheory/Localization/Away/Basic.lean
theorem selfZPow_neg_mul (d : ℤ) : selfZPow x B (-d) * selfZPow x B d = 1
-- Mathlib/CategoryTheory/Functor/FullyFaithful.lean
@[simp]
theorem preimage_id : F.preimage (𝟙 (F.obj X)) = 𝟙 X
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
protected theorem IntegrableAtFilter.norm (hf : IntegrableAtFilter f l μ) :
    IntegrableAtFilter (fun x => ‖f x‖) l μ
-- Mathlib/Analysis/Calculus/TangentCone.lean
theorem uniqueDiffWithinAt_congr (st : 𝓝[s] x = 𝓝[t] x) :
    UniqueDiffWithinAt 𝕜 s x ↔ UniqueDiffWithinAt 𝕜 t x
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem mk_rightMovesEquiv {x y L R hL hR} : (@Relabelling.mk x y L R hL hR).rightMovesEquiv = R
-- Mathlib/Topology/Basic.lean
theorem Filter.HasBasis.clusterPt_iff {ιX ιF} {pX : ιX → Prop} {sX : ιX → Set X} {pF : ιF → Prop}
    {sF : ιF → Set X} {F : Filter X} (hX : (𝓝 x).HasBasis pX sX) (hF : F.HasBasis pF sF) :
    ClusterPt x F ↔ ∀ ⦃i⦄, pX i → ∀ ⦃j⦄, pF j → (sX i ∩ sF j).Nonempty
-- Mathlib/Data/Multiset/Range.lean
theorem not_mem_range_self {n : ℕ} : n ∉ range n
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
@[fun_prop]
theorem Continuous.rexp (h : Continuous f) : Continuous fun y ↦ exp (f y)
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem valuation_eq_one_iff (a : A) : IsUnit a ↔ A.valuation a = 1
-- Mathlib/RingTheory/Localization/Basic.lean
theorem add_mk (a b c d) : (mk a b : Localization M) + mk c d =
    mk ((b : R) * c + (d : R) * a) (b * d)
-- Mathlib/Data/Stream/Init.lean
@[simp]
theorem drop_drop (n m : ℕ) (s : Stream' α) : drop n (drop m s) = drop (n + m) s
-- Mathlib/Algebra/Polynomial/Div.lean
theorem pow_mul_divByMonic_rootMultiplicity_eq (p : R[X]) (a : R) :
    (X - C a) ^ rootMultiplicity a p * (p /ₘ (X - C a) ^ rootMultiplicity a p) = p
-- Mathlib/Analysis/SpecialFunctions/Stirling.lean
/-- The sequence `log ∘ stirlingSeq ∘ succ` is monotone decreasing -/
theorem log_stirlingSeq'_antitone : Antitone (Real.log ∘ stirlingSeq ∘ succ)
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
protected theorem ne_of_gt {a b : Fin n} (h : a < b) : b ≠ a
-- Mathlib/CategoryTheory/Galois/Basic.lean
/-- An object is initial if and only if its fiber is empty. -/
lemma initial_iff_fiber_empty (X : C) : Nonempty (IsInitial X) ↔ IsEmpty (F.obj X)
-- Mathlib/Data/Multiset/Pi.lean
theorem card_pi (m : Multiset α) (t : ∀ a, Multiset (β a)) :
    card (pi m t) = prod (m.map fun a => card (t a))
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem totallyBounded_iff_filter {s : Set α} :
    TotallyBounded s ↔ ∀ f, NeBot f → f ≤ 𝓟 s → ∃ c ≤ f, Cauchy c
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
@[simp]
theorem cofan_mk_inj {f : β → C} (P : C) (p : ∀ b, f b ⟶ P) (j : β) :
    (Cofan.mk P p).inj j = p j
-- Mathlib/CategoryTheory/Monad/Basic.lean
/-- Construct a comonad isomorphism from a natural isomorphism of functors where the forward
direction is a comonad morphism. -/
@[simps]
def ComonadIso.mk {M N : Comonad C} (f : (M : C ⥤ C) ≅ N)
    (f_ε : ∀ (X : C), f.hom.app X ≫ N.ε.app X = M.ε.app X := by aesop_cat)
    (f_δ : ∀ (X : C), f.hom.app X ≫ N.δ.app X =
    M.δ.app X ≫ f.hom.app (M.obj X) ≫ N.map (f.hom.app X) := by aesop_cat) : M ≅ N
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lcm.lean
@[simp] theorem lcm_one_right (m : Nat) : lcm m 1 = m
-- Mathlib/Order/Filter/Basic.lean
theorem map_const [NeBot f] {c : β} : (f.map fun _ => c) = pure c
-- Mathlib/Analysis/Normed/Group/Submodule.lean
/-- If `x` is an element of a submodule `s` of a normed group `E`, its norm in `s` is equal to its
norm in `E`. -/
@[simp]
theorem coe_norm [Ring 𝕜] [SeminormedAddCommGroup E] [Module 𝕜 E] {s : Submodule 𝕜 E}
    (x : s) : ‖x‖ = ‖(x : E)‖
-- Mathlib/RingTheory/MvPolynomial/Ideal.lean
/-- `x` is in a monomial ideal generated by variables `X` iff every element of its support
has a component in `s`. -/
theorem mem_ideal_span_X_image {x : MvPolynomial σ R} {s : Set σ} :
    x ∈ Ideal.span (MvPolynomial.X '' s : Set (MvPolynomial σ R)) ↔
      ∀ m ∈ x.support, ∃ i ∈ s, (m : σ →₀ ℕ) i ≠ 0
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
lemma LeftFractionRel.op {X Y : C} {z₁ z₂ : W.LeftFraction X Y}
    (h : LeftFractionRel z₁ z₂) : RightFractionRel z₁.op z₂.op
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean
theorem mul_mem' (U : (Opens (ProjectiveSpectrum.top 𝒜))ᵒᵖ) (a b : ∀ x : U.unop, at x.1)
    (ha : (isLocallyFraction 𝒜).pred a) (hb : (isLocallyFraction 𝒜).pred b) :
    (isLocallyFraction 𝒜).pred (a * b)
-- Mathlib/Control/Traversable/Instances.lean
protected theorem traverse_eq_map_id {α β} (f : α → β) (x : σ ⊕ α) :
    Sum.traverse ((pure : _ → Id _) ∘ f) x = (pure : _ → Id _) (f <$> x)
-- Mathlib/FieldTheory/PrimitiveElement.lean
/-- Primitive element theorem for finite dimensional extension of a finite field. -/
theorem exists_primitive_element_of_finite_bot [Finite F] [FiniteDimensional F E] :
    ∃ α : E, F⟮α⟯ = ⊤
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.map (f : α → β) (hl : l.HasBasis p s) : (l.map f).HasBasis p fun i => f '' s i
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIocDiv_eq_of_sub_zsmul_mem_Ioc (h : b - n • p ∈ Set.Ioc a (a + p)) :
    toIocDiv hp a b = n
-- Mathlib/Topology/UniformSpace/Basic.lean
lemma uniformContinuous_inr : UniformContinuous (Sum.inr : β → α ⊕ β)
-- Mathlib/Data/Nat/SuccPred.lean
@[simp]
theorem succ_eq_succ : Order.succ = succ
-- Mathlib/Data/Option/Basic.lean
theorem Mem.leftUnique : Relator.LeftUnique ((· ∈ ·) : α → Option α → Prop)
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp]
theorem sum_apply {ι : Type*} (Q : ι → QuadraticMap R M N) (s : Finset ι) (x : M) :
    (∑ i ∈ s, Q i) x = ∑ i ∈ s, Q i x
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
/-- If `f` is a multilinear map, then `f.toLinearMap m i` is the linear map obtained by fixing all
coordinates but `i` equal to those of `m`, and varying the `i`-th coordinate. -/
@[simps]
def toLinearMap [DecidableEq ι] (m : ∀ i, M₁ i) (i : ι) : M₁ i →ₗ[R] M₂
-- Mathlib/Analysis/SpecialFunctions/CompareExp.lean
theorem isLittleO_im_pow_exp_re (hl : IsExpCmpFilter l) (n : ℕ) :
    (fun z : ℂ => z.im ^ n) =o[l] fun z => Real.exp z.re
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem dist_triangle_left (x y z : α) : dist x y ≤ dist z x + dist z y
-- Mathlib/Topology/Inseparable.lean
theorem inseparable_iff_closure_eq : (x ~ᵢ y) ↔ closure ({x} : Set X) = closure {y}
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem num_div_dvd (p : K[X]) {q : K[X]} (hq : q ≠ 0) :
    num (algebraMap _ _ p / algebraMap _ _ q) ∣ p
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
@[simp]
theorem ofIsoColimit_desc {r t : Cocone F} (P : IsColimit r) (i : r ≅ t) (s) :
    (P.ofIsoColimit i).desc s = i.inv.hom ≫ P.desc s
-- Mathlib/Data/Nat/Nth.lean
theorem nth_le_nth_of_lt_card (hf : (setOf p).Finite) {m n : ℕ} (h : m ≤ n)
    (hn : n < hf.toFinset.card) : nth p m ≤ nth p n
-- Mathlib/Computability/TuringMachine.lean
@[elab_as_elim]
protected theorem ListBlank.induction_on {Γ} [Inhabited Γ] {p : ListBlank Γ → Prop}
    (q : ListBlank Γ) (h : ∀ a, p (ListBlank.mk a)) : p q
-- Mathlib/MeasureTheory/Measure/WithDensityFinite.lean
lemma toFiniteAux_eq_zero_iff [SFinite μ] : μ.toFiniteAux = 0 ↔ μ = 0
-- Mathlib/Data/NNRat/BigOperators.lean
@[norm_cast]
theorem coe_multiset_prod (s : Multiset ℚ≥0) : (s.prod : ℚ) = (s.map (↑)).prod
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem hasDerivAt_cosh (x : ℝ) : HasDerivAt cosh (sinh x) x
-- Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean
/-- "iff" version of `Multipliable.of_nat_of_neg_add_one`. -/
@[to_additive "\"iff\" version of `Summable.of_nat_of_neg_add_one`."]
lemma multipliable_int_iff_multipliable_nat_and_neg_add_one {f : ℤ → G} : Multipliable f ↔
    (Multipliable fun n : ℕ ↦ f n) ∧ (Multipliable fun n : ℕ ↦ f (-(n + 1)))
-- Mathlib/Analysis/NormedSpace/OperatorNorm/NNNorm.lean
/-- For a continuous real linear map `f`, if one controls the norm of every `f x`, `‖x‖₊ = 1`, then
one controls the norm of `f`. -/
theorem opNNNorm_le_of_unit_nnnorm [NormedSpace ℝ E] [NormedSpace ℝ F] {f : E →L[ℝ] F} {C : ℝ≥0}
    (hf : ∀ x, ‖x‖₊ = 1 → ‖f x‖₊ ≤ C) : ‖f‖₊ ≤ C