ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/FieldTheory/IntermediateField.lean
theorem minpoly_eq (x : S) : minpoly K x = minpoly K (x : L)
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
theorem H0LequivOfIsTrivial_apply [A.IsTrivial] (x : H0 A) :
    H0LequivOfIsTrivial A x = x
-- Mathlib/Computability/Partrec.lean
theorem vector_toList {n} : Computable (@Vector.toList α n)
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ico_subset_Ioo_left (h₁ : a₁ < a₂) : Ico a₂ b ⊆ Ioo a₁ b
-- Mathlib/Topology/Connected/Basic.lean
theorem IsPreconnected.preimage_of_isOpenMap [TopologicalSpace β] {f : α → β} {s : Set β}
    (hs : IsPreconnected s) (hinj : Function.Injective f) (hf : IsOpenMap f) (hsf : s ⊆ range f) :
    IsPreconnected (f ⁻¹' s)
-- Mathlib/Order/SuccPred/LinearLocallyFinite.lean
theorem le_succFn (i : ι) : i ≤ succFn i
-- Mathlib/NumberTheory/Padics/PadicVal.lean
theorem of_ne_one_ne_zero {z : ℤ} (hp : p ≠ 1) (hz : z ≠ 0) :
    padicValInt p z =
      (multiplicity (p : ℤ) z).get
        (by
          apply multiplicity.finite_int_iff.2
          simp [hp, hz])
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem ker_ne_top [Nontrivial S] (f : F) : ker f ≠ ⊤
-- Mathlib/Topology/Algebra/Module/LocallyConvex.lean
theorem locallyConvexSpace_iff :
    LocallyConvexSpace 𝕜 E ↔ ∀ x : E, (𝓝 x).HasBasis (fun s : Set E => s ∈ 𝓝 x ∧ Convex 𝕜 s) id
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
theorem isFractional_span_singleton (x : P) : IsFractional S (span R {x} : Submodule R P)
-- Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean
/-- This is [grinberg_clifford_2016][] Theorem 7 -/
theorem contractLeft_contractLeft (x : CliffordAlgebra Q) : d⌋(d⌋x) = 0
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive sub_nsmul_nsmul_add]
lemma pow_sub_mul_pow (a : M) (h : m ≤ n) : a ^ (n - m) * a ^ m = a ^ n
-- Mathlib/NumberTheory/DiophantineApproximation.lean
/-- The technical version of *Legendre's Theorem*. -/
theorem exists_rat_eq_convergent' {v : ℕ} (h' : ContfracLegendre.Ass ξ u v) :
    ∃ n, (u / v : ℚ) = ξ.convergent n
-- Mathlib/Algebra/Algebra/Operations.lean
theorem smul_le_smul {s t : SetSemiring A} {M N : Submodule R A}
    (h₁ : SetSemiring.down (α := A) s ⊆ SetSemiring.down (α := A) t)
    (h₂ : M ≤ N) : s • M ≤ t • N
-- Mathlib/NumberTheory/ArithmeticFunction.lean
theorem one_apply {x : ℕ} : (1 : ArithmeticFunction R) x = ite (x = 1) 1 0
-- Mathlib/NumberTheory/ArithmeticFunction.lean
theorem mul_apply_one [Semiring R] {f g : ArithmeticFunction R} : (f * g) 1 = f 1 * g 1
-- Mathlib/RingTheory/Ideal/IsPrincipal.lean
theorem mem_isPrincipalSubmonoid_iff {I : Ideal R} :
    I ∈ isPrincipalSubmonoid R ↔ IsPrincipal I
-- Mathlib/Deprecated/Group.lean
theorem map' {f : M → N} (hf : IsMonoidHom f) {x : M} (h : IsUnit x) : IsUnit (f x)
-- Mathlib/Data/Multiset/Powerset.lean
theorem powersetCard_zero_right (n : ℕ) : @powersetCard α (n + 1) 0 = 0
-- Mathlib/Algebra/DualQuaternion.lean
@[simp]
theorem fst_re_dualNumberEquiv_symm (d : DualNumber (Quaternion R)) :
    (dualNumberEquiv.symm d).re.fst = d.fst.re
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
/-- When both maps `S.f` and `S.g` of a short complex `S` are zero, this is the left homology map
data (for the identity of `S`) which relates the left homology data `ofZeros` and
`ofIsColimitCokernelCofork`. -/
@[simps]
def compatibilityOfZerosOfIsColimitCokernelCofork (hf : S.f = 0) (hg : S.g = 0)
    (c : CokernelCofork S.f) (hc : IsColimit c) :
    LeftHomologyMapData (𝟙 S) (LeftHomologyData.ofZeros S hf hg)
      (LeftHomologyData.ofIsColimitCokernelCofork S hg c hc)
