ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem swap_comm (a : Array α) {i j : Fin a.size} : a.swap i j = a.swap j i
-- Mathlib/Order/Filter/AtTopBot.lean
theorem Tendsto.prod_map_prod_atTop [SemilatticeSup γ] {F : Filter α} {G : Filter β} {f : α → γ}
    {g : β → γ} (hf : Tendsto f F atTop) (hg : Tendsto g G atTop) :
    Tendsto (Prod.map f g) (F ×ˢ G) atTop
-- Mathlib/MeasureTheory/SetAlgebra.lean
/-- An algebra of sets is closed by finite intersections. -/
theorem biInter_mem {ι : Type*} (h𝒜 : IsSetAlgebra 𝒜) {s : ι → Set α} (S : Finset ι)
    (hs : ∀ i ∈ S, s i ∈ 𝒜) : ⋂ i ∈ S, s i ∈ 𝒜
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
/-- ε-characterization of the closure in pseudometric spaces-/
theorem mem_closure_iff {s : Set α} {a : α} : a ∈ closure s ↔ ∀ ε > 0, ∃ b ∈ s, dist a b < ε
-- Mathlib/CategoryTheory/Monoidal/Internal/FunctorCategory.lean
/-- Functor translating a comonoid object in a functor category
to a functor into the category of comonoid objects.
-/
@[simps]
def functor : Comon_ (C ⥤ D) ⥤ C ⥤ Comon_ D
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma SMulPosReflectLE.toSMulPosStrictMono [SMulPosReflectLE α β] : SMulPosStrictMono α β
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
@[simp]
theorem algebraMap_eq : algebraMap R R[X] = C
-- Mathlib/MeasureTheory/Function/UnifTight.lean
protected theorem add (hf : UnifTight f p μ) (hg : UnifTight g p μ)
    (hf_meas : ∀ i, AEStronglyMeasurable (f i) μ) (hg_meas : ∀ i, AEStronglyMeasurable (g i) μ) :
    UnifTight (f + g) p μ
-- Mathlib/Algebra/Module/LocalizedModule.lean
theorem mk'_smul (r : R) (m : M) (s : S) : mk' f (r • m) s = r • mk' f m s
-- Mathlib/Data/Set/Sups.lean
lemma sep_infs_le (s t : Set α) (a : α) :
    {b ∈ s ⊼ t | a ≤ b} = {b ∈ s | a ≤ b} ⊼ {b ∈ t | a ≤ b}
-- Mathlib/Data/Finset/Grade.lean
@[simp] lemma erase_wcovBy (s : Finset α) (a : α) : s.erase a ⩿ s
-- Mathlib/Data/Nat/Defs.lean
lemma add_eq_max_iff : m + n = max m n ↔ m = 0 ∨ n = 0
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem map_const (l : List α) (b : β) : map (Function.const α b) l = replicate l.length b
-- Mathlib/Order/Max.lean
@[simp]
theorem not_isMax_iff : ¬IsMax a ↔ ∃ b, a < b
-- Mathlib/Algebra/Polynomial/Splits.lean
theorem splits_of_comp (j : L →+* F) {f : K[X]} (h : Splits (j.comp i) f)
    (roots_mem_range : ∀ a ∈ (f.map (j.comp i)).roots, a ∈ j.range) : Splits i f
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem boundedBy_measure (μ : Measure α) : OuterMeasure.boundedBy μ = μ.toOuterMeasure
-- Mathlib/Topology/Maps/Proper/Basic.lean
/-- If `Y` is Hausdorff and compactly generated, then proper maps `X → Y` are exactly
continuous maps such that the preimage of any compact set is compact.

This result should be the only one needed to link the definition of a proper map and
the criteria "preimage of compact sets are compact", but the notion of compactly generated space
is not yet in Mathlib (TODO) so we use it as an intermediate result to prove
`WeaklyLocallyCompactSpace.isProperMap_iff_isCompact_preimage` and
`SequentialSpace.isProperMap_iff_isCompact_preimage`. In the future those should be inferred
by typeclass inference. -/
theorem isProperMap_iff_isCompact_preimage [T2Space Y]
    (compactlyGenerated : ∀ s : Set Y, IsClosed s ↔ ∀ ⦃K⦄, IsCompact K → IsClosed (s ∩ K)) :
    IsProperMap f ↔ Continuous f ∧ ∀ ⦃K⦄, IsCompact K → IsCompact (f ⁻¹' K)
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive const_sub]
theorem Filter.Tendsto.const_div' (b : G) {c : G} {f : α → G} {l : Filter α}
    (h : Tendsto f l (𝓝 c)) : Tendsto (fun k : α => b / f k) l (𝓝 (b / c))
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem map_iSup {ι : Sort*} (f : R →+* S) (s : ι → Subsemiring R) :
    (iSup s).map f = ⨆ i, (s i).map f
