ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Module/Equiv/Basic.lean
@[simp]
theorem coe_toLinearEquiv (h : ∀ (c : R) (x), e (c • x) = c • e x) : ⇑(e.toLinearEquiv h) = e
-- Mathlib/Data/Set/Subsingleton.lean
theorem subsingleton_univ [Subsingleton α] : (univ : Set α).Subsingleton
-- Mathlib/Algebra/Group/Int.lean
lemma isUnit_eq_or_eq_neg (hu : IsUnit u) (hv : IsUnit v) : u = v ∨ u = -v
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
@[simp] theorem ite_false_same (p q : Prop) [h : Decidable p] : (if p then q else p) = (p ∧ q)
-- Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean
theorem measure_eq_inducedOuterMeasure :
    μ s = inducedOuterMeasure (fun s _ => μ s) MeasurableSet.empty μ.empty s
-- Mathlib/Analysis/CstarAlgebra/GelfandDuality.lean
/-- The Gelfand transform is bijective when the algebra is a C⋆-algebra over `ℂ`. -/
theorem gelfandTransform_bijective : Function.Bijective (gelfandTransform ℂ A)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_smul_real_left (x y : E) (r : ℝ) : ⟪(r : 𝕜) • x, y⟫ = r • ⟪x, y⟫
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- The diameter of a union is controlled by the diameter of the sets, and the edistance
between two points in the sets. -/
theorem diam_union {t : Set α} (xs : x ∈ s) (yt : y ∈ t) :
    diam (s ∪ t) ≤ diam s + edist x y + diam t
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIcoMod_sub_self (a b : α) : toIcoMod hp a b - b = -toIcoDiv hp a b • p
-- Mathlib/Algebra/Homology/ImageToKernel.lean
theorem imageToKernel_comp_right {D : V} (h : C ⟶ D) (w : f ≫ g = 0) :
    imageToKernel f (g ≫ h) (by simp [reassoc_of% w]) =
      imageToKernel f g w ≫ Subobject.ofLE _ _ (kernelSubobject_comp_le g h)
-- Mathlib/Order/CompleteBooleanAlgebra.lean
lemma iSup_inf_eq (f : ι → α) (a : α) : (⨆ i, f i) ⊓ a = ⨆ i, f i ⊓ a
-- Mathlib/Data/Nat/Defs.lean
lemma div_dvd_of_dvd (h : n ∣ m) : m / n ∣ m
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean
lemma IsEquipartition.sum_nonUniforms_lt (hA : A.Nonempty) (hε : 0 < ε) (hP : P.IsEquipartition)
    (hG : P.IsUniform G ε) :
    ((P.nonUniforms G ε).biUnion fun (U, V) ↦ U ×ˢ V).card < 4 * ε * A.card ^ 2
-- Mathlib/Combinatorics/Quiver/Basic.lean
@[ext]
theorem ext {V : Type u} [Quiver.{v₁} V] {W : Type u₂} [Quiver.{v₂} W] {F G : Prefunctor V W}
    (h_obj : ∀ X, F.obj X = G.obj X)
    (h_map : ∀ (X Y : V) (f : X ⟶ Y),
      F.map f = Eq.recOn (h_obj Y).symm (Eq.recOn (h_obj X).symm (G.map f))) : F = G
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- If two points belong to some set, their edistance is bounded by the diameter of the set -/
theorem edist_le_diam_of_mem (hx : x ∈ s) (hy : y ∈ s) : edist x y ≤ diam s
-- Mathlib/Data/Set/Lattice.lean
theorem iInter₂_union (s : ∀ i, κ i → Set α) (t : Set α) :
    (⋂ (i) (j), s i j) ∪ t = ⋂ (i) (j), s i j ∪ t
-- Mathlib/Data/Multiset/Basic.lean
theorem filterMap_eq_filter : filterMap (Option.guard p) = filter p
-- Mathlib/Data/Set/Finite.lean
theorem finite_univ_iff : (@univ α).Finite ↔ Finite α
-- Mathlib/CategoryTheory/Adjunction/Basic.lean
/-- Transport being a left adjoint along a natural isomorphism. -/
lemma isLeftAdjoint_of_iso {F G : C ⥤ D} (h : F ≅ G) [IsLeftAdjoint F] :
    IsLeftAdjoint G
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem smul_comp [Monoid S] [DistribMulAction S R] [IsScalarTower S R R] (s : S) (p q : R[X]) :
    (s • p).comp q = s • p.comp q
