ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Homology/Opposite.lean
/-- Auxiliary definition for `unopEquivalence`. -/
@[simps]
def unopInverse : HomologicalComplex V c.symm ⥤ (HomologicalComplex Vᵒᵖ c)ᵒᵖ
-- Mathlib/Data/ENat/Basic.lean
theorem coe_zero : ((0 : ℕ) : ℕ∞) = 0
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem bne_right_inj : ∀ (x y z : Bool), (x != z) = (y != z) ↔ x = y
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem natDegree_of_b_eq_zero' : (toPoly ⟨0, 0, c, d⟩).natDegree ≤ 1
-- Mathlib/Algebra/Order/Interval/Set/Group.lean
theorem pairwise_disjoint_Ico_add_intCast :
    Pairwise (Disjoint on fun n : ℤ => Ico (a + n) (a + n + 1))
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem top_toSubmonoid : (⊤ : Subgroup G).toSubmonoid = ⊤
-- Mathlib/Analysis/Normed/Order/Basic.lean
/-- A `NormedOrderedGroup` is a group that is both a `NormedCommGroup` and an
`OrderedCommGroup`. This class is necessary to avoid diamonds caused by both classes
carrying their own group structure. -/
@[to_additive]
class NormedOrderedGroup (α : Type*) extends OrderedCommGroup α, Norm α, MetricSpace α where
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x / y‖ := by aesop
-- Mathlib/Algebra/Polynomial/Smeval.lean
@[simp]
theorem smeval_sub : (p - q).smeval x = p.smeval x - q.smeval x
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
/-- The `i + j`-th element of a list coincides with the `j`-th element of the list obtained by
dropping the first `i` elements. Version designed to rewrite from the big list to the small list. -/
@[deprecated getElem_drop (since := "2024-06-12")]
theorem get_drop (L : List α) {i j : Nat} (h : i + j < L.length) :
    get L ⟨i + j, h⟩ = get (L.drop i) ⟨j, lt_length_drop L h⟩
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToFun_measure_zero (hT : DominatedFinMeasAdditive μ T C) (h : μ = 0) :
    setToFun μ T hT f = 0
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
theorem DifferentiableAt.neg (h : DifferentiableAt 𝕜 f x) : DifferentiableAt 𝕜 (fun y => -f y) x
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
theorem neighborSet_subset_verts (G' : Subgraph G) (v : V) : G'.neighborSet v ⊆ G'.verts
-- Mathlib/Topology/Separation.lean
/-- A point with a finite neighborhood has to be isolated. -/
theorem isOpen_singleton_of_finite_mem_nhds [T1Space X] (x : X)
    {s : Set X} (hs : s ∈ 𝓝 x) (hsf : s.Finite) : IsOpen ({x} : Set X)
-- Mathlib/CategoryTheory/ComposableArrows.lean
@[simp]
lemma precomp_δ₀ {X : C} (f : X ⟶ F.left) : (F.precomp f).δ₀ = F
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
/-- Two subsemirings are equal if they have the same elements. -/
@[ext]
theorem ext {S T : Subsemiring R} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
theorem HasStrictDerivAt.mul_const (hc : HasStrictDerivAt c c' x) (d : 𝔸) :
    HasStrictDerivAt (fun y => c y * d) (c' * d) x
-- Mathlib/Computability/Partrec.lean
theorem snd : Computable (@Prod.snd α β)
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
@[simp]
theorem deriv_const_mul_field' (u : 𝕜') : (deriv fun x => u * v x) = fun x => u * deriv v x
-- Mathlib/NumberTheory/GaussSum.lean
/-- If the square of the Gauss sum of a quadratic character is `χ(-1) * #R`,
then we get, for all `n : ℕ`, the relation `(χ(-1) * #R) ^ (p^n/2) = χ(p^n)`,
where `p` is the (odd) characteristic of the target ring `R'`.
This version can be used when `R` is not a field, e.g., `ℤ/8ℤ`. -/
theorem Char.card_pow_char_pow {χ : MulChar R R'} (hχ : IsQuadratic χ) (ψ : AddChar R R') (p n : ℕ)
    [fp : Fact p.Prime] [hch : CharP R' p] (hp : IsUnit (p : R)) (hp' : p ≠ 2)
    (hg : gaussSum χ ψ ^ 2 = χ (-1) * Fintype.card R) :
    (χ (-1) * Fintype.card R) ^ (p ^ n / 2) = χ ((p : R) ^ n)
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@[simp]
theorem coe_bot : ((⊥ : NonUnitalStarSubalgebra R A) : Set A) = {0}
-- Mathlib/AlgebraicGeometry/OpenImmersion.lean
@[reassoc (attr := simp), elementwise (attr := simp)]
theorem appIso_inv_app (U) :
    (f.appIso U).inv ≫ f.app (f ''ᵁ U) = X.presheaf.map (eqToHom (preimage_image_eq f U)).op
-- Mathlib/Algebra/Module/Submodule/Equiv.lean
@[simp]
protected theorem range : LinearMap.range (e : M →ₛₗ[σ₁₂] M₂) = ⊤
-- .lake/packages/batteries/Batteries/Data/Sum/Basic.lean
@[simp] theorem getRight?_inl : (inl x : α ⊕ β).getRight? = none
-- Mathlib/Algebra/Polynomial/Module/AEval.lean
@[simp] lemma comapSubmodule_le_comap :
    comapSubmodule R M a q ≤ (comapSubmodule R M a q).comap (Algebra.lsmul R R M a)
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
theorem logb_eq_iff_rpow_eq (hy : 0 < y) : logb b y = x ↔ b ^ x = y
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
@[simp]
theorem sub_apply (m : ι → M) : (g - g₂) m = g m - g₂ m
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Basic.lean
/-- This is the key lemma on the way to establishing spectral permanence for C⋆-algebras, which is
established in `StarSubalgebra.spectrum_eq`. This lemma is superseded by
`StarSubalgebra.coe_isUnit`, which does not require an `IsStarNormal` hypothesis and holds for
any closed star subalgebra. -/
theorem elementalStarAlgebra.isUnit_of_isUnit_of_isStarNormal (h : IsUnit a) :
    IsUnit (⟨a, self_mem ℂ a⟩ : elementalStarAlgebra ℂ a)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem bsup_succ_eq_blsub {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
    succ (bsup.{_, v} o f) = blsub.{_, v} o f ↔ ∃ i hi, f i hi = bsup.{_, v} o f
-- Mathlib/Analysis/Convex/Combination.lean
theorem convexHull_sum {ι} (s : Finset ι) (t : ι → Set E) :
    convexHull R (∑ i ∈ s, t i) = ∑ i ∈ s, convexHull R (t i)
-- Mathlib/Data/List/Infix.lean
theorem get_tails (l : List α) (n : Fin (length (tails l))) : (tails l).get n = l.drop n
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
theorem withDensity_indicator {s : Set α} (hs : MeasurableSet s) (f : α → ℝ≥0∞) :
    μ.withDensity (s.indicator f) = (μ.restrict s).withDensity f
-- Mathlib/FieldTheory/Adjoin.lean
@[simp] protected
theorem finrank_bot : finrank F (⊥ : IntermediateField F E) = 1
-- Mathlib/Data/Real/ConjExponents.lean
theorem div_conj_eq_sub_one : p / q = p - 1
-- Mathlib/Algebra/Polynomial/Lifts.lean
theorem monomial_mem_lifts_and_degree_eq {s : S} {n : ℕ} (hl : monomial n s ∈ lifts f) :
    ∃ q : R[X], map f q = monomial n s ∧ q.degree = (monomial n s).degree
-- Mathlib/RingTheory/FractionalIdeal/Norm.lean
theorem absNorm_div_norm_eq_absNorm_div_norm {I : FractionalIdeal R⁰ K} (a : R⁰) (I₀ : Ideal R)
    (h : a • (I : Submodule R K) = Submodule.map (Algebra.linearMap R K) I₀) :
    (Ideal.absNorm I.num : ℚ) / |Algebra.norm ℤ (I.den : R)| =
      (Ideal.absNorm I₀ : ℚ) / |Algebra.norm ℤ (a : R)|
-- Mathlib/Computability/EpsilonNFA.lean
@[simp]
theorem εClosure_empty : M.εClosure ∅ = ∅
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem abs_sin_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) :
    |sin θ| = |sin ψ|
-- Mathlib/RingTheory/PowerSeries/Basic.lean
theorem coeff_monomial (m n : ℕ) (a : R) : coeff R m (monomial R n a) = if m = n then a else 0
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
/-- The angle at a point does not depend on the order of the other two
points. -/
nonrec theorem angle_comm (p1 p2 p3 : P) : ∠ p1 p2 p3 = ∠ p3 p2 p1
-- Mathlib/Order/Filter/Basic.lean
theorem eventuallyEq_empty {s : Set α} {l : Filter α} : s =ᶠ[l] (∅ : Set α) ↔ ∀ᶠ x in l, x ∉ s
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
@[to_additive]
theorem lintegral_eq_tsum' (h : IsFundamentalDomain G s μ) (f : α → ℝ≥0∞) :
    ∫⁻ x, f x ∂μ = ∑' g : G, ∫⁻ x in s, f (g⁻¹ • x) ∂μ
-- Mathlib/Order/BooleanAlgebra.lean
@[simp]
theorem inf_sdiff_self_right : x ⊓ y \ x = ⊥
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
theorem SameCycle.exists_pow_eq [DecidableEq α] [Fintype α] (f : Perm α) (h : SameCycle f x y) :
    ∃ i : ℕ, 0 < i ∧ i ≤ (f.cycleOf x).support.card + 1 ∧ (f ^ i) x = y
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem fract_fract (a : α) : fract (fract a) = fract a
-- Mathlib/Data/Set/Pairwise/Lattice.lean
theorem pairwiseDisjoint_sUnion {s : Set (Set ι)} (h : DirectedOn (· ⊆ ·) s) :
    (⋃₀ s).PairwiseDisjoint f ↔ ∀ ⦃a⦄, a ∈ s → Set.PairwiseDisjoint a f
-- Mathlib/Data/Nat/Choose/Basic.lean
/-- Show that `Nat.choose` is increasing for small values of the right argument. -/
theorem choose_le_succ_of_lt_half_left {r n : ℕ} (h : r < n / 2) :
    choose n r ≤ choose n (r + 1)
-- Mathlib/Probability/ProbabilityMassFunction/Constructions.lean
theorem monad_map_eq_map {α β : Type u} (f : α → β) (p : PMF α) : f <$> p = p.map f
-- Mathlib/Data/Set/Finite.lean
theorem Finite.sInter {α : Type*} {s : Set (Set α)} {t : Set α} (ht : t ∈ s) (hf : t.Finite) :
    (⋂₀ s).Finite
-- Mathlib/MeasureTheory/Measure/Haar/Quotient.lean
/-- Given a normal subgroup `Γ` of a topological group `G` with Haar measure `μ`, which is also
  right-invariant, and a finite volume fundamental domain `𝓕`, the quotient map to `G ⧸ Γ`,
  properly normalized, satisfies `QuotientMeasureEqMeasurePreimage`. -/
@[to_additive "Given a
normal subgroup `Γ` of an additive topological group `G` with Haar measure `μ`, which is also
right-invariant, and a finite volume fundamental domain `𝓕`, the quotient map to `G ⧸ Γ`,
properly normalized, satisfies `AddQuotientMeasureEqMeasurePreimage`."]
theorem IsFundamentalDomain.QuotientMeasureEqMeasurePreimage_smulHaarMeasure {𝓕 : Set G}
    (h𝓕 : IsFundamentalDomain Γ.op 𝓕 ν) (h𝓕_finite : ν 𝓕 ≠ ⊤) :
    QuotientMeasureEqMeasurePreimage ν
      ((ν ((π ⁻¹' (K : Set (G ⧸ Γ))) ∩ 𝓕)) • haarMeasure K)
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
theorem mem_cycleFactorsFinset_iff {f p : Perm α} :
    p ∈ cycleFactorsFinset f ↔ p.IsCycle ∧ ∀ a ∈ p.support, p a = f a
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_add_le_of_le (hp : natDegree p ≤ m) (hq : natDegree q ≤ n) :
    natDegree (p + q) ≤ max m n
-- Mathlib/Topology/UniformSpace/Basic.lean
@[to_additive]
theorem uniformContinuous_unop [UniformSpace α] : UniformContinuous (unop : αᵐᵒᵖ → α)
-- Mathlib/RingTheory/Coprime/Lemmas.lean
theorem IsCoprime.of_prod_right (H1 : IsCoprime x (∏ i ∈ t, s i)) (i : I) (hit : i ∈ t) :
    IsCoprime x (s i)
-- Mathlib/CategoryTheory/FinCategory/AsType.lean
@[simps (config := .lemmasOnly) id comp]
noncomputable instance categoryAsType : SmallCategory (AsType α)
-- Mathlib/Analysis/Convex/Cone/Closure.lean
@[simp, norm_cast]
theorem coe_closure (K : ConvexCone 𝕜 E) : (K.closure : Set E) = closure K
-- Mathlib/Algebra/Field/Basic.lean
theorem one_div_mul_sub_mul_one_div_eq_one_div_add_one_div (ha : a ≠ 0) (hb : b ≠ 0) :
    1 / a * (b - a) * (1 / b) = 1 / a - 1 / b
-- Mathlib/Algebra/Ring/Ext.lean
theorem ext_iff {inst₁ inst₂ : NonUnitalSemiring R} :
    inst₁ = inst₂ ↔
      (local_hAdd[R, inst₁] = local_hAdd[R, inst₂]) ∧
      (local_hMul[R, inst₁] = local_hMul[R, inst₂])
-- Mathlib/Analysis/RCLike/Basic.lean
theorem div_re_ofReal {z : K} {r : ℝ} : re (z / r) = re z / r
-- Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean
theorem neg_e0_mul_v (m : M) : -(e0 Q * v Q m) = v Q m * e0 Q
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
lemma mul_nonpos_iff_pos_imp_nonpos [PosMulStrictMono α] [MulPosStrictMono α]
    [CovariantClass α α (· + ·) (· ≤ ·)] [ContravariantClass α α (· + ·) (· ≤ ·)] :
    a * b ≤ 0 ↔ (0 < a → b ≤ 0) ∧ (b < 0 → 0 ≤ a)
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
lemma tendstoLocallyUniformly_iff_forall_isCompact [LocallyCompactSpace α]  :
    TendstoLocallyUniformly F f p ↔ ∀ K : Set α, IsCompact K → TendstoUniformlyOn F f p K
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
theorem mem_oneCocycles_of_addMonoidHom [A.IsTrivial] (f : Additive G →+ A) :
    f ∘ Additive.ofMul ∈ oneCocycles A
-- Mathlib/Algebra/CharP/Defs.lean
@[simp]
lemma eq_zero [CharZero R] : ringChar R = 0
-- Mathlib/Analysis/Complex/UnitDisc/Basic.lean
theorem abs_ne_one (z : 𝔻) : abs (z : ℂ) ≠ 1
-- Mathlib/CategoryTheory/LiftingProperties/Basic.lean
theorem iff_of_arrow_iso_left {A B A' B' X Y : C} {i : A ⟶ B} {i' : A' ⟶ B'}
    (e : Arrow.mk i ≅ Arrow.mk i') (p : X ⟶ Y) :
    HasLiftingProperty i p ↔ HasLiftingProperty i' p
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
/-- The `map` function preserves the order invariants if `f` is monotone. -/
protected theorem Ordered.map (f : α → β) [IsMonotone cmpα cmpβ f] :
    ∀ {t : RBNode α}, t.Ordered cmpα → (t.map f).Ordered cmpβ
-- Mathlib/CategoryTheory/Monad/Adjunction.lean
/-- For a pair of functors `L : C ⥤ D`, `R : D ⥤ C`, an adjunction `h : L ⊣ R` induces a monad on
the category `C`.
-/
-- Porting note: Specifying simps projections manually to match mathlib3 behavior.
@[simps! coe η μ]
def toMonad (h : L ⊣ R) : Monad C
-- Mathlib/Analysis/NormedSpace/OperatorNorm/NNNorm.lean
theorem exists_mul_lt_of_lt_opNorm (f : E →SL[σ₁₂] F) {r : ℝ} (hr₀ : 0 ≤ r) (hr : r < ‖f‖) :
    ∃ x, r * ‖x‖ < ‖f x‖
-- Mathlib/Data/Real/Sqrt.lean
@[simp]
theorem sqrt_eq_zero (h : 0 ≤ x) : √x = 0 ↔ x = 0
-- Mathlib/Topology/Homotopy/Product.lean
/-- Lemmas showing projection is the inverse of pi. -/
@[simp]
theorem proj_pi (i : ι) (paths : ∀ i, Path.Homotopic.Quotient (as i) (bs i)) :
    proj i (pi paths) = paths i
-- Mathlib/Deprecated/Subgroup.lean
@[to_additive]
theorem closure_subset_iff {s t : Set G} (ht : IsSubgroup t) : closure s ⊆ t ↔ s ⊆ t
-- Mathlib/LinearAlgebra/Lagrange.lean
theorem interpolate_eq_sum_interpolate_insert_sdiff (hvt : Set.InjOn v t) (hs : s.Nonempty)
    (hst : s ⊆ t) :
    interpolate t v r = ∑ i ∈ s, interpolate (insert i (t \ s)) v r * Lagrange.basis s v i
-- Mathlib/Algebra/Module/LocalizedModule.lean
lemma LocalizedModule.subsingleton_iff_ker_eq_top {S : Submonoid R} :
    Subsingleton (LocalizedModule S M) ↔
      LinearMap.ker (LocalizedModule.mkLinearMap S M) = ⊤
-- Mathlib/Data/Set/Basic.lean
theorem eq_or_mem_of_mem_insert {x a : α} {s : Set α} : x ∈ insert a s → x = a ∨ x ∈ s
-- Mathlib/Algebra/AlgebraicCard.lean
@[simp]
protected theorem countable : Set.Countable { x : A | IsAlgebraic R x }
-- Mathlib/Order/SuccPred/Basic.lean
theorem covBy_succ (a : α) : a ⋖ succ a
-- .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean
@[simp] theorem getElem_enum (i) (h : i < (enum n).size) : (enum n)[i] = ⟨i, size_enum n ▸ h⟩
-- Mathlib/Combinatorics/SimpleGraph/Matching.lean
theorem isPerfectMatching_iff_forall_degree [∀ v, Fintype (M.neighborSet v)] :
    M.IsPerfectMatching ↔ ∀ v, M.degree v = 1
-- Mathlib/Combinatorics/SimpleGraph/Hamiltonian.lean
/-- The length of a hamiltonian cycle is the number of vertices. -/
lemma IsHamiltonianCycle.length_eq (hp : p.IsHamiltonianCycle) :
    p.length = Fintype.card α
-- Mathlib/Topology/MetricSpace/Isometry.lean
theorem completeSpace_iff (e : α ≃ᵢ β) : CompleteSpace α ↔ CompleteSpace β
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
theorem infDist_inter_closedBall_of_mem (h : y ∈ s) :
    infDist x (s ∩ closedBall x (dist y x)) = infDist x s
-- Mathlib/Topology/Instances/AddCircle.lean
@[simp] lemma toAddCircle_eq_zero {j : ZMod N} : toAddCircle j = 0 ↔ j = 0
-- Mathlib/Topology/Connected/PathConnected.lean
theorem pathConnectedSpace_iff_eq : PathConnectedSpace X ↔ ∃ x : X, pathComponent x = univ
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp]
theorem inl_add [Add R] [AddZeroClass M] (r₁ r₂ : R) :
    (inl (r₁ + r₂) : tsze R M) = inl r₁ + inl r₂
-- Mathlib/RingTheory/IntegralClosure/Algebra/Defs.lean
lemma Algebra.isIntegral_def : Algebra.IsIntegral R A ↔ ∀ x : A, IsIntegral R x
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
theorem smoothOn_id : SmoothOn I I (id : M → M) s
-- Mathlib/Order/Hom/Lattice.lean
lemma fst_apply (x : α × β) : fst x = x.fst
-- Mathlib/GroupTheory/Coxeter/Inversion.lean
theorem getD_rightInvSeq_mul_self (ω : List B) (j : ℕ) :
    ((ris ω).getD j 1) * ((ris ω).getD j 1) = 1
-- Mathlib/Algebra/BigOperators/Finprod.lean
@[to_additive]
theorem finprod_mem_def (s : Set α) (f : α → M) : ∏ᶠ a ∈ s, f a = ∏ᶠ a, mulIndicator s f a
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
theorem HasLineDerivAt.of_comp {v : E'} (hf : HasLineDerivAt 𝕜 (f ∘ L) f' x v) :
    HasLineDerivAt 𝕜 f f' (L x) (L v)
-- Mathlib/Algebra/Order/Antidiag/Finsupp.lean
lemma mem_finsuppAntidiag' :
    f ∈ finsuppAntidiag s n ↔ f.sum (fun _ x ↦ x) = n ∧ f.support ⊆ s
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToFun_const [IsFiniteMeasure μ] (hT : DominatedFinMeasAdditive μ T C) (x : E) :
    (setToFun μ T hT fun _ => x) = T univ x
-- Mathlib/Analysis/Seminorm.lean
@[simp, norm_cast]
theorem coe_lt_coe {p q : Seminorm 𝕜 E} : (p : E → ℝ) < q ↔ p < q
-- Mathlib/Analysis/Convex/Integral.lean
/-- If `μ` is a non-zero finite measure on `α`, `s` is a convex set in `E`, and `f` is an integrable
function sending `μ`-a.e. points to `s`, then the average value of `f` belongs to `closure s`:
`⨍ x, f x ∂μ ∈ s`. See also `Convex.centerMass_mem` for a finite sum version of this lemma. -/
theorem Convex.set_average_mem_closure (hs : Convex ℝ s) (h0 : μ t ≠ 0) (ht : μ t ≠ ∞)
    (hfs : ∀ᵐ x ∂μ.restrict t, f x ∈ s) (hfi : IntegrableOn f t μ) :
    (⨍ x in t, f x ∂μ) ∈ closure s
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
theorem bounds_bddBelow {f : ContinuousMultilinearMap 𝕜 E G} :
    BddBelow { c | 0 ≤ c ∧ ∀ m, ‖f m‖ ≤ c * ∏ i, ‖m i‖ }
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[reassoc (attr := simp, nolint simpNF)]
theorem biproduct.eqToHom_comp_ι (f : J → C) [HasBiproduct f] {j j' : J} (w : j = j') :
    eqToHom (by simp [w]) ≫ biproduct.ι f j' = biproduct.ι f j
-- Mathlib/Algebra/MvPolynomial/Equiv.lean
/-- The ring isomorphism between multivariable polynomials in a single variable and
polynomials over the ground ring.
-/
@[simps]
def pUnitAlgEquiv : MvPolynomial PUnit R ≃ₐ[R] R[X]
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem extract.go₁_cons_addChar (c : Char) (cs : List Char) (b e : Pos) :
    go₁ (c :: cs) 0 (b + c) (e + c) = go₁ cs 0 b e
-- Mathlib/ModelTheory/Substructures.lean
theorem map_comap_eq_of_surjective (S : L.Substructure N) : (S.comap f).map f = S
-- Mathlib/RingTheory/Polynomial/Chebyshev.lean
theorem T_add_one (n : ℤ) : T R (n + 1) = 2 * X * T R n - T R (n - 1)
-- Mathlib/Algebra/Polynomial/Smeval.lean
theorem eval₂_eq_smeval (R : Type*) [Semiring R] {S : Type*} [Semiring S] (f : R →+* S) (p : R[X])
    (x : S) : letI : Module R S := RingHom.toModule f
    p.eval₂ f x = p.smeval x
-- Mathlib/MeasureTheory/Decomposition/SignedHahn.lean
/-- **The Hahn decomposition theorem**: Given a signed measure `s`, there exist
complement measurable sets `i` and `j` such that `i` is positive, `j` is negative. -/
theorem exists_isCompl_positive_negative (s : SignedMeasure α) :
    ∃ i j : Set α, MeasurableSet i ∧ 0 ≤[i] s ∧ MeasurableSet j ∧ s ≤[j] 0 ∧ IsCompl i j
-- Mathlib/LinearAlgebra/BilinearMap.lean
theorem domRestrict₂_apply (f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) (q : Submodule S N) (x : M) (y : q) :
    f.domRestrict₂ q x y = f x y
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem blsub_eq_of_brange_eq {o o'} {f : ∀ a < o, Ordinal} {g : ∀ a < o', Ordinal}
    (h : { o | ∃ i hi, f i hi = o } = { o | ∃ i hi, g i hi = o }) :
    blsub.{u, max v w} o f = blsub.{v, max u w} o' g
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
@[simp]
theorem walkingParallelPairOp_one : walkingParallelPairOp.obj one = op zero
-- Mathlib/LinearAlgebra/Dimension/Basic.lean
/-- The same-universe version of `Algebra.lift_rank_le_of_injective_injective`. -/
theorem rank_le_of_injective_injective
    (i : R' →+* R) (j : S →+* S') (hi : Injective i) (hj : Injective j)
    (hc : (j.comp (algebraMap R S)).comp i = algebraMap R' S') :
    Module.rank R S ≤ Module.rank R' S'
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem toFinsupp_mul (a b : R[X]) : (a * b).toFinsupp = a.toFinsupp * b.toFinsupp
-- Mathlib/Analysis/Complex/RealDeriv.lean
theorem HasStrictDerivAt.complexToReal_fderiv' {f : ℂ → E} {x : ℂ} {f' : E}
    (h : HasStrictDerivAt f f' x) :
    HasStrictFDerivAt f (reCLM.smulRight f' + I • imCLM.smulRight f') x
-- Mathlib/LinearAlgebra/CliffordAlgebra/BaseChange.lean
@[simp] theorem toBaseChange_ofBaseChange (Q : QuadraticForm R V) (x : A ⊗[R] CliffordAlgebra Q) :
    toBaseChange A Q (ofBaseChange A Q x) = x
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
theorem FiberBundle.writtenInExtChartAt_trivializationAt_symm {x : TotalSpace F E} {y}
    (hy : y ∈ (extChartAt (IB.prod 𝓘(𝕜, F)) x).target) :
    writtenInExtChartAt (IB.prod 𝓘(𝕜, F)) (IB.prod 𝓘(𝕜, F)) (trivializationAt F E x.proj x)
      (trivializationAt F E x.proj).toPartialHomeomorph.symm y = y
-- Mathlib/GroupTheory/Nilpotent.lean
theorem is_decending_rev_series_of_is_ascending {H : ℕ → Subgroup G} {n : ℕ} (hn : H n = ⊤)
    (hasc : IsAscendingCentralSeries H) : IsDescendingCentralSeries fun m : ℕ => H (n - m)
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIcoDiv_sub' (a b : α) : toIcoDiv hp (a - p) b = toIcoDiv hp a b + 1
-- Mathlib/MeasureTheory/Measure/LevyProkhorovMetric.lean
/-- The topology of the Lévy-Prokhorov metric on probability measures on a separable space
coincides with the topology of convergence in distribution. -/
theorem levyProkhorov_eq_convergenceInDistribution :
    (inferInstance : TopologicalSpace (ProbabilityMeasure Ω))
      = TopologicalSpace.coinduced (LevyProkhorov.toProbabilityMeasure (Ω := Ω)) inferInstance
-- Mathlib/AlgebraicTopology/SimplicialObject.lean
/-- The second part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_succ {n} {i : Fin (n + 1)} : X.σ i ≫ X.δ i.succ = 𝟙 _
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma not_mem_uIcc_of_lt (ha : c < a) (hb : c < b) : c ∉ [[a, b]]
-- Mathlib/Analysis/Normed/Order/UpperLower.lean
theorem IsUpperSet.mem_interior_of_forall_lt (hs : IsUpperSet s) (hx : x ∈ closure s)
    (h : ∀ i, x i < y i) : y ∈ interior s
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, rclike_simps]
theorem re_add_im (z : K) : (re z : K) + im z * I = z
-- Mathlib/CategoryTheory/Limits/Cones.lean
/-- A cone morphism between two cones for the same diagram is a morphism of the cone points which
commutes with the cone legs. -/
structure ConeMorphism (A B : Cone F) where
  /-- A morphism between the two vertex objects of the cones -/
  hom : A.pt ⟶ B.pt
  /-- The triangle consisting of the two natural transformations and `hom` commutes -/
  w : ∀ j : J, hom ≫ B.π.app j = A.π.app j := by aesop_cat
-- Mathlib/CategoryTheory/Monad/Adjunction.lean
/-- For a pair of functors `L : C ⥤ D`, `R : D ⥤ C`, an adjunction `h : L ⊣ R` induces a comonad on
the category `D`.
-/
-- Porting note: Specifying simps projections manually to match mathlib3 behavior.
@[simps coe ε δ]
def toComonad (h : L ⊣ R) : Comonad D
-- Mathlib/Logic/Relation.lean
theorem reflTransGen_of_transitive_reflexive {r' : α → α → Prop} (hr : Reflexive r)
    (ht : Transitive r) (h : ∀ a b, r' a b → r a b) (h' : ReflTransGen r' a b) : r a b
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
@[simp]
theorem ceil_eq_self_of_mem (m : E) (h : m ∈ span ℤ (Set.range b)) : (ceil b m : E) = m
-- Mathlib/RingTheory/Polynomial/Basic.lean
@[simp]
theorem map_restriction {R : Type u} [CommRing R] (p : R[X]) :
    p.restriction.map (algebraMap _ _) = p
-- Mathlib/Logic/Function/Basic.lean
protected theorem Surjective.exists₂ (hf : Surjective f) {p : β → β → Prop} :
    (∃ y₁ y₂, p y₁ y₂) ↔ ∃ x₁ x₂, p (f x₁) (f x₂)
-- Mathlib/Analysis/Normed/Field/InfiniteSum.lean
theorem summable_norm_sum_mul_range_of_summable_norm {f g : ℕ → R} (hf : Summable fun x => ‖f x‖)
    (hg : Summable fun x => ‖g x‖) : Summable fun n => ‖∑ k ∈ range (n + 1), f k * g (n - k)‖
-- Mathlib/Logic/Relation.lean
/-- If a reflexive relation `r : α → α → Prop` holds over `x y : α`,
then it holds whether or not `x ≠ y`. Unlike `Reflexive.ne_imp_iff`, this uses `[IsRefl α r]`. -/
theorem reflexive_ne_imp_iff [IsRefl α r] {x y : α} : x ≠ y → r x y ↔ r x y
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
theorem append_assoc (s₁ s₂ s₃ : String) : (s₁ ++ s₂) ++ s₃ = s₁ ++ (s₂ ++ s₃)
-- Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean
/-- The group homomorphism from `RingAut R` to `RingAut k` where `k`
is the residue field of `R`. -/
@[simps]
def mapAut : RingAut R →* RingAut (LocalRing.ResidueField R)