-- Mathlib/Topology/Instances/ENNReal.lean
theorem tendsto_sub : ∀ {a b : ℝ≥0∞}, (a ≠ ∞ ∨ b ≠ ∞) →
    Tendsto (fun p : ℝ≥0∞ × ℝ≥0∞ => p.1 - p.2) (𝓝 (a, b)) (𝓝 (a - b))
-- Mathlib/Topology/Instances/TrivSqZeroExt.lean
nonrec theorem continuous_fst : Continuous (fst : tsze R M → R)
-- Mathlib/Combinatorics/SimpleGraph/Partition.lean
theorem partitionable_iff_colorable {n : ℕ} : G.Partitionable n ↔ G.Colorable n
-- Mathlib/CategoryTheory/Comma/Presheaf.lean
lemma counitForward_counitBackward (F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v)
    (s : CostructuredArrow yoneda A) : counitForward F s ∘ counitBackward F s = id
-- Mathlib/CategoryTheory/Triangulated/Basic.lean
@[simps]
def Triangle.homMk (A B : Triangle C)
    (hom₁ : A.obj₁ ⟶ B.obj₁) (hom₂ : A.obj₂ ⟶ B.obj₂) (hom₃ : A.obj₃ ⟶ B.obj₃)
    (comm₁ : A.mor₁ ≫ hom₂ = hom₁ ≫ B.mor₁ := by aesop_cat)
    (comm₂ : A.mor₂ ≫ hom₃ = hom₂ ≫ B.mor₂ := by aesop_cat)
    (comm₃ : A.mor₃ ≫ hom₁⟦1⟧' = hom₃ ≫ B.mor₃ := by aesop_cat) :
    A ⟶ B
-- Mathlib/Order/BooleanAlgebra.lean
@[simp]
theorem compl_inj_iff : xᶜ = yᶜ ↔ x = y
-- Mathlib/CategoryTheory/Dialectica/Monoidal.lean
/-- Right unit cancellation `X ⊗ 1 ≅ X` in `Dial C`. -/
@[simps!] def rightUnitor (X : Dial C) : tensorObj X tensorUnit ≅ X
-- Mathlib/SetTheory/Cardinal/Finite.lean
lemma card_eq_card_toFinset (s : Set α) [Fintype s] : Nat.card s = s.toFinset.card
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
theorem arg_ofReal_of_nonneg {x : ℝ} (hx : 0 ≤ x) : arg x = 0
-- Mathlib/Order/Filter/Ultrafilter.lean
theorem mem_iff_ultrafilter : s ∈ f ↔ ∀ g : Ultrafilter α, ↑g ≤ f → s ∈ g
-- Mathlib/Data/List/Cycle.lean
@[deprecated next_get (since := "2023-01-27")]
theorem next_nthLe (l : List α) (h : Nodup l) (n : ℕ) (hn : n < l.length) :
    next l (l.nthLe n hn) (nthLe_mem _ _ _) =
      l.nthLe ((n + 1) % l.length) (Nat.mod_lt _ (n.zero_le.trans_lt hn))
-- Mathlib/LinearAlgebra/Dimension/LinearMap.lean
/-- The rank of the composition of two maps is less than the minimum of their ranks. -/
theorem lift_rank_comp_le (g : V →ₗ[K] V') (f : V' →ₗ[K] V'') :
    Cardinal.lift.{v'} (rank (f.comp g)) ≤
      min (Cardinal.lift.{v'} (rank f)) (Cardinal.lift.{v''} (rank g))
-- Mathlib/ModelTheory/Syntax.lean
/-- Maps a sentence's symbols along a language equivalence. -/
@[simps!] -- Porting note: add `!` to `simps`
def onSentence (φ : L ≃ᴸ L') : L.Sentence ≃ L'.Sentence
-- Mathlib/Order/Filter/Bases.lean
theorem exists_antitone_seq (f : Filter α) [f.IsCountablyGenerated] :
    ∃ x : ℕ → Set α, Antitone x ∧ ∀ {s}, s ∈ f ↔ ∃ i, x i ⊆ s
-- Mathlib/LinearAlgebra/StdBasis.lean
theorem coe_stdBasis (i : ι) : ⇑(stdBasis R φ i) = Pi.single i
-- Mathlib/CategoryTheory/Subobject/Lattice.lean
theorem prod_eq_inf {A : C} {f₁ f₂ : Subobject A} [HasBinaryProduct f₁ f₂] :
    (f₁ ⨯ f₂) = f₁ ⊓ f₂
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
/-- The braiding isomorphism which swaps a binary coproduct. -/
@[simps]
def coprod.braiding (P Q : C) : P ⨿ Q ≅ Q ⨿ P
-- Mathlib/Algebra/Group/Action/Defs.lean
/-- This cannot be an instance because it can cause infinite loops whenever the `SMul` arguments
are still metavariables. -/
@[to_additive
"This cannot be an instance because it can cause infinite loops whenever the `VAdd` arguments
are still metavariables."]
lemma comp.smulCommClass' [SMul β α] [SMulCommClass β M α] (g : N → M) :
    haveI := comp α g
    SMulCommClass β N α
-- Mathlib/Data/Set/Lattice.lean
@[congr]
theorem iInter_congr_Prop {p q : Prop} {f₁ : p → Set α} {f₂ : q → Set α} (pq : p ↔ q)
    (f : ∀ x, f₁ (pq.mpr x) = f₂ x) : iInter f₁ = iInter f₂
-- Mathlib/Data/ENNReal/Inv.lean
protected theorem mul_div_mul_right (a b : ℝ≥0∞) (hc : c ≠ 0) (hc' : c ≠ ⊤) :
    a * c / (b * c) = a / b
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Div.lean
@[simp] theorem mul_div_left (m : Nat) {n : Nat} (H : 0 < n) : m * n / n = m
-- Mathlib/Algebra/Group/Units.lean
@[to_additive (attr := simp, norm_cast)]
theorem val_one : ((1 : αˣ) : α) = 1
-- Mathlib/Order/Closure.lean
theorem closure_sup_closure (x y : α) : c (c x ⊔ c y) = c (x ⊔ y)
-- Mathlib/Topology/Basic.lean
theorem Filter.HasBasis.nhds_interior {x : X} {p : ι → Prop} {s : ι → Set X}
    (h : (𝓝 x).HasBasis p s) : (𝓝 x).HasBasis p (interior <| s ·)
-- Mathlib/Data/Num/Lemmas.lean
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ)
-- Mathlib/Topology/Semicontinuous.lean
theorem IsOpen.upperSemicontinuousOn_indicator (hs : IsOpen s) (hy : y ≤ 0) :
    UpperSemicontinuousOn (indicator s fun _x => y) t
-- Mathlib/Data/Real/EReal.lean
/-- `-a ≤ b ↔ -b ≤ a` on `EReal`. -/
protected theorem neg_le {a b : EReal} : -a ≤ b ↔ -b ≤ a
-- Mathlib/Algebra/Order/Monoid/NatCast.lean
/-- See `zero_lt_two` for a version with the type implicit. -/
lemma zero_lt_two' : (0 : α) < 2
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ico_eq_empty_of_le (h : b ≤ a) : Ico a b = ∅
-- Mathlib/Analysis/Convex/Hull.lean
theorem Convex.convex_remove_iff_not_mem_convexHull_remove {s : Set E} (hs : Convex 𝕜 s) (x : E) :
    Convex 𝕜 (s \ {x}) ↔ x ∉ convexHull 𝕜 (s \ {x})
-- Mathlib/Topology/Compactification/OnePoint.lean
theorem continuousAt_infty' {Y : Type*} [TopologicalSpace Y] {f : OnePoint X → Y} :
    ContinuousAt f ∞ ↔ Tendsto (f ∘ (↑)) (coclosedCompact X) (𝓝 (f ∞))
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
/-- If the set where you want `f` to be smooth lies entirely in a single chart, and `f` maps it
  into a single chart, the smoothness of `f` on that set can be expressed by purely looking in
  these charts.
  Note: this lemma uses `extChartAt I x '' s` instead of `(extChartAt I x).symm ⁻¹' s` to ensure
  that this set lies in `(extChartAt I x).target`. -/
theorem contMDiffOn_iff_of_subset_source' {x : M} {y : M'} (hs : s ⊆ (extChartAt I x).source)
    (h2s : MapsTo f s (extChartAt I' y).source) :
    ContMDiffOn I I' n f s ↔
        ContDiffOn 𝕜 n (extChartAt I' y ∘ f ∘ (extChartAt I x).symm) (extChartAt I x '' s)
-- Mathlib/Data/Set/Function.lean
theorem injOn_range (h : Semiconj f fa fb) (ha : Injective fa) (hf : InjOn f (range fa)) :
    InjOn fb (range f)
-- Mathlib/GroupTheory/CoprodI.lean
theorem lift_word_prod_nontrivial_of_head_card {i j} (w : NeWord H i j) (hcard : 3 ≤ #(H i))
    (hheadtail : i ≠ j) : lift f w.prod ≠ 1
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem congr_fun (h : Q = Q') (x : M) : Q x = Q' x
-- Mathlib/Algebra/Star/Basic.lean
protected theorem IsUnit.star [Monoid R] [StarMul R] {a : R} : IsUnit a → IsUnit (star a)
-- Mathlib/Data/Nat/Factorization/Defs.lean
theorem multiplicity_eq_factorization {n p : ℕ} (pp : p.Prime) (hn : n ≠ 0) :
    multiplicity p n = n.factorization p
-- Mathlib/Tactic/Rify.lean
@[rify_simps] lemma ratCast_lt (a b : ℚ) : a < b ↔ (a : ℝ) < (b : ℝ)
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem mul_equiv_zero' (g : CauSeq _ abv) {f : CauSeq _ abv} (hf : f ≈ 0) : f * g ≈ 0
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
theorem isUnit_iff_mulLeft_bijective {a : M} :
    IsUnit a ↔ Function.Bijective (a * ·)
-- Mathlib/RingTheory/Polynomial/Eisenstein/Basic.lean
theorem _root_.Polynomial.Monic.isEisensteinAt_of_mem_of_not_mem (hf : f.Monic) (h : 𝓟 ≠ ⊤)
    (hmem : ∀ {n}, n < f.natDegree → f.coeff n ∈ 𝓟) (hnot_mem : f.coeff 0 ∉ 𝓟 ^ 2) :
    f.IsEisensteinAt 𝓟
-- Mathlib/RingTheory/Polynomial/Hermite/Basic.lean
theorem coeff_hermite (n k : ℕ) :
    coeff (hermite n) k =
      if Even (n + k) then (-1 : ℤ) ^ ((n - k) / 2) * (n - k - 1)‼ * Nat.choose n k else 0
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem comap_sup_comap_le (H K : Subgroup N) (f : G →* N) :
    comap f H ⊔ comap f K ≤ comap f (H ⊔ K)
-- Mathlib/Data/Finset/Sort.lean
/-- Two parametrizations `orderEmbOfFin` of the same set take the same value on `i` and `j` if
and only if `i = j`. Since they can be defined on a priori not defeq types `Fin k` and `Fin l`
(although necessarily `k = l`), the conclusion is rather written `(i : ℕ) = (j : ℕ)`. -/
@[simp]
theorem orderEmbOfFin_eq_orderEmbOfFin_iff {k l : ℕ} {s : Finset α} {i : Fin k} {j : Fin l}
    {h : s.card = k} {h' : s.card = l} :
    s.orderEmbOfFin h i = s.orderEmbOfFin h' j ↔ (i : ℕ) = (j : ℕ)
-- Mathlib/Data/QPF/Multivariate/Constructions/Cofix.lean
theorem corecF_eq {α : TypeVec n} {β : Type u} (g : β → F (α.append1 β)) (x : β) :
    M.dest q.P (corecF g x) = appendFun id (corecF g) <$$> repr (g x)
-- Mathlib/Algebra/BigOperators/Finsupp.lean
/-- Generalization of `Finsupp.mul_prod_erase`: if `g` maps a second argument of 0 to 1,
then its product over `f : α →₀ M` is the same as multiplying the value on any element
`y : α` by the product over `erase y f`. -/
@[to_additive
      " Generalization of `Finsupp.add_sum_erase`: if `g` maps a second argument of 0
      to 0, then its sum over `f : α →₀ M` is the same as adding the value on any element
      `y : α` to the sum over `erase y f`. "]
theorem mul_prod_erase' (f : α →₀ M) (y : α) (g : α → M → N) (hg : ∀ i : α, g i 0 = 1) :
    g y (f y) * (erase y f).prod g = f.prod g
-- Mathlib/Algebra/BigOperators/Finprod.lean
@[to_additive]
theorem finprod_congr {f g : α → M} (h : ∀ x, f x = g x) : finprod f = finprod g
-- Mathlib/Order/Concept.lean
theorem intentClosure_iUnion₂ (f : ∀ i, κ i → Set α) :
    intentClosure r (⋃ (i) (j), f i j) = ⋂ (i) (j), intentClosure r (f i j)
-- Mathlib/Order/PFilter.lean
/-- A specific witness of `pfilter.nonempty` when `P` has a top element. -/
@[simp] theorem top_mem : ⊤ ∈ F
-- Mathlib/Topology/Order/DenselyOrdered.lean
theorem map_coe_atTop_of_Ioo_subset (hb : s ⊆ Iio b) (hs : ∀ a' < b, ∃ a < b, Ioo a b ⊆ s) :
    map ((↑) : s → α) atTop = 𝓝[<] b
-- Mathlib/LinearAlgebra/Span.lean
theorem mem_iSup {ι : Sort*} (p : ι → Submodule R M) {m : M} :
    (m ∈ ⨆ i, p i) ↔ ∀ N, (∀ i, p i ≤ N) → m ∈ N
-- Mathlib/Analysis/Convex/SpecificFunctions/Basic.lean
/-- `Real.exp` is convex on the whole real line. -/
theorem convexOn_exp : ConvexOn ℝ univ exp
-- Mathlib/FieldTheory/PerfectClosure.lean
theorem natCast_eq_iff (x y : ℕ) : (x : PerfectClosure K p) = y ↔ (x : K) = y
-- Mathlib/CategoryTheory/Monoidal/Limits.lean
@[simp]
theorem limLax_obj (F : J ⥤ C) : limLax.obj F = limit F
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem two_nsmul_toReal_eq_two_mul {θ : Angle} :
    ((2 : ℕ) • θ).toReal = 2 * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / 2) (π / 2)
-- Mathlib/Order/Filter/Basic.lean
theorem _root_.Function.LeftInverse.filter_comap {f : α → β} {g : β → α} (hfg : LeftInverse g f) :
    RightInverse (comap g) (comap f)
-- Mathlib/Data/List/Basic.lean
@[simp] theorem tail_replicate (a : α) (n) :
    tail (replicate n a) = replicate (n - 1) a
-- Mathlib/SetTheory/Game/PGame.lean
theorem neg_lt_iff {x y : PGame} : -y < x ↔ -x < y
-- Mathlib/Data/Rat/Cast/Order.lean
@[simp]
theorem preimage_cast_uIoc (p q : ℚ) : (↑) ⁻¹' uIoc (p : K) q = uIoc p q
-- Mathlib/Order/Hom/Lattice.lean
/-- Adjoins a `⊤` to the domain and codomain of a `LatticeHom`. -/
@[simps]
protected def withTop (f : LatticeHom α β) : LatticeHom (WithTop α) (WithTop β)
-- Mathlib/Data/Finset/Union.lean
@[simp] lemma mem_disjiUnion {b : β} {h} : b ∈ s.disjiUnion t h ↔ ∃ a ∈ s, b ∈ t a
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
theorem reflection_orthogonal_apply (v : E) : reflection Kᗮ v = -reflection K v
-- Mathlib/RingTheory/TensorProduct/Basic.lean
theorem adjoin_tmul_eq_top : adjoin R { t : A ⊗[R] B | ∃ a b, a ⊗ₜ[R] b = t } = ⊤
-- Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean
/-- The graph induced by the adjacency matrix of `G` is `G` itself. -/
theorem toGraph_adjMatrix_eq [MulZeroOneClass α] [Nontrivial α] :
    (G.isAdjMatrix_adjMatrix α).toGraph = G
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[to_additive (attr := measurability)]
theorem _root_.List.aestronglyMeasurable_prod' (l : List (α → M))
    (hl : ∀ f ∈ l, AEStronglyMeasurable f μ) : AEStronglyMeasurable l.prod μ
-- Mathlib/Algebra/Order/Monoid/Unbundled/Defs.lean
/-- Dual of `Monotone.covariant_of_const'` -/
theorem Antitone.covariant_of_const' {μ : N → N → N} [CovariantClass N N (swap μ) (· ≤ ·)]
    (hf : Antitone f) (m : N) : Antitone (f <| μ · m)
-- Mathlib/LinearAlgebra/Span.lean
theorem span_le {p} : span R s ≤ p ↔ s ⊆ p
-- .lake/packages/lean4/src/lean/Init/Data/Array/Basic.lean
theorem data_toArray (as : List α) : as.toArray.data = as
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
@[ext]
theorem ext {f g : lp E p} (h : (f : ∀ i, E i) = g) : f = g
-- Mathlib/Algebra/Homology/ShortComplex/ShortExact.lean
lemma ShortExact.mk' (h : S.Exact) (_ : Mono S.f) (_ : Epi S.g) : S.ShortExact
-- Mathlib/Data/Fintype/BigOperators.lean
@[to_additive]
theorem prod_eq_one (f : α → M) (h : ∀ a, f a = 1) : ∏ a, f a = 1
-- Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
lemma ext_from (i j : ℤ) (hij : j + 1 = i) {A : C} {f g : (mappingCone φ).X j ⟶ A}
    (h₁ : (inl φ).v i j (by omega) ≫ f = (inl φ).v i j (by omega) ≫ g)
    (h₂ : (inr φ).f j ≫ f = (inr φ).f j ≫ g) :
    f = g
-- Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean
theorem hom_mk {v : V} (vnL : v ∉ L) (h : K ⊆ L) :
    (G.componentComplMk vnL).hom h = G.componentComplMk (Set.not_mem_subset h vnL)
-- Mathlib/Tactic/CategoryTheory/MonoidalComp.lean
@[simps]
instance assoc' (W X Y Z : C) [MonoidalCoherence W (X ⊗ (Y ⊗ Z))] :
    MonoidalCoherence W ((X ⊗ Y) ⊗ Z)
-- Mathlib/Tactic/Ring/Basic.lean
theorem add_pf_add_overlap_zero
    (h : IsNat (a₁ + b₁) (nat_lit 0)) (h₄ : a₂ + b₂ = c) : (a₁ + a₂ : R) + (b₁ + b₂) = c
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
/-- The dimension of a submodule is bounded by the dimension of the ambient space. -/
theorem Submodule.finrank_le [Module.Finite R M] (s : Submodule R M) :
    finrank R s ≤ finrank R M
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem ext_fourfold {g h : ((M ⊗[R] N) ⊗[R] P) ⊗[R] Q →ₗ[R] S}
    (H : ∀ w x y z, g (w ⊗ₜ x ⊗ₜ y ⊗ₜ z) = h (w ⊗ₜ x ⊗ₜ y ⊗ₜ z)) : g = h
-- Mathlib/Data/Real/EReal.lean
lemma toReal_mul {x y : EReal} : toReal (x * y) = toReal x * toReal y
-- Mathlib/MeasureTheory/Covering/OneDim.lean
theorem tendsto_Icc_vitaliFamily_left (x : ℝ) :
    Tendsto (fun y => Icc y x) (𝓝[<] x) ((vitaliFamily (volume : Measure ℝ) 1).filterAt x)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
@[simp]
theorem cos_int_mul_two_pi_sub (x : ℝ) (n : ℤ) : cos (n * (2 * π) - x) = cos x
-- Mathlib/Tactic/NormNum/Basic.lean
theorem IsInt.raw_refl (n : ℤ) : IsInt n n
-- Mathlib/Data/Finset/Image.lean
@[simp]
theorem attach_image_val [DecidableEq α] {s : Finset α} : s.attach.image Subtype.val = s
-- Mathlib/Topology/Spectral/Hom.lean
@[simp]
theorem id_comp (f : SpectralMap α β) : (SpectralMap.id β).comp f = f
-- Mathlib/Order/Zorn.lean
theorem zorn_preorder (h : ∀ c : Set α, IsChain (· ≤ ·) c → BddAbove c) :
    ∃ m : α, ∀ a, m ≤ a → a ≤ m
-- Mathlib/Data/Matrix/Block.lean
/-- `Matrix.blockDiagonal` as a `RingHom`. -/
@[simps]
def blockDiagonalRingHom [DecidableEq m] [Fintype o] [Fintype m] [NonAssocSemiring α] :
    (o → Matrix m m α) →+* Matrix (m × o) (m × o) α
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem withTopCongr_refl : (OrderIso.refl α).withTopCongr = OrderIso.refl _
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem memℒp_top_of_bound {f : α → E} (hf : AEStronglyMeasurable f μ) (C : ℝ)
    (hfC : ∀ᵐ x ∂μ, ‖f x‖ ≤ C) : Memℒp f ∞ μ
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
@[simp, fun_prop]
theorem differentiable_id : Differentiable 𝕜 (id : E → E)
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
theorem homothety_apply (c : P1) (r : k) (p : P1) : homothety c r p = r • (p -ᵥ c : V1) +ᵥ c
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[simp] theorem coe_singleton [MeasurableSingletonClass α] (a : α) :
    ↑({a} : Subtype (MeasurableSet : Set α → Prop)) = ({a} : Set α)
-- Mathlib/Data/List/Infix.lean
theorem mem_of_mem_suffix (hx : a ∈ l₁) (hl : l₁ <:+ l₂) : a ∈ l₂
-- Mathlib/Analysis/Normed/Ring/Units.lean
/-- The formula
`Ring.inverse (x + t) =
  (∑ i ∈ Finset.range n, (- x⁻¹ * t) ^ i) * x⁻¹ + (- x⁻¹ * t) ^ n * Ring.inverse (x + t)`
holds for `t` sufficiently small. -/
theorem inverse_add_nth_order (x : Rˣ) (n : ℕ) :
    ∀ᶠ t in 𝓝 0, inverse ((x : R) + t) =
      (∑ i ∈ range n, (-↑x⁻¹ * t) ^ i) * ↑x⁻¹ + (-↑x⁻¹ * t) ^ n * inverse (x + t)
-- Mathlib/CategoryTheory/ComposableArrows.lean
lemma map_id (i : Fin (n + 1 + 1)) : map F f i i (by simp) = 𝟙 _
-- Mathlib/Data/Sym/Basic.lean
@[simp]
theorem append_inj_right (s : Sym α n) {t t' : Sym α n'} : s.append t = s.append t' ↔ t = t'
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem comap_map_eq_self {f : G →* N} {H : Subgroup G} (h : f.ker ≤ H) :
    comap f (map f H) = H
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive]
theorem le_comap_of_map_le {T : Subsemigroup N} {f : M →ₙ* N} : S.map f ≤ T → S ≤ T.comap f
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem add_moveLeft_inl {x : PGame} (y : PGame) (i) :
    (x + y).moveLeft (toLeftMovesAdd (Sum.inl i)) = x.moveLeft i + y
-- Mathlib/Data/Seq/Computation.lean
theorem exists_of_liftRel_left {R : α → β → Prop} {ca cb} (H : LiftRel R ca cb) {a} (h : a ∈ ca) :
    ∃ b, b ∈ cb ∧ R a b
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem erase_cons_tail {a b : α} (l : List α) (h : ¬(b == a)) :
    (b :: l).erase a = b :: l.erase a
-- Mathlib/CategoryTheory/Shift/CommShift.lean
/-- If `τ : F₁ ⟶ F₂` is a natural transformation between two functors
which commute with a shift by an additive monoid `A`, this typeclass
asserts a compatibility of `τ` with these shifts. -/
class CommShift : Prop :=
  comm' (a : A) : (F₁.commShiftIso a).hom ≫ whiskerRight τ _ =
    whiskerLeft _ τ ≫ (F₂.commShiftIso a).hom
-- Mathlib/Order/Antichain.lean
protected theorem eq (hs : IsAntichain r s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) (h : r a b) :
    a = b
-- Mathlib/Data/Fin/Basic.lean
lemma predAbove_of_lt_succ (p : Fin n) (i : Fin (n + 1)) (h : i < succ p)
    (hi := Fin.ne_last_of_lt h) : p.predAbove i = i.castPred hi
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
/-- Uses `left` co(ntra)variant. -/
@[to_additive (attr := simp) "Uses `left` co(ntra)variant."]
theorem Left.inv_lt_one_iff : a⁻¹ < 1 ↔ 1 < a
-- Mathlib/Logic/Denumerable.lean
theorem ofNat_surjective_aux : ∀ {x : ℕ} (hx : x ∈ s), ∃ n, ofNat s n = ⟨x, hx⟩
-- Mathlib/GroupTheory/Commensurable.lean
theorem equivalence : Equivalence (@Commensurable G _)
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem norm_eq_integral (f : α →₁ₛ[μ] E) : ‖f‖ = ((toSimpleFunc f).map norm).integral μ
-- .lake/packages/lean4/src/lean/Init/Omega/Int.lean
theorem natAbs_dichotomy {a : Int} : 0 ≤ a ∧ a.natAbs = a ∨ a < 0 ∧ a.natAbs = -a
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean
theorem ratio_le_opNorm : ‖f x‖ / ‖x‖ ≤ ‖f‖
-- Mathlib/Topology/Algebra/UniformMulAction.lean
@[to_additive]
lemma UniformInducing.uniformContinuousConstSMul [SMul M Y] [UniformContinuousConstSMul M Y]
    {f : X → Y} (hf : UniformInducing f) (hsmul : ∀ (c : M) x, f (c • x) = c • f x) :
    UniformContinuousConstSMul M X
-- Mathlib/FieldTheory/IsAlgClosed/AlgebraicClosure.lean
theorem AdjoinMonic.exists_root {f : k[X]} (hfm : f.Monic) (hfi : Irreducible f) :
    ∃ x : AdjoinMonic k, f.eval₂ (toAdjoinMonic k) x = 0
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- A side of a right-angled triangle divided by the cosine of the adjacent angle equals the
hypotenuse, version subtracting vectors. -/
theorem norm_div_cos_oangle_sub_right_of_oangle_eq_pi_div_two {x y : V}
    (h : o.oangle x y = ↑(π / 2)) : ‖y‖ / Real.Angle.cos (o.oangle y (y - x)) = ‖y - x‖
-- Mathlib/Probability/Kernel/Disintegration/StandardBorel.lean
/-- Auxiliary lemma for `condKernel_apply_of_ne_zero`. -/
@[deprecated Measure.IsCondKernel.apply_of_ne_zero (since := "2024-07-24"), nolint unusedArguments]
lemma _root_.MeasureTheory.Measure.condKernel_apply_of_ne_zero_of_measurableSet
    [MeasurableSingletonClass α] {x : α} (hx : ρ.fst {x} ≠ 0) {s : Set Ω} (hs : MeasurableSet s) :
    ρ.condKernel x s = (ρ.fst {x})⁻¹ * ρ ({x} ×ˢ s)
-- Mathlib/Order/Antichain.lean
protected theorem Symmetric.compl (h : Symmetric r) : Symmetric rᶜ
-- Mathlib/MeasureTheory/Constructions/Prod/Integral.lean
theorem MeasureTheory.AEStronglyMeasurable.fst {γ} [TopologicalSpace γ] [SFinite ν] {f : α → γ}
    (hf : AEStronglyMeasurable f μ) : AEStronglyMeasurable (fun z : α × β => f z.1) (μ.prod ν)
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Restrict.lean
lemma cfcₙ_eq_restrict (f : C(S, R)) (halg : UniformEmbedding (algebraMap R S)) {a : A} (hpa : p a)
    (hqa : q a) (h : QuasispectrumRestricts a f) [CompactSpace (σₙ S a)] (g : R → R) :
    cfcₙ g a = cfcₙ (fun x ↦ algebraMap R S (g (f x))) a