-- Mathlib/Data/Set/Card.lean
theorem Finite.eq_of_subset_of_encard_le' (hs : s.Finite) (hst : s ⊆ t)
    (hts : t.encard ≤ s.encard) : s = t
-- .lake/packages/batteries/Batteries/Data/List/Pairwise.lean
theorem forall_mem_pwFilter [DecidableRel (α := α) R]
    (neg_trans : ∀ {x y z}, R x z → R x y ∨ R y z) (a : α) (l : List α) :
    (∀ b ∈ pwFilter R l, R a b) ↔ ∀ b ∈ l, R a b
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem HasStrictFDerivAt.multiset_prod [DecidableEq ι] {u : Multiset ι} {x : E}
    (h : ∀ i ∈ u, HasStrictFDerivAt (g i ·) (g' i) x) :
    HasStrictFDerivAt (fun x ↦ (u.map (g · x)).prod)
      (u.map fun i ↦ ((u.erase i).map (g · x)).prod • g' i).sum x
-- Mathlib/Data/Real/Irrational.lean
theorem irrational_sqrt_ratCast_iff_of_nonneg {q : ℚ} (hq : 0 ≤ q) :
    Irrational (√q) ↔ ¬IsSquare q
-- Mathlib/Order/Heyting/Basic.lean
@[gcongr]
theorem compl_le_compl (h : a ≤ b) : bᶜ ≤ aᶜ
-- Mathlib/Analysis/Normed/Group/SemiNormedGrp/Completion.lean
theorem completion.map_normNoninc {V W : SemiNormedGrp} {f : V ⟶ W} (hf : f.NormNoninc) :
    (completion.map f).NormNoninc
-- Mathlib/Algebra/Order/Archimedean.lean
theorem archimedean_iff_rat_lt : Archimedean α ↔ ∀ x : α, ∃ q : ℚ, x < q
-- Mathlib/Order/Heyting/Boundary.lean
theorem boundary_le_boundary_sup_sup_boundary_inf_right : ∂ b ≤ ∂ (a ⊔ b) ⊔ ∂ (a ⊓ b)
-- Mathlib/Topology/MetricSpace/PiNat.lean
theorem dist_summable (x y : ∀ i, F i) :
    Summable fun i : ι => min ((1 / 2) ^ encode i : ℝ) (dist (x i) (y i))
-- Mathlib/Order/Heyting/Basic.lean
theorem sdiff_right_comm (a b c : α) : (a \ b) \ c = (a \ c) \ b
-- Mathlib/CategoryTheory/Types.lean
@[simp]
theorem comp (x : F.obj X) : (σ ≫ τ).app X x = τ.app X (σ.app X x)
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_left_injective {x : ℝ} (hx : x ≠ 0) : Function.Injective fun y : ℝ≥0 => y ^ x
-- Mathlib/Algebra/Order/Hom/Ring.lean
@[simp]
theorem symm_symm (e : α ≃+*o β) : e.symm.symm = e
-- Mathlib/Geometry/Manifold/ContMDiffMap.lean
protected theorem smooth (f : C^∞⟮I, M; I', M'⟯) : Smooth I I' f
-- Mathlib/Data/ZMod/Basic.lean
theorem castHom_injective : Function.Injective (ZMod.castHom (dvd_refl n) R)
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
theorem chartedSpaceSelf_prod : prodChartedSpace H H H' H' = chartedSpaceSelf (H × H')
-- Mathlib/Data/Ordmap/Ordset.lean
@[simp]
theorem merge_node {ls ll lx lr rs rl rx rr} :
    merge (@node α ls ll lx lr) (node rs rl rx rr) =
      if delta * ls < rs then balanceL (merge (node ls ll lx lr) rl) rx rr
      else if delta * rs < ls then balanceR ll lx (merge lr (node rs rl rx rr))
      else glue (node ls ll lx lr) (node rs rl rx rr)
-- .lake/packages/batteries/Batteries/Data/Array/Monadic.lean
theorem size_mapM [Monad m] [LawfulMonad m] (f : α → m β) (as : Array α) :
    SatisfiesM (fun arr => arr.size = as.size) (Array.mapM f as)
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem Ici_prod_Ici (a : α) (b : β) : Iic a ×ˢ Iic b = Iic (a, b)
-- Mathlib/Topology/Bornology/Basic.lean
theorem nonempty_of_not_isBounded (h : ¬IsBounded s) : s.Nonempty
-- Mathlib/RingTheory/Adjoin/Basic.lean
theorem adjoin_algebraMap (s : Set S) :
    adjoin R (algebraMap S A '' s) = (adjoin R s).map (IsScalarTower.toAlgHom R S A)
-- Mathlib/Algebra/Module/Submodule/Pointwise.lean
theorem span_set_smul [SMulCommClass S R M] (s : Set S) (t : Set M) :
    span R (s • t) = s • span R t
-- .lake/packages/batteries/Batteries/Data/AssocList.lean
@[simp] theorem findEntryP?_eq (p : α → β → Bool) (l : AssocList α β) :
    findEntryP? p l = l.toList.find? fun (a, b) => p a b
-- Mathlib/CategoryTheory/Functor/Derived/RightDerived.lean
/-- A functor `RF : D ⥤ H` is a right derived functor of `F : C ⥤ H`
if it is equipped with a natural transformation `α : F ⟶ L ⋙ RF`
which makes it a left Kan extension of `F` along `L`,
where `L : C ⥤ D` is a localization functor for `W : MorphismProperty C`. -/
class IsRightDerivedFunctor [L.IsLocalization W] : Prop where
  isLeftKanExtension' : RF.IsLeftKanExtension α
-- Mathlib/Order/CompleteLattice.lean
theorem le_iSup (f : ι → α) (i : ι) : f i ≤ iSup f
-- Mathlib/NumberTheory/Padics/Hensel.lean
private theorem ncs_tendsto_lim :
    Tendsto (fun i => ‖F.derivative.eval (ncs i)‖) atTop (𝓝 ‖F.derivative.eval ncs.lim‖)
-- Mathlib/LinearAlgebra/TensorPower.lean
/-- Two dependent pairs of tensor products are equal if their index is equal and the contents
are equal after a canonical reindexing. -/
@[ext]
theorem gradedMonoid_eq_of_reindex_cast {ιι : Type*} {ι : ιι → Type*} :
    ∀ {a b : GradedMonoid fun ii => ⨂[R] _ : ι ii, M} (h : a.fst = b.fst),
      reindex R (fun _ ↦ M) (Equiv.cast <| congr_arg ι h) a.snd = b.snd → a = b
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
theorem mem_of_mem_join {a : α} {x : Option (Option α)} (h : a ∈ x.join) : some a ∈ x
-- Mathlib/Order/GaloisConnection.lean
theorem le_u_l (a) : a ≤ u (l a)
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
theorem map_zero : e 0 = 0
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
@[measurability]
theorem measurable_coe_nnreal_real : Measurable ((↑) : ℝ≥0 → ℝ)
-- Mathlib/Algebra/Polynomial/Coeff.lean
@[simp] lemma coeff_mul_intCast [Ring S] {p : S[X]} {a : ℤ} {k : ℕ} :
  coeff (p * (a : S[X])) k = coeff p k * (↑a : S)
-- Mathlib/Analysis/Complex/Basic.lean
@[simp]
theorem conjCLE_apply (z : ℂ) : conjCLE z = conj z
-- Mathlib/RingTheory/Polynomial/Wronskian.lean
/--
`natDegree` version of the above theorem.
Note this would be false with just `(ha : a ≠ 0) (hb : b ≠ 0),
as when `a = b = 1` we have `(wronskian a b).natDegree = a.natDegree = b.natDegree = 0`.
-/
theorem natDegree_wronskian_lt_add {a b : R[X]} (hw : wronskian a b ≠ 0) :
    (wronskian a b).natDegree < a.natDegree + b.natDegree
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
@[simp]
theorem mem_coe {I : FractionalIdeal S P} {x : P} : x ∈ (I : Submodule R P) ↔ x ∈ I
-- Mathlib/Data/Real/Sqrt.lean
theorem sqrt_ne_zero' : √x ≠ 0 ↔ 0 < x
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
theorem equivCongr_symm (e : A₁ ≃ₐ[R] A₂) (e' : A₁' ≃ₐ[R] A₂') :
    (equivCongr e e').symm = equivCongr e.symm e'.symm
-- Mathlib/Order/Hom/Basic.lean
theorem copy_eq (f : α →o β) (f' : α → β) (h : f' = f) : f.copy f' h = f
-- Mathlib/CategoryTheory/Subobject/WellPowered.lean
/-- Being well-powered is preserved by equivalences, as long as the two categories involved have
    their morphisms in the same universe. -/
theorem wellPowered_congr (e : C ≌ D) : WellPowered C ↔ WellPowered D
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
theorem IsVonNBounded.smul_tendsto_zero [NormedField 𝕜]
    [AddCommGroup E] [Module 𝕜 E] [TopologicalSpace E]
    {S : Set E} {ε : ι → 𝕜} {x : ι → E} {l : Filter ι}
    (hS : IsVonNBounded 𝕜 S) (hxS : ∀ᶠ n in l, x n ∈ S) (hε : Tendsto ε l (𝓝 0)) :
    Tendsto (ε • x) l (𝓝 0)
-- Mathlib/FieldTheory/Separable.lean
theorem separable_X_add_C (a : R) : (X + C a).Separable
-- Mathlib/Order/Interval/Finset/Defs.lean
@[simp]
theorem mem_Ioo : x ∈ Ioo a b ↔ a < x ∧ x < b
-- Mathlib/Analysis/Complex/UnitDisc/Basic.lean
theorem one_add_coe_ne_zero (z : 𝔻) : (1 + z : ℂ) ≠ 0
-- Mathlib/Probability/Process/Filtration.lean
/-- A measure is σ-finite with respect to filtration if it is σ-finite with respect
to all the sub-σ-algebra of the filtration. -/
class SigmaFiniteFiltration [Preorder ι] (μ : Measure Ω) (f : Filtration ι m) : Prop where
  SigmaFinite : ∀ i : ι, SigmaFinite (μ.trim (f.le i))
-- Mathlib/LinearAlgebra/QuadraticForm/Prod.lean
/-- `LinearMap.proj` as an isometry, when all but one quadratic form is zero. -/
@[simps!]
def Isometry.proj [Fintype ι] [DecidableEq ι] (i : ι) (Q : QuadraticMap R (Mᵢ i) P) :
    pi (Pi.single i Q) →qᵢ Q
-- Mathlib/Data/Finset/Pointwise.lean
@[simp]
protected theorem neg_smul [DecidableEq α] : -s • t = -(s • t)
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem prev : ∀ {s}, ValidFor l (m₁ ++ c :: m₂) r s →
    s.prev ⟨utf8Len m₁ + c.utf8Size⟩ = ⟨utf8Len m₁⟩
-- Mathlib/Order/Disjoint.lean
theorem ofDual {a b : αᵒᵈ} (h : IsCompl a b) : IsCompl (ofDual a) (ofDual b)
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[simp]
theorem eqToHom_whiskerRight {X Y : C} (f : X = Y) (Z : C) :
    eqToHom f ▷ Z = eqToHom (congr_arg₂ tensorObj f rfl)
-- Mathlib/Logic/Embedding/Basic.lean
/-- Fixing an element `a : α` gives an embedding `β ↪ α × β`. -/
@[simps]
def sectr {α : Sort _} (a : α) (β : Sort _) : β ↪ α × β
-- Mathlib/Algebra/Homology/Localization.lean
lemma ComplexShape.QFactorsThroughHomotopy_of_exists_prev [CategoryWithHomology C] :
    c.QFactorsThroughHomotopy C
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
theorem orderOf_pow' (h : n ≠ 0) : orderOf (x ^ n) = orderOf x / gcd (orderOf x) n
-- Mathlib/Data/Finset/NoncommProd.lean
/-- Proof used in definition of `Finset.noncommProd` -/
@[to_additive]
theorem noncommProd_lemma (s : Finset α) (f : α → β)
    (comm : (s : Set α).Pairwise fun a b => Commute (f a) (f b)) :
    Set.Pairwise { x | x ∈ Multiset.map f s.val } Commute
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem getLsb_append {v : BitVec n} {w : BitVec m} :
    getLsb (v ++ w) i = bif i < m then getLsb w i else getLsb v (i - m)
-- Mathlib/MeasureTheory/Function/SpecialFunctions/Basic.lean
@[measurability]
theorem measurable_arg : Measurable arg
-- Mathlib/NumberTheory/Cyclotomic/Gal.lean
theorem fromZetaAut_spec : fromZetaAut hμ h (zeta n K L) = μ
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
@[simp]
theorem spanSingleton_zero : spanSingleton S (0 : P) = 0
-- Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean
theorem Subalgebra.toNonUnitalSubalgebra_toSubalgebra (S : Subalgebra R A) :
    S.toNonUnitalSubalgebra.toSubalgebra S.one_mem = S
-- Mathlib/Order/Heyting/Basic.lean
theorem compl_le_hnot : aᶜ ≤ ￢a
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem HasDerivWithinAt.congr (h : HasDerivWithinAt f f' s x) (hs : ∀ x ∈ s, f₁ x = f x)
    (hx : f₁ x = f x) : HasDerivWithinAt f₁ f' s x
-- Mathlib/LinearAlgebra/QuadraticForm/TensorProduct.lean
@[simp]
theorem baseChange_tmul (Q : QuadraticForm R M₂) (a : A) (m₂ : M₂) :
    Q.baseChange A (a ⊗ₜ m₂) = Q m₂ • (a * a)
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
theorem smooth_const : Smooth I I' fun _ : M => c
-- Mathlib/MeasureTheory/Function/LpSpace/ContinuousCompMeasurePreserving.lean
theorem Filter.Tendsto.compMeasurePreservingLp {α : Type*} {l : Filter α}
    {f : α → Lp E p ν} {f₀ : Lp E p ν} {g : α → C(X, Y)} {g₀ : C(X, Y)}
    (hf : Tendsto f l (𝓝 f₀)) (hg : Tendsto g l (𝓝 g₀))
    (hgm : ∀ a, MeasurePreserving (g a) μ ν) (hgm₀ : MeasurePreserving g₀ μ ν) (hp : p ≠ ∞) :
    Tendsto (fun a ↦ Lp.compMeasurePreserving (g a) (hgm a) (f a)) l
      (𝓝 (Lp.compMeasurePreserving g₀ hgm₀ f₀))
-- Mathlib/Algebra/Group/TypeTags.lean
@[simp]
theorem ofMul_inv [Inv α] (x : α) : ofMul x⁻¹ = -ofMul x
-- Mathlib/Order/Cover.lean
theorem mk_wcovBy_mk_iff : (a₁, b₁) ⩿ (a₂, b₂) ↔ a₁ ⩿ a₂ ∧ b₁ = b₂ ∨ b₁ ⩿ b₂ ∧ a₁ = a₂
-- Mathlib/LinearAlgebra/CliffordAlgebra/Fold.lean
@[simp]
theorem foldr_mul (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) (a b : CliffordAlgebra Q) :
    foldr Q f hf n (a * b) = foldr Q f hf (foldr Q f hf n b) a
-- Mathlib/Analysis/Convex/Segment.lean
theorem segment_translate_image (a b c : E) : (fun x => a + x) '' [b -[𝕜] c] = [a + b -[𝕜] a + c]
-- Mathlib/Topology/Homeomorph.lean
protected theorem t0Space [T0Space X] (h : X ≃ₜ Y) : T0Space Y
-- Mathlib/Algebra/Polynomial/EraseLead.lean
theorem eraseLead_add_of_natDegree_lt_right {p q : R[X]} (pq : p.natDegree < q.natDegree) :
    (p + q).eraseLead = p + q.eraseLead
-- Mathlib/MeasureTheory/Constructions/Prod/Integral.lean
theorem integrable_swap_iff [SFinite μ] {f : α × β → E} :
    Integrable (f ∘ Prod.swap) (ν.prod μ) ↔ Integrable f (μ.prod ν)
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
theorem IntegrableAtFilter.filter_mono (hl : l ≤ l') (hl' : IntegrableAtFilter f l' μ) :
    IntegrableAtFilter f l μ
-- Mathlib/Data/Finset/Card.lean
/-- **Pigeonhole principle** for two finsets inside an ambient finset. -/
theorem inter_nonempty_of_card_lt_card_add_card (hts : t ⊆ s) (hus : u ⊆ s)
    (hstu : s.card < t.card + u.card) : (t ∩ u).Nonempty
-- Mathlib/Data/Rat/Lemmas.lean
@[simp]
theorem coe_pnatDen (x : ℚ) : (x.pnatDen : ℕ) = x.den
-- Mathlib/Algebra/Polynomial/Monomial.lean
@[ext high]
theorem ringHom_ext' {S} [Semiring S] {f g : R[X] →+* S} (h₁ : f.comp C = g.comp C)
    (h₂ : f X = g X) : f = g
-- .lake/packages/batteries/Batteries/Logic.lean
theorem funext₃ {β : α → Sort _} {γ : ∀ a, β a → Sort _} {δ : ∀ a b, γ a b → Sort _}
    {f g : ∀ a b c, δ a b c} (h : ∀ a b c, f a b c = g a b c) : f = g
-- Mathlib/Init/Logic.lean
theorem heq_prop {P Q : Prop} (p : P) (q : Q) : HEq p q
-- Mathlib/Geometry/Manifold/Instances/Real.lean
@[ext]
theorem EuclideanQuadrant.ext (x y : EuclideanQuadrant n) (h : x.1 = y.1) : x = y
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, rclike_simps, norm_cast]
theorem ofReal_finsupp_sum {α M : Type*} [Zero M] (f : α →₀ M) (g : α → M → ℝ) :
    ((f.sum fun a b => g a b : ℝ) : K) = f.sum fun a b => (g a b : K)
-- Mathlib/Order/CompleteLattice.lean
lemma iSup_unique [Unique ι] (f : ι → α) : ⨆ i, f i = f default
-- Mathlib/GroupTheory/Complement.lean
@[to_additive]
theorem isComplement_iff_existsUnique :
    IsComplement S T ↔ ∀ g : G, ∃! x : S × T, x.1.1 * x.2.1 = g
-- Mathlib/Analysis/SpecialFunctions/Complex/Analytic.lean
/-- `f z ^ g z` is analytic if `f z` is not a nonpositive real -/
theorem AnalyticAt.cpow (fa : AnalyticAt ℂ f x) (ga : AnalyticAt ℂ g x)
    (m : f x ∈ slitPlane) : AnalyticAt ℂ (fun z ↦ f z ^ g z) x
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem chain_of_chain_cons {a b : α} {l : List α} (p : Chain R a (b :: l)) : Chain R b l
-- Mathlib/Topology/Sheaves/LocalPredicate.lean
/-- The subpresheaf of dependent functions on `X` satisfying the "pre-local" predicate `P`.
-/
@[simps!]
def subpresheafToTypes (P : PrelocalPredicate T) : Presheaf (Type v) X
-- Mathlib/Probability/Distributions/Gaussian.lean
lemma gaussianPDF_pos (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0) (x : ℝ) : 0 < gaussianPDF μ v x
-- Mathlib/Algebra/Order/Sub/Defs.lean
/-- See `tsub_add_tsub_comm` for the equality. -/
theorem add_tsub_add_le_tsub_add_tsub : a + b - (c + d) ≤ a - c + (b - d)
-- Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean
lemma tensor_map_id_left_injective_of_injective (hf : Function.Injective f) :
    Function.Injective (AlgebraTensorModule.map LinearMap.id f :
        AdicCompletion I R ⊗[R] M →ₗ[AdicCompletion I R] AdicCompletion I R ⊗[R] N)
-- Mathlib/Order/Sublattice.lean
lemma map_equiv_eq_comap_symm (f : α ≃o β) (L : Sublattice α) :
    L.map f = L.comap (f.symm : LatticeHom β α)
-- Mathlib/Topology/MetricSpace/Antilipschitz.lean
theorem comap_uniformity_le (hf : AntilipschitzWith K f) : (𝓤 β).comap (Prod.map f f) ≤ 𝓤 α
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem span_mul_span (S T : Set R) : span S * span T = span (⋃ (s ∈ S) (t ∈ T), {s * t})
-- Mathlib/Algebra/Order/Monoid/NatCast.lean
/-- See `zero_lt_two'` for a version with the type explicit. -/
@[simp] lemma zero_lt_two : (0 : α) < 2
-- Mathlib/Data/List/Nodup.lean
theorem Nodup.pmap {p : α → Prop} {f : ∀ a, p a → β} {l : List α} {H}
    (hf : ∀ a ha b hb, f a ha = f b hb → a = b) (h : Nodup l) : Nodup (pmap f l H)
-- Mathlib/Algebra/Algebra/Equiv.lean
@[deprecated map_finsupp_prod (since := "2024-06-20")]
protected theorem map_finsupp_prod {α : Type*} [Zero α] {ι : Type*} (f : ι →₀ α) (g : ι → α → A₁) :
    e (f.prod g) = f.prod fun i a => e (g i a)
-- Mathlib/Order/Filter/AtTopBot.lean
theorem Tendsto.eventually_forall_ge_atTop [Preorder β] {l : Filter α}
    {p : β → Prop} {f : α → β} (hf : Tendsto f l atTop) (h_evtl : ∀ᶠ x in atTop, p x) :
    ∀ᶠ x in l, ∀ y, f x ≤ y → p y
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem continuousAt_extend {x : M} (h : x ∈ f.source) : ContinuousAt (f.extend I) x
-- Mathlib/CategoryTheory/Localization/SmallShiftedHom.lean
lemma equiv_comp [HasSmallLocalizedShiftedHom.{w} W M X Y]
    [HasSmallLocalizedShiftedHom.{w} W M Y Z] [HasSmallLocalizedShiftedHom.{w} W M X Z]
    [HasSmallLocalizedShiftedHom.{w} W M Z Z] {a b c : M}
    (f : SmallShiftedHom.{w} W X Y a) (g : SmallShiftedHom.{w} W Y Z b) (h : b + a = c) :
    equiv W L (f.comp g h) = (equiv W L f).comp (equiv W L g) h
-- Mathlib/Analysis/MellinInversion.lean
theorem mellinInv_eq_fourierIntegralInv (σ : ℝ) (f : ℂ → E) {x : ℝ} (hx : 0 < x) :
    mellinInv σ f x =
    (x : ℂ) ^ (-σ : ℂ) • 𝓕⁻ (fun (y : ℝ) ↦ f (σ + 2 * π * y * I)) (-Real.log x)
-- Mathlib/RingTheory/Ideal/IsPrincipal.lean
@[simp]
theorem associatesEquivIsPrincipal_map_one :
    (associatesEquivIsPrincipal R 1 : Ideal R) = 1
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToFun_smul [NontriviallyNormedField 𝕜] [NormedSpace 𝕜 E] [NormedSpace 𝕜 F]
    (hT : DominatedFinMeasAdditive μ T C) (h_smul : ∀ c : 𝕜, ∀ s x, T s (c • x) = c • T s x) (c : 𝕜)
    (f : α → E) : setToFun μ T hT (c • f) = c • setToFun μ T hT f
-- Mathlib/CategoryTheory/MorphismProperty/IsInvertedBy.lean
lemma of_le (P Q : MorphismProperty C) (F : C ⥤ D) (hQ : Q.IsInvertedBy F) (h : P ≤ Q) :
    P.IsInvertedBy F
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
@[measurability, fun_prop]
theorem AEMeasurable.ennreal_toNNReal {f : α → ℝ≥0∞} {μ : Measure α} (hf : AEMeasurable f μ) :
    AEMeasurable (fun x => (f x).toNNReal) μ
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem orthonormal_empty : Orthonormal 𝕜 (fun x => x : (∅ : Set E) → E)
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIocMod_sub_zsmul (a b : α) (m : ℤ) : toIocMod hp a (b - m • p) = toIocMod hp a b
-- .lake/packages/lean4/src/lean/Init/Omega/Int.lean
theorem ofNat_sub_eq_zero {b a : Nat} (h : ¬ b ≤ a) : ((a - b : Nat) : Int) = 0
-- Mathlib/Analysis/Convex/Segment.lean
theorem openSegment_subset (x y : E × F) :
    openSegment 𝕜 x y ⊆ openSegment 𝕜 x.1 y.1 ×ˢ openSegment 𝕜 x.2 y.2
-- Mathlib/CategoryTheory/ComposableArrows.lean
/-- Constructor for isomorphisms `F ≅ G` in `ComposableArrows C n` which takes as inputs
a family of isomorphisms `F.obj i ≅ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. -/
@[simps]
def isoMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ≅ G.obj i)
    (w : ∀ (i : ℕ) (hi : i < n),
      F.map' i (i + 1) ≫ (app _).hom = (app _).hom ≫ G.map' i (i + 1)) :
    F ≅ G
-- Mathlib/Combinatorics/Quiver/Symmetric.lean
@[simp]
theorem Path.reverse_comp [HasReverse V] {a b c : V} (p : Path a b) (q : Path b c) :
    (p.comp q).reverse = q.reverse.comp p.reverse
-- Mathlib/Logic/Equiv/TransferInstance.lean
/-- Any finite group in universe `u` is equivalent to some finite group in universe `0`. -/
lemma exists_type_zero_nonempty_mulEquiv (G : Type u) [Group G] [Finite G] :
    ∃ (G' : Type) (_ : Group G') (_ : Fintype G'), Nonempty (G ≃* G')
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem nextCoeff_X_add_C [Semiring S] (c : S) : nextCoeff (X + C c) = c
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc (attr := simp)]
theorem whiskerLeft_inv_hom' (X : C) {Y Z : C} (f : Y ⟶ Z) [IsIso f] :
    X ◁ inv f ≫ X ◁ f = 𝟙 (X ⊗ Z)
-- Mathlib/Algebra/Order/Monoid/NatCast.lean
/-- See `zero_lt_four` for a version with the type implicit. -/
lemma zero_lt_four' : (0 : α) < 4
-- Mathlib/Data/Sum/Basic.lean
theorem isRight_left (h : LiftRel r s x (inr d)) : x.isRight
-- Mathlib/Data/Multiset/Nodup.lean
theorem Nodup.ext {s t : Multiset α} : Nodup s → Nodup t → (s = t ↔ ∀ a, a ∈ s ↔ a ∈ t)
-- Mathlib/Data/Finsupp/Defs.lean
@[simp, nolint simpNF] -- Porting note: simpNF linter claims simp can prove this, it can not
theorem erase_zero (a : α) : erase a (0 : α →₀ M) = 0
-- Mathlib/RingTheory/Polynomial/Opposites.lean
@[simp]
theorem support_opRingEquiv (p : R[X]ᵐᵒᵖ) : (opRingEquiv R p).support = (unop p).support
-- .lake/packages/batteries/Batteries/Classes/SatisfiesM.lean
@[simp] theorem SatisfiesM_ExceptT_eq [Monad m] [LawfulMonad m] :
    SatisfiesM (m := ExceptT ρ m) (α := α) p x ↔ SatisfiesM (m := m) (∀ a, · = .ok a → p a) x
-- Mathlib/Topology/Connected/Clopen.lean
theorem Sigma.isPreconnected_iff [hι : Nonempty ι] [∀ i, TopologicalSpace (π i)]
    {s : Set (Σi, π i)} : IsPreconnected s ↔ ∃ i t, IsPreconnected t ∧ s = Sigma.mk i '' t
-- Mathlib/Algebra/Group/Pi/Basic.lean
@[to_additive (attr := simp, to_additive) (reorder := 2 3, 5 6) smul_const]
lemma _root_.Function.const_pow [Pow α β] (a : α) (b : β) : const I a ^ b = const I (a ^ b)
-- Mathlib/Data/Seq/WSeq.lean
theorem length_eq_map (s : WSeq α) : length s = Computation.map List.length (toList s)
-- Mathlib/Algebra/Ring/Parity.lean
lemma Even.neg_zpow : Even n → ∀ a : α, (-a) ^ n = a ^ n
-- Mathlib/Data/Nat/Totient.lean
theorem totient_eq_iff_prime {p : ℕ} (hp : 0 < p) : p.totient = p - 1 ↔ p.Prime