-- Mathlib/FieldTheory/Adjoin.lean
theorem _root_.AlgHom.fieldRange_eq_map (f : E →ₐ[F] K) :
    f.fieldRange = IntermediateField.map f ⊤
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
lemma rpow_natCast_mul (hx : 0 ≤ x) (n : ℕ) (z : ℝ) : x ^ (n * z) = (x ^ n) ^ z
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
theorem isHomogeneous_one : IsHomogeneous (1 : MvPolynomial σ R) 0
-- Mathlib/CategoryTheory/Monad/Products.lean
/-- `X ⨯ -` has a comonad structure. This is sometimes called the writer comonad. -/
@[simps!]
def prodComonad : Comonad C
-- Mathlib/CategoryTheory/CatCommSq.lean
lemma vInv_vInv (h : CatCommSq T L.functor R.functor B) :
    vInv B L.symm R.symm T (vInv T L R B h) = h
-- Mathlib/Algebra/Group/Opposite.lean
@[to_additive]
theorem _root_.SemiconjBy.unop [Mul α] {a x y : αᵐᵒᵖ} (h : SemiconjBy a x y) :
    SemiconjBy (unop a) (unop y) (unop x)
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem Prod.eta (p : α × β) : (p.1, p.2) = p
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
theorem mem_twoCocycles_iff (f : G × G → A) :
    f ∈ twoCocycles A ↔ ∀ g h j : G,
      f (g * h, j) + f (g, h) =
        A.ρ g (f (h, j)) + f (g, h * j)
-- Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
/-- A non zero weighted homogeneous polynomial of weighted degree `n` has weighted total degree
  `n`. -/
theorem weighted_total_degree [SemilatticeSup M] {w : σ → M} (hφ : IsWeightedHomogeneous w φ n)
    (h : φ ≠ 0) : weightedTotalDegree' w φ = n
-- Mathlib/Topology/Support.lean
theorem HasCompactSupport.mul_right (hf : HasCompactSupport f) : HasCompactSupport (f * f')
-- Mathlib/Topology/Homeomorph.lean
/-- A subset of a topological space is homeomorphic to its image under a homeomorphism.
-/
@[simps!]
def image (e : X ≃ₜ Y) (s : Set X) : s ≃ₜ e '' s
-- Mathlib/Data/Real/Sign.lean
theorem sign_of_neg {r : ℝ} (hr : r < 0) : sign r = -1
-- Mathlib/CategoryTheory/Limits/Shapes/KernelPair.lean
theorem isIso_of_mono (h : IsKernelPair f a b) [Mono f] : IsIso a
-- Mathlib/GroupTheory/PresentedGroup.lean
@[ext]
theorem ext {φ ψ : PresentedGroup rels →* G} (hx : ∀ (x : α), φ (.of x) = ψ (.of x)) : φ = ψ
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem ediv_eq_zero_of_lt {a b : Int} (H1 : 0 ≤ a) (H2 : a < b) : a / b = 0
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
/-- Equation theorem for `Int.sub` when both arguments are `Int.ofNat` -/
private theorem Int.ofNat_sub_ofNat_of_lt {n m : Nat} (hlt : n < m) :
    (n : Int) - (m : Int) = -(↑(m - 1 - n) + 1)
-- Mathlib/Topology/Order/Hom/Esakia.lean
@[simp]
theorem comp_id (f : PseudoEpimorphism α β) : f.comp (PseudoEpimorphism.id α) = f
-- Mathlib/RingTheory/Bialgebra/Equiv.lean
@[simp]
theorem symm_toCoalgEquiv (e : A ≃ₐc[R] B) :
    e.symm = (e : A ≃ₗc[R] B).symm
-- Mathlib/Algebra/NeZero.lean
/-- A type-class version of `n ≠ 0`.  -/
class NeZero (n : R) : Prop where
  /-- The proposition that `n` is not zero. -/
  out : n ≠ 0
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- One subspace is not less than or equal to another if and only if it has a point not in the
second subspace. -/
theorem not_le_iff_exists (s1 s2 : AffineSubspace k P) : ¬s1 ≤ s2 ↔ ∃ p ∈ s1, p ∉ s2
-- Mathlib/Order/SemiconjSup.lean
theorem comp_orderIso [Preorder α] [Preorder β] [Preorder γ] {f : α → β} {g : β → α}
    (h : IsOrderRightAdjoint f g) (e : γ ≃o α) : IsOrderRightAdjoint (f ∘ e) (e.symm ∘ g)
-- Mathlib/LinearAlgebra/Dimension/LinearMap.lean
theorem rank_add_le (f g : V →ₗ[K] V') : rank (f + g) ≤ rank f + rank g
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
lemma cycles_ext_iff {A : C} (f₁ f₂ : A ⟶ S.cycles) :
    f₁ = f₂ ↔ f₁ ≫ S.iCycles = f₂ ≫ S.iCycles
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem ordConnected_setOf_ball_subset (x : α) (s : Set α) : OrdConnected { r | ball x r ⊆ s }
-- Mathlib/CategoryTheory/Category/Quiv.lean
/-- The functor sending each quiver to its path category. -/
@[simps]
def free : Quiv.{v, u} ⥤ Cat.{max u v, u}
-- Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean
@[simp]
theorem volume_Ioc {a b : ℝ} : volume (Ioc a b) = ofReal (b - a)
-- Mathlib/Data/Set/Finite.lean
theorem infinite_univ_iff : (@univ α).Infinite ↔ Infinite α
-- Mathlib/AlgebraicGeometry/Morphisms/QuasiCompact.lean
theorem exists_pow_mul_eq_zero_of_res_basicOpen_eq_zero_of_isAffineOpen (X : Scheme)
    {U : X.Opens} (hU : IsAffineOpen U) (x f : Γ(X, U))
    (H : x |_ X.basicOpen f = 0) : ∃ n : ℕ, f ^ n * x = 0
-- Mathlib/Topology/Semicontinuous.lean
theorem lowerSemicontinuousAt_sum {f : ι → α → γ} {a : Finset ι}
    (ha : ∀ i ∈ a, LowerSemicontinuousAt (f i) x) :
    LowerSemicontinuousAt (fun z => ∑ i ∈ a, f i z) x
-- Mathlib/Order/Lattice.lean
theorem SemilatticeInf.ext_inf {α} {A B : SemilatticeInf α}
    (H : ∀ x y : α, (haveI := A; x ≤ y) ↔ x ≤ y)
    (x y : α) :
    (haveI := A; x ⊓ y) = x ⊓ y
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
theorem _root_.Set.Finite.nullMeasurableSet_sInter {s : Set (Set α)} (hs : s.Finite)
    (h : ∀ t ∈ s, NullMeasurableSet t μ) : NullMeasurableSet (⋂₀ s) μ
-- Mathlib/Topology/MetricSpace/Antilipschitz.lean
/-- The preimage of a proper space under a Lipschitz homeomorphism is proper. -/
protected theorem LipschitzWith.properSpace [PseudoMetricSpace α] [MetricSpace β] [ProperSpace β]
    {K : ℝ≥0} {f : α ≃ₜ β} (hK : LipschitzWith K f) : ProperSpace α
-- Mathlib/Tactic/CC/Lemmas.lean
theorem not_eq_of_eq_false {a : Prop} (h : a = False) : Not a = True
-- Mathlib/Geometry/Manifold/VectorBundle/Hom.lean
theorem contMDiffAt_hom_bundle (f : M → LE₁E₂) {x₀ : M} {n : ℕ∞} :
    ContMDiffAt IM (IB.prod 𝓘(𝕜, F₁ →L[𝕜] F₂)) n f x₀ ↔
      ContMDiffAt IM IB n (fun x => (f x).1) x₀ ∧
        ContMDiffAt IM 𝓘(𝕜, F₁ →L[𝕜] F₂) n
          (fun x => inCoordinates F₁ E₁ F₂ E₂ (f x₀).1 (f x).1 (f x₀).1 (f x).1 (f x).2) x₀
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem SmoothOn.contMDiffOn (h : SmoothOn I I' f s) : ContMDiffOn I I' n f s
-- Mathlib/Logic/Function/Basic.lean
theorem sometimes_spec {p : Prop} {α} [Nonempty α] (P : α → Prop) (f : p → α) (a : p)
    (h : P (f a)) : P (sometimes f)
-- Mathlib/LinearAlgebra/AffineSpace/ContinuousAffineEquiv.lean
@[simp]
theorem symm_refl : (refl k P₁).symm = refl k P₁
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
@[to_additive]
theorem inv_toGerm (f : α →ₘ[μ] γ) : f⁻¹.toGerm = f.toGerm⁻¹
-- Mathlib/Analysis/Convex/Topology.lean
/-- If `x ∈ closure s` and `x + y ∈ interior s`, then `x + t y ∈ interior s` for `t ∈ (0, 1]`. -/
theorem Convex.add_smul_mem_interior' {s : Set E} (hs : Convex 𝕜 s) {x y : E} (hx : x ∈ closure s)
    (hy : x + y ∈ interior s) {t : 𝕜} (ht : t ∈ Ioc (0 : 𝕜) 1) : x + t • y ∈ interior s
-- Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean
lemma compProd_toKernel [IsFiniteKernel κ] [IsSFiniteKernel ν] (hf : IsCondKernelCDF f κ ν) :
    ν ⊗ₖ hf.toKernel f = κ
-- Mathlib/NumberTheory/Harmonic/ZetaAsymp.lean
lemma tendsto_Gamma_term_aux : Tendsto (fun s ↦ 1 / (s - 1) - 1 / Gammaℝ s / (s - 1)) (𝓝[≠] 1)
    (𝓝 (-(γ + Complex.log (4 * ↑π)) / 2))
-- Mathlib/Algebra/BigOperators/Group/List.lean
@[to_additive]
theorem map_list_prod {F : Type*} [FunLike F M N] [MonoidHomClass F M N] (f : F) (l : List M) :
    f l.prod = (l.map f).prod
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
/-- The equivalence between the nonsingular rational points on a Weierstrass curve `W` in Jacobian
coordinates with the nonsingular rational points on `W` in affine coordinates. -/
@[simps]
noncomputable def toAffineAddEquiv : W.Point ≃+ W.toAffine.Point
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem sumAddHom_comp_single [∀ i, AddZeroClass (β i)] [AddCommMonoid γ] (f : ∀ i, β i →+ γ)
    (i : ι) : (sumAddHom f).comp (singleAddHom β i) = f i
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem and_not_self : ¬(a ∧ ¬a)
-- Mathlib/Topology/Instances/Real.lean
theorem Real.mem_closure_iff {s : Set ℝ} {x : ℝ} :
    x ∈ closure s ↔ ∀ ε > 0, ∃ y ∈ s, |y - x| < ε
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem mod_zero (a : Ordinal) : a % 0 = a
-- Mathlib/Data/Vector/Basic.lean
@[simp] theorem length_val (v : Vector α n) : v.val.length = n
-- Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean
lemma inv_rnDeriv [SigmaFinite μ] [SigmaFinite ν] (hμν : μ ≪ ν) :
    (μ.rnDeriv ν)⁻¹ =ᵐ[μ] ν.rnDeriv μ
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sin_int_mul_two_pi_sub (x : ℂ) (n : ℤ) : sin (n * (2 * π) - x) = -sin x
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/Basic.lean
theorem condexp_of_not_sigmaFinite (hm : m ≤ m0) (hμm_not : ¬SigmaFinite (μ.trim hm)) :
    μ[f|m] = 0
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
@[simp]
theorem closedBall_diff_sphere : closedBall x ε \ sphere x ε = ball x ε
-- Mathlib/Order/SuccPred/Limit.lean
theorem IsSuccLimit.succ_lt_iff (hb : IsSuccLimit b) : succ a < b ↔ a < b
-- Mathlib/Order/Interval/Set/OrderIso.lean
@[simp]
theorem image_Ioc (e : α ≃o β) (a b : α) : e '' Ioc a b = Ioc (e a) (e b)
-- Mathlib/CategoryTheory/Subobject/MonoOver.lean
@[simp]
theorem map_obj_arrow (f : X ⟶ Y) [Mono f] (g : MonoOver X) : ((map f).obj g).arrow = g.arrow ≫ f
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem liftAlgHom_apply {L S : Type*} [Field L] [CommSemiring S] [Algebra S K[X]] [Algebra S L]
    (φ : K[X] →ₐ[S] L) (hφ : K[X]⁰ ≤ L⁰.comap φ) (f : RatFunc K) :
    liftAlgHom φ hφ f = φ f.num / φ f.denom
-- Mathlib/Topology/Order.lean
@[simp]
theorem induced_iInf {ι : Sort w} {t : ι → TopologicalSpace α} :
    (⨅ i, t i).induced g = ⨅ i, (t i).induced g
-- Mathlib/CategoryTheory/Monad/Products.lean
/-- The backward direction of the equivalence from coalgebras for the product comonad to the over
category.
-/
@[simps]
def overToCoalgebra : Over X ⥤ Coalgebra (prodComonad X)
-- Mathlib/Algebra/Homology/HomotopyCategory/Triangulated.lean
@[reassoc]
lemma mappingConeCompHomotopyEquiv_comm₁ :
    inr (map f (f ≫ g) (𝟙 X₁) g (by rw [id_comp])) ≫
      (mappingConeCompHomotopyEquiv f g).inv = (mappingConeCompTriangle f g).mor₂
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
theorem prod_dirac (y : β) : μ.prod (dirac y) = map (fun x => (x, y)) μ
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- The inner product between a vector and a multiple of a `π / 2` rotation of that vector is
zero. -/
@[simp]
theorem inner_smul_rotation_pi_div_two_right (x : V) (r : ℝ) :
    ⟪x, r • o.rotation (π / 2 : ℝ) x⟫ = 0
-- Mathlib/Algebra/ContinuedFractions/ConvergentsEquiv.lean
/-- The values before the squashed position stay the same. -/
theorem squashSeq_nth_of_lt {m : ℕ} (m_lt_n : m < n) : (squashSeq s n).get? m = s.get? m
-- Mathlib/Algebra/Associated/Basic.lean
theorem Irreducible.dvd_comm [Monoid α] {p q : α} (hp : Irreducible p) (hq : Irreducible q) :
    p ∣ q ↔ q ∣ p
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem inter_singleton_eq_empty : s ∩ {a} = ∅ ↔ a ∉ s
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Basic.lean
theorem elementalStarAlgebra.bijective_characterSpaceToSpectrum :
    Function.Bijective (elementalStarAlgebra.characterSpaceToSpectrum a)
-- Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean
/-- The real power function with any exponent is not integrable on `(0, +∞)`. -/
theorem not_integrableOn_Ioi_rpow (s : ℝ) : ¬ IntegrableOn (fun x ↦ x ^ s) (Ioi (0 : ℝ))
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
theorem spectralRadius_le_liminf_pow_nnnorm_pow_one_div (a : A) :
    spectralRadius 𝕜 a ≤ atTop.liminf fun n : ℕ => (‖a ^ n‖₊ : ℝ≥0∞) ^ (1 / n : ℝ)
-- Mathlib/Analysis/LocallyConvex/Basic.lean
theorem Balanced.add (hs : Balanced 𝕜 s) (ht : Balanced 𝕜 t) : Balanced 𝕜 (s + t)
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
theorem divInt_mul_divInt (n₁ n₂ : Int) {d₁ d₂} (z₁ : d₁ ≠ 0) (z₂ : d₂ ≠ 0) :
    (n₁ /. d₁) * (n₂ /. d₂) = (n₁ * n₂) /. (d₁ * d₂)
-- Mathlib/Probability/Kernel/Basic.lean
theorem piecewise_apply' (a : α) (t : Set β) :
    piecewise hs κ η a t = if a ∈ s then κ a t else η a t
-- Mathlib/AlgebraicGeometry/Gluing.lean
@[simp]
theorem ι_isoCarrier_inv (i : D.J) :
    (D_).ι i ≫ D.isoCarrier.inv = (D.ι i).1.base
-- Mathlib/Data/PNat/Factors.lean
/-- The gcd and lcm operations on positive integers correspond
 to the inf and sup operations on multisets. -/
theorem factorMultiset_gcd (m n : ℕ+) :
    factorMultiset (gcd m n) = factorMultiset m ⊓ factorMultiset n
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
@[simp] lemma nextCoeffUp_zero : nextCoeffUp (0 : R[X]) = 0
-- Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean
/-- The integral defining the `Γ` function converges for complex `s` with `0 < re s`.

This is proved by reduction to the real case. -/
theorem GammaIntegral_convergent {s : ℂ} (hs : 0 < s.re) :
    IntegrableOn (fun x => (-x).exp * x ^ (s - 1) : ℝ → ℂ) (Ioi 0)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Div.lean
theorem le_div_iff_mul_le (k0 : 0 < k) : x ≤ y / k ↔ x * k ≤ y
-- Mathlib/Topology/Connected/Basic.lean
theorem IsPreconnected.union (x : α) {s t : Set α} (H1 : x ∈ s) (H2 : x ∈ t) (H3 : IsPreconnected s)
    (H4 : IsPreconnected t) : IsPreconnected (s ∪ t)
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem rTensor_zero : rTensor M (0 : N →ₗ[R] P) = 0
-- Mathlib/Data/Finset/Piecewise.lean
lemma update_piecewise [DecidableEq ι] (i : ι) (v : π i) :
    update (s.piecewise f g) i v = s.piecewise (update f i v) (update g i v)
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive const_add]
theorem Monotone.const_mul' [CovariantClass α α (· * ·) (· ≤ ·)] (hf : Monotone f) (a : α) :
    Monotone fun x => a * f x
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addU_of_Z_eq_zero_left {P Q : Fin 3 → F} (hPz : P z = 0) : addU P Q = 0
-- Mathlib/Analysis/Complex/Basic.lean
@[simp]
lemma zero_not_mem_slitPlane : 0 ∉ slitPlane
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem isPrefixOf_length_pos_nil {L : List α} (h : 0 < L.length) : isPrefixOf L [] = false
-- Mathlib/Order/Interval/Finset/Fin.lean
theorem card_fintypeIci : Fintype.card (Set.Ici a) = n - a
-- Mathlib/Topology/Order/Lattice.lean
lemma ContinuousWithinAt.inf' (hf : ContinuousWithinAt f s x) (hg : ContinuousWithinAt g s x) :
    ContinuousWithinAt (f ⊓ g) s x
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@[simp]
lemma _root_.NonUnitalStarAlgHom.map_adjoin_singleton (f : F) (x : A) :
    map f (adjoin R {x}) = adjoin R {f x}
-- Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean
lemma sinKernel_zero (x : ℝ) : sinKernel 0 x = 0
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem closure_univ : closure (Set.univ : Set K) = ⊤
-- Mathlib/Order/GaloisConnection.lean
/-- If there exists an `a` such that `b = l a`, then `a = u b` is one such element. -/
theorem exists_eq_l (b : β) : (∃ a : α, b = l a) ↔ b = l (u b)
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
nonrec theorem HasDerivAt.const_add (c : F) (hf : HasDerivAt f f' x) :
    HasDerivAt (fun x => c + f x) f' x
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem uniformity_comap {_ : UniformSpace β} (f : α → β) :
    𝓤[UniformSpace.comap f ‹_›] = comap (Prod.map f f) (𝓤 β)
-- Mathlib/Analysis/RCLike/Basic.lean
/--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
-- Mathlib/Data/Multiset/Fold.lean
theorem fold_eq_foldl (b : α) (s : Multiset α) :
    fold op b s = foldl op (right_comm _ hc.comm ha.assoc) b s
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem normUnit_X : normUnit (X : Polynomial R) = 1
-- Mathlib/Algebra/Order/Group/Bounds.lean
theorem IsLUB.exists_between_sub_self (h : IsLUB s a) (hε : 0 < ε) : ∃ b ∈ s, a - ε < b ∧ b ≤ a
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem Function.Surjective.lieAlgebra_isNilpotent [h₁ : IsNilpotent R L] {f : L →ₗ⁅R⁆ L'}
    (h₂ : Function.Surjective f) : IsNilpotent R L'
-- Mathlib/Algebra/Order/BigOperators/Ring/List.lean
/-- A variant of `List.prod_pos` for `CanonicallyOrderedCommSemiring`. -/
@[simp] lemma _root_.CanonicallyOrderedCommSemiring.list_prod_pos
    {α : Type*} [CanonicallyOrderedCommSemiring α] [Nontrivial α] :
    ∀ {l : List α}, 0 < l.prod ↔ (∀ x ∈ l, (0 : α) < x)
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem sigmaFinsuppAddEquivPiFinsupp_apply {α : Type*} {ιs : η → Type*} [AddMonoid α]
    (f : (Σj, ιs j) →₀ α) (j i) : sigmaFinsuppAddEquivPiFinsupp f j i = f ⟨j, i⟩
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
/-- The limit cone for the product over an index type with exactly one term. -/
@[simps]
def limitConeOfUnique : LimitCone (Discrete.functor f)
-- Mathlib/Topology/Algebra/Module/Star.lean
/-- If `A` is a topological module over a commutative `R` with compatible actions,
then `star` is a continuous semilinear equivalence. -/
@[simps!]
def starL (R : Type*) {A : Type*} [CommSemiring R] [StarRing R] [AddCommMonoid A]
    [StarAddMonoid A] [Module R A] [StarModule R A] [TopologicalSpace A] [ContinuousStar A] :
    A ≃L⋆[R] A
-- Mathlib/CategoryTheory/Limits/Preserves/Limits.lean
@[reassoc (attr := simp)]
theorem ι_preservesColimitsIso_inv (j : J) :
    colimit.ι _ j ≫ (preservesColimitIso G F).inv = G.map (colimit.ι F j)
-- Mathlib/CategoryTheory/Category/TwoP.lean
@[simp]
theorem TwoP_swap_comp_forget_to_Bipointed :
    TwoP.swap ⋙ forget₂ TwoP Bipointed = forget₂ TwoP Bipointed ⋙ Bipointed.swap
-- Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
theorem left_triangle (X : LocallyRingedSpace) :
    SpecΓIdentity.inv.app (Γ.obj (op X)) ≫ (identityToΓSpec.app X).val.c.app (op ⊤) = 𝟙 _
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.le_basis_iff (hl : l.HasBasis p s) (hl' : l'.HasBasis p' s') :
    l ≤ l' ↔ ∀ i', p' i' → ∃ i, p i ∧ s i ⊆ s' i'
-- Mathlib/Init/Data/Sigma/Lex.lean
theorem skipLeft_wf (α : Type u) {β : Type v} {s : β → β → Prop} (hb : WellFounded s) :
    WellFounded (SkipLeft α s)
-- Mathlib/AlgebraicGeometry/Gluing.lean
theorem glued_cover_cocycle (x y z : 𝒰.J) :
    gluedCoverT' 𝒰 x y z ≫ gluedCoverT' 𝒰 y z x ≫ gluedCoverT' 𝒰 z x y = 𝟙 _
-- Mathlib/Analysis/SpecificLimits/Normed.lean
/-- If `0 ≤ r < 1`, then `n * r ^ n` tends to zero. This is a specialized version of
`tendsto_self_mul_const_pow_of_abs_lt_one`, singled out for ease of application. -/
theorem tendsto_self_mul_const_pow_of_lt_one {r : ℝ} (hr : 0 ≤ r) (h'r : r < 1) :
    Tendsto (fun n ↦ n * r ^ n : ℕ → ℝ) atTop (𝓝 0)
-- Mathlib/CategoryTheory/Simple.lean
theorem Biprod.isIso_inl_iff_isZero (X Y : C) : IsIso (biprod.inl : X ⟶ X ⊞ Y) ↔ IsZero Y
-- Mathlib/CategoryTheory/Category/Bipointed.lean
/-- `BipointedToPointed_snd` is inverse to `PointedToBipointed`. -/
@[simps!]
def pointedToBipointedCompBipointedToPointedSnd :
    pointedToBipointed ⋙ bipointedToPointedSnd ≅ 𝟭 _
-- Mathlib/Order/UpperLower/Basic.lean
@[simp, norm_cast]
theorem coe_inf (s t : UpperSet α) : (↑(s ⊓ t) : Set α) = (s : Set α) ∪ t
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem append_nil {u v : V} (p : G.Walk u v) : p.append nil = p
-- Mathlib/GroupTheory/Nilpotent.lean
@[simp]
theorem upperCentralSeries_one : upperCentralSeries G 1 = center G
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive ContinuousWithinAt.norm]
theorem ContinuousWithinAt.norm' {s : Set α} {a : α} (h : ContinuousWithinAt f s a) :
    ContinuousWithinAt (fun x => ‖f x‖) s a
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
theorem of_hasBinaryProduct [HasBinaryProduct X Y] [HasZeroObject C] [HasZeroMorphisms C] :
    IsPullback Limits.prod.fst Limits.prod.snd (0 : X ⟶ 0) (0 : Y ⟶ 0)