ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Normed/Algebra/TrivSqZeroExt.lean
/-- If `exp R x.fst` converges to `e` then `(exp R x).snd` converges to `e • x.snd`. -/
theorem hasSum_snd_expSeries_of_smul_comm (x : tsze R M)
    (hx : MulOpposite.op x.fst • x.snd = x.fst • x.snd) {e : R}
    (h : HasSum (fun n => expSeries 𝕜 R n fun _ => x.fst) e) :
    HasSum (fun n => snd (expSeries 𝕜 (tsze R M) n fun _ => x)) (e • x.snd)
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem nextn : ∀ {s}, Valid s → s.toString.1 = m₁ ++ m₂ →
    ∀ n, s.nextn n ⟨utf8Len m₁⟩ = ⟨utf8Len m₁ + utf8Len (m₂.take n)⟩
-- Mathlib/Order/Filter/Basic.lean
theorem mem_comap'' : s ∈ comap f l ↔ kernImage f s ∈ l
-- Mathlib/Topology/Homeomorph.lean
/-- If `h : X → Y` is a homeomorphism, `h⁻¹(s)` is σ-compact iff `s` is. -/
@[simp]
theorem isSigmaCompact_preimage {s : Set Y} (h : X ≃ₜ Y) :
    IsSigmaCompact (h ⁻¹' s) ↔ IsSigmaCompact s
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_image_eq_of_injOn {α β : Type u} (f : α → β) (s : Set α) (h : InjOn f s) :
    #(f '' s) = #s
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
theorem WalkingParallelPairHom.assoc {X Y Z W : WalkingParallelPair}
    (f : WalkingParallelPairHom X Y) (g : WalkingParallelPairHom Y Z)
    (h : WalkingParallelPairHom Z W) : comp (comp f g) h = comp f (comp g h)
-- Mathlib/Order/Bounds/Basic.lean
theorem IsGLB.lowerBounds_eq (h : IsGLB s a) : lowerBounds s = Iic a
-- Mathlib/Dynamics/BirkhoffSum/NormedSpace.lean
theorem dist_birkhoffSum_birkhoffSum_le (f : α → α) (g : α → E) (n : ℕ) (x y : α) :
    dist (birkhoffSum f g n x) (birkhoffSum f g n y) ≤
      ∑ k ∈ Finset.range n, dist (g (f^[k] x)) (g (f^[k] y))
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem bot_prod_bot : (⊥ : Subgroup G).prod (⊥ : Subgroup N) = ⊥
-- Mathlib/Analysis/Convex/Between.lean
theorem Sbtw.right_mem_affineSpan {x y z : P} (h : Sbtw R x y z) : z ∈ line[R, x, y]
-- Mathlib/Geometry/Euclidean/PerpBisector.lean
@[simp]
theorem direction_perpBisector (p₁ p₂ : P) :
    (perpBisector p₁ p₂).direction = (ℝ ∙ (p₂ -ᵥ p₁))ᗮ
-- Mathlib/Order/BoundedOrder.lean
@[simp]
theorem coe_eq_top_iff [OrderTop α] [OrderTop (Subtype p)] (htop : p ⊤) {x : { x // p x }} :
    (x : α) = ⊤ ↔ x = ⊤
-- Mathlib/RingTheory/OreLocalization/Ring.lean
theorem universalHom_commutes {r : R} : universalHom f fS hf (numeratorHom r) = f r
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem nil_union (l : List α) : nil ∪ l = l
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
@[simp]
theorem decide_implies (u v : Prop)
    [duv : Decidable (u → v)] [du : Decidable u] {dv : u → Decidable v}
  : decide (u → v) = dite u (fun h => @decide v (dv h)) (fun _ => true)
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem mem_range_self (f : R →+* S) (x : R) : f x ∈ f.range
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem TopologicalGroup.t1Space (h : @IsClosed G _ {1}) : T1Space G
-- Mathlib/LinearAlgebra/Trace.lean
theorem traceAux_def (b : Basis ι R M) (f : M →ₗ[R] M) :
    traceAux R b f = Matrix.trace (LinearMap.toMatrix b b f)
-- Mathlib/AlgebraicGeometry/Cover/Open.lean
@[simp]
lemma OpenCover.id_idx_apply {X : Scheme.{u}} (𝓤 : X.OpenCover) (j : 𝓤.J) :
    (𝟙 𝓤 : 𝓤 ⟶ 𝓤).idx j = j
-- Mathlib/Geometry/Manifold/ContMDiff/NormedSpace.lean
theorem ContMDiffWithinAt.clm_comp {g : M → F₁ →L[𝕜] F₃} {f : M → F₂ →L[𝕜] F₁} {s : Set M} {x : M}
    (hg : ContMDiffWithinAt I 𝓘(𝕜, F₁ →L[𝕜] F₃) n g s x)
    (hf : ContMDiffWithinAt I 𝓘(𝕜, F₂ →L[𝕜] F₁) n f s x) :
    ContMDiffWithinAt I 𝓘(𝕜, F₂ →L[𝕜] F₃) n (fun x => (g x).comp (f x)) s x
-- Mathlib/CategoryTheory/Limits/ConeCategory.lean
/-- If `F` has a colimit, then the colimit inclusions can be interpreted as costructured arrows
    `F.obj - ⟶ colimit F`. -/
@[simps]
noncomputable def colimit.toCostructuredArrow (F : J ⥤ C) [HasColimit F] :
    J ⥤ CostructuredArrow F (colimit F)
-- Mathlib/Probability/ProbabilityMassFunction/Basic.lean
@[simp]
theorem support_nonempty (p : PMF α) : p.support.Nonempty
-- Mathlib/Data/PNat/Prime.lean
theorem Coprime.factor_eq_gcd_left {a b m n : ℕ+} (cop : m.Coprime n) (am : a ∣ m) (bn : b ∣ n) :
    a = (a * b).gcd m
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[to_additive (attr := measurability)]
theorem _root_.Finset.stronglyMeasurable_prod' {ι : Type*} {f : ι → α → M} (s : Finset ι)
    (hf : ∀ i ∈ s, StronglyMeasurable (f i)) : StronglyMeasurable (∏ i ∈ s, f i)
-- Mathlib/RingTheory/Localization/AtPrime.lean
theorem to_map_mem_maximal_iff (x : R) (h : LocalRing S := localRing S I) :
    algebraMap R S x ∈ LocalRing.maximalIdeal S ↔ x ∈ I
-- Mathlib/Topology/MetricSpace/Dilation.lean
/-- `DilationClass F α β r` states that `F` is a type of `r`-dilations.
You should extend this typeclass when you extend `Dilation`. -/
class DilationClass (F α β : Type*) [PseudoEMetricSpace α] [PseudoEMetricSpace β]
    [FunLike F α β] : Prop where
  edist_eq' : ∀ f : F, ∃ r : ℝ≥0, r ≠ 0 ∧ ∀ x y : α, edist (f x) (f y) = r * edist x y
-- Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean
/-- A diagonal matrix rescales Lebesgue according to its determinant. This is a special case of
`Real.map_matrix_volume_pi_eq_smul_volume_pi`, that one should use instead (and whose proof
uses this particular case). -/
theorem smul_map_diagonal_volume_pi [DecidableEq ι] {D : ι → ℝ} (h : det (diagonal D) ≠ 0) :
    ENNReal.ofReal (abs (det (diagonal D))) • Measure.map (toLin' (diagonal D)) volume =
      volume
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Ico_mem_nhdsWithin_Ici (H : b ∈ Ico a c) : Ico a c ∈ 𝓝[≥] b
-- .lake/packages/batteries/Batteries/Data/RBMap/Alter.lean
protected theorem _root_.Batteries.RBNode.Balanced.zoom : t.Balanced c n → path.Balanced c₀ n₀ c n →
    zoom cut t path = (t', path') → ∃ c n, t'.Balanced c n ∧ path'.Balanced c₀ n₀ c n
-- Mathlib/AlgebraicGeometry/OpenImmersion.lean
@[simp, reassoc]
lemma isoOfRangeEq_hom_fac {X Y Z : Scheme.{u}} (f : X ⟶ Z) (g : Y ⟶ Z)
    [IsOpenImmersion f] [IsOpenImmersion g] (e : Set.range f.1.base = Set.range g.1.base) :
    (isoOfRangeEq f g e).hom ≫ g = f
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem map_equiv_eq_comap_symm (f : R ≃+* S) (K : Subring R) :
    K.map (f : R →+* S) = K.comap f.symm
-- Mathlib/Data/Real/Sqrt.lean
@[simp] lemma sqrt_le_one : sqrt x ≤ 1 ↔ x ≤ 1
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
theorem lineDeriv_zero_of_not_lineDifferentiableAt (h : ¬LineDifferentiableAt 𝕜 f x v) :
    lineDeriv 𝕜 f x v = 0
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem contMDiffOn_iff_of_mem_maximalAtlas' (he : e ∈ maximalAtlas I M)
    (he' : e' ∈ maximalAtlas I' M') (hs : s ⊆ e.source) (h2s : MapsTo f s e'.source) :
    ContMDiffOn I I' n f s ↔
      ContDiffOn 𝕜 n (e'.extend I' ∘ f ∘ (e.extend I).symm) (e.extend I '' s)
-- Mathlib/Order/Concept.lean
/-- The dual of a concept lattice is isomorphic to the concept lattice of the dual context. -/
@[simps]
def swapEquiv : (Concept α β r)ᵒᵈ ≃o Concept β α (Function.swap r)
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
@[simp]
theorem symm_preimage_preimage (e : α ≃ᵐ β) (s : Set β) : e.symm ⁻¹' (e ⁻¹' s) = s
-- Mathlib/MeasureTheory/Function/LpSeminorm/Trim.lean
theorem essSup_trim (hm : m ≤ m0) {f : α → ℝ≥0∞} (hf : Measurable[m] f) :
    essSup f (μ.trim hm) = essSup f μ
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
/-- Given a distinguished triangle `T` such that `T.mor₃ = 0` and the datum of morphisms
`inr : T.obj₃ ⟶ T.obj₂` and `fst : T.obj₂ ⟶ T.obj₁` satisfying suitable relations, this
is the binary biproduct data expressing that `T.obj₂` identifies to the binary
biproduct of `T.obj₁` and `T.obj₃`.
See also `exists_iso_binaryBiproduct_of_distTriang`. -/
@[simps]
def binaryBiproductData (T : Triangle C) (hT : T ∈ distTriang C) (hT₀ : T.mor₃ = 0)
    (inr : T.obj₃ ⟶ T.obj₂) (inr_snd : inr ≫ T.mor₂ = 𝟙 _) (fst : T.obj₂ ⟶ T.obj₁)
    (total : fst ≫ T.mor₁ + T.mor₂ ≫ inr = 𝟙 T.obj₂) :
    BinaryBiproductData T.obj₁ T.obj₃
-- Mathlib/ModelTheory/Basic.lean
/-- Makes a `Language.empty.Hom` out of any function. -/
@[simps]
def _root_.Function.emptyHom (f : M → N) : M →[Language.empty] N
-- Mathlib/Algebra/Order/Ring/Basic.lean
@[simp]
theorem sq_eq_sq {a b : R} (ha : 0 ≤ a) (hb : 0 ≤ b) : a ^ 2 = b ^ 2 ↔ a = b
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
@[simp]
theorem add_fst : (x + y).fst = x.fst + y.fst
-- Mathlib/RingTheory/PowerSeries/Basic.lean
theorem commute_X (φ : R⟦X⟧) : Commute φ X
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem le_iff_derivBFamily (H : ∀ i hi, IsNormal (f i hi)) {a} :
    (∀ i hi, f i hi a ≤ a) ↔ ∃ b, derivBFamily.{u, v} o f b = a
-- Mathlib/Topology/Algebra/InfiniteSum/Defs.lean
@[to_additive]
theorem Multipliable.hasProd_iff (h : Multipliable f) : HasProd f a ↔ ∏' b, f b = a
-- Mathlib/Topology/Algebra/InfiniteSum/Group.lean
@[to_additive]
theorem multipliable_inv_iff : (Multipliable fun b ↦ (f b)⁻¹) ↔ Multipliable f
-- Mathlib/Algebra/Homology/ShortComplex/Linear.lean
/-- Given a right homology map data for morphism `φ`, this is the induced right homology
map data for `a • φ`. -/
@[simps]
def smul (a : R) : RightHomologyMapData (a • φ) h₁ h₂
-- Mathlib/Topology/Instances/ENNReal.lean
theorem tsum_eq_toNNReal_tsum {f : β → ℝ≥0} : ∑' b, f b = (∑' b, (f b : ℝ≥0∞)).toNNReal
-- Mathlib/Algebra/FreeMonoid/Basic.lean
@[to_additive (attr := simp)]
theorem map_id : map (@id α) = MonoidHom.id (FreeMonoid α)
-- Mathlib/Topology/Connected/Basic.lean
/-- The image of a connected set is connected as well. -/
protected theorem IsConnected.image [TopologicalSpace β] {s : Set α} (H : IsConnected s) (f : α → β)
    (hf : ContinuousOn f s) : IsConnected (f '' s)
-- Mathlib/Algebra/Order/GroupWithZero/Canonical.lean
lemma zero_lt_coe (a : α) : (0 : WithZero α) < a
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[to_additive (attr := measurability)]
theorem Multiset.measurable_prod' (l : Multiset (α → M)) (hl : ∀ f ∈ l, Measurable f) :
    Measurable l.prod
-- Mathlib/Topology/Semicontinuous.lean
theorem upperSemicontinuous_iff_isOpen_preimage :
    UpperSemicontinuous f ↔ ∀ y, IsOpen (f ⁻¹' Iio y)
-- Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean
/-- `secondInter` is unchanged by multiplying the vector by a nonzero real. -/
@[simp]
theorem Sphere.secondInter_smul (s : Sphere P) (p : P) (v : V) {r : ℝ} (hr : r ≠ 0) :
    s.secondInter p (r • v) = s.secondInter p v
-- Mathlib/Topology/Order/OrderClosed.lean
protected theorem Dense.exists_gt [NoMaxOrder α] {s : Set α} (hs : Dense s) (x : α) :
    ∃ y ∈ s, x < y
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[reassoc (attr := simp)]
theorem biproduct.toSubtype_fromSubtype [DecidablePred p] :
    biproduct.toSubtype f p ≫ biproduct.fromSubtype f p =
      biproduct.map fun j => if p j then 𝟙 (f j) else 0
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem compl_bihimp_compl : aᶜ ⇔ bᶜ = a ⇔ b
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem or_self_iff : a ∨ a ↔ a
-- Mathlib/Analysis/Analytic/CPolynomial.lean
theorem HasFiniteFPowerSeriesOnBall.hasFiniteFPowerSeriesAt
    (hf : HasFiniteFPowerSeriesOnBall f p x n r) :
    HasFiniteFPowerSeriesAt f p x n
-- Mathlib/Order/Interval/Set/Disjoint.lean
@[simp]
theorem iUnion_Ioc_right (a : α) : ⋃ b, Ioc a b = Ioi a
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem ae_pi_le_pi : ae (Measure.pi μ) ≤ Filter.pi fun i => ae (μ i)
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem monotone_spanningSets (μ : Measure α) [SigmaFinite μ] : Monotone (spanningSets μ)
-- Mathlib/Geometry/Euclidean/Sphere/Basic.lean
/-- Given three collinear points, two on a sphere and one inside it, the one inside it is
strictly between the other two points. -/
theorem sbtw_of_collinear_of_dist_center_lt_radius {s : Sphere P} {p₁ p₂ p₃ : P}
    (h : Collinear ℝ ({p₁, p₂, p₃} : Set P)) (hp₁ : p₁ ∈ s) (hp₂ : dist p₂ s.center < s.radius)
    (hp₃ : p₃ ∈ s) (hp₁p₃ : p₁ ≠ p₃) : Sbtw ℝ p₁ p₂ p₃
-- Mathlib/Topology/Order.lean
theorem gc_nhds (a : α) : GaloisConnection (nhdsAdjoint a) fun t => @nhds α t a
-- Mathlib/Geometry/Euclidean/Circumcenter.lean
/-- Adding a vector to a point in the given subspace, then taking the
orthogonal projection, produces the original point if the vector is a
multiple of the result of subtracting a point's orthogonal projection
from that point. -/
theorem orthogonalProjection_vadd_smul_vsub_orthogonalProjection {n : ℕ} (s : Simplex ℝ P n)
    {p1 : P} (p2 : P) (r : ℝ) (hp : p1 ∈ affineSpan ℝ (Set.range s.points)) :
    s.orthogonalProjectionSpan (r • (p2 -ᵥ s.orthogonalProjectionSpan p2 : V) +ᵥ p1) = ⟨p1, hp⟩
-- Mathlib/Data/Set/Function.lean
theorem image_image (hf : LeftInvOn f' f s) : f' '' (f '' s) = s
-- Mathlib/Algebra/Polynomial/Roots.lean
theorem rootSet_mapsTo {p : T[X]} {S S'} [CommRing S] [IsDomain S] [Algebra T S] [CommRing S']
    [IsDomain S'] [Algebra T S'] [NoZeroSMulDivisors T S'] (f : S →ₐ[T] S') :
    (p.rootSet S).MapsTo f (p.rootSet S')
-- Mathlib/Algebra/Order/Monoid/Unbundled/MinMax.lean
@[to_additive]
theorem min_mul_mul_right (a b c : α) : min (a * c) (b * c) = min a b * c
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem einfsep_top :
    s.einfsep = ∞ ↔ ∀ x ∈ s, ∀ y ∈ s, x ≠ y → edist x y = ∞
-- Mathlib/Order/Interval/Multiset.lean
theorem Ico_filter_lt_of_le_left [DecidablePred (· < c)] (hca : c ≤ a) :
    ((Ico a b).filter fun x => x < c) = ∅
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive]
theorem comap_injective_of_surjective : Function.Injective (comap f)
-- Mathlib/Topology/Connected/PathConnected.lean
@[simp]
theorem truncate_zero_one {a b : X} (γ : Path a b) :
    γ.truncate 0 1 = γ.cast (by simp [zero_le_one, extend_zero]) (by simp)
-- Mathlib/Algebra/BigOperators/Finprod.lean
@[to_additive]
theorem finprod_mem_eq_prod_of_inter_mulSupport_eq (f : α → M) {s : Set α} {t : Finset α}
    (h : s ∩ mulSupport f = t.toSet ∩ mulSupport f) : ∏ᶠ i ∈ s, f i = ∏ i ∈ t, f i
-- Mathlib/Computability/Partrec.lean
theorem vector_ofFn {n} {f : Fin n → α → σ} (hf : ∀ i, Computable (f i)) :
    Computable fun a => Vector.ofFn fun i => f i a
-- Mathlib/Analysis/Convex/Deriv.lean
/-- Reformulation of `ConvexOn.le_slope_of_hasDerivWithinAt` using `derivWithin`. -/
lemma derivWithin_le_slope (hfc : ConvexOn ℝ S f) (hx : x ∈ S) (hy : y ∈ S) (hxy : x < y)
    (hfd : DifferentiableWithinAt ℝ f S x) :
    derivWithin f S x ≤ slope f x y
-- Mathlib/Data/TwoPointing.lean
/-- Swaps the two pointed elements. -/
@[simps]
def swap : TwoPointing α
-- Mathlib/Data/Set/Basic.lean
theorem empty_def : (∅ : Set α) = { _x : α | False }
-- Mathlib/Data/Set/Basic.lean
theorem AntitoneOn.inter [Preorder β] {f g : β → Set α} {s : Set β} (hf : AntitoneOn f s)
    (hg : AntitoneOn g s) : AntitoneOn (fun x => f x ∩ g x) s
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/ArctanDeriv.lean
theorem tendsto_abs_tan_atTop (k : ℤ) :
    Tendsto (fun x => abs (tan x)) (𝓝[≠] ((2 * k + 1) * π / 2)) atTop
-- Mathlib/SetTheory/Game/Ordinal.lean
@[simp, nolint unusedHavesSuffices]
theorem toPGame_leftMoves (o : Ordinal) : o.toPGame.LeftMoves = o.out.α
-- Mathlib/Order/BoundedOrder.lean
@[simp]
theorem mk_bot [OrderBot α] [OrderBot (Subtype p)] (hbot : p ⊥) : mk ⊥ hbot = ⊥
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Simproc.lean
theorem add_le_add_le (a c : Nat) {b d : Nat} (h : b ≤ d) : (a + b ≤ c + d) = (a ≤ c + (d - b))
-- Mathlib/Logic/Equiv/Basic.lean
theorem eq_or_eq_of_swap_apply_ne_self {a b x : α} (h : swap a b x ≠ x) : x = a ∨ x = b
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem iterate_toEnd_mem_lowerCentralSeries (x : L) (m : M) (k : ℕ) :
    (toEnd R L M x)^[k] m ∈ lowerCentralSeries R L M k
-- Mathlib/Algebra/Module/Submodule/RestrictScalars.lean
@[simp]
theorem restrictScalars_eq_bot_iff {p : Submodule R M} : restrictScalars S p = ⊥ ↔ p = ⊥
-- Mathlib/MeasureTheory/Integral/CircleIntegral.lean
@[simp]
theorem integral_radius_zero (f : ℂ → E) (c : ℂ) : (∮ z in C(c, 0), f z) = 0
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem mul_isNormal {a : Ordinal} (h : 0 < a) : IsNormal (a * ·)
-- Mathlib/Algebra/MvPolynomial/Basic.lean
/-- See note [partially-applied ext lemmas]. -/
@[ext 1100]
theorem ringHom_ext' {A : Type*} [Semiring A] {f g : MvPolynomial σ R →+* A}
    (hC : f.comp C = g.comp C) (hX : ∀ i, f (X i) = g (X i)) : f = g
-- Mathlib/LinearAlgebra/LinearIndependent.lean
@[simp]
theorem LinearIndependent.totalEquiv_apply_coe (hv : LinearIndependent R v) (l : ι →₀ R) :
    hv.totalEquiv l = Finsupp.total ι M R v l
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem mapMatrix_symm (f : α ≃ₗ[R] β) :
    f.mapMatrix.symm = (f.symm.mapMatrix : Matrix m n β ≃ₗ[R] _)
-- Mathlib/MeasureTheory/Measure/Regular.lean
/-- The restriction of a weakly regular measure to a measurable set of finite measure is
weakly regular. -/
theorem restrict_of_measure_ne_top [BorelSpace α] [WeaklyRegular μ] {A : Set α}
    (h'A : μ A ≠ ∞) : WeaklyRegular (μ.restrict A)
-- Mathlib/AlgebraicTopology/SplitSimplicialObject.lean
/-- Given `A : IndexSet Δ₁`, if `p.unop : unop Δ₂ ⟶ unop Δ₁` is an epi, this
is the obvious element in `A : IndexSet Δ₂` associated to the composition
of epimorphisms `p.unop ≫ A.e`. -/
@[simps]
def epiComp {Δ₁ Δ₂ : SimplexCategoryᵒᵖ} (A : IndexSet Δ₁) (p : Δ₁ ⟶ Δ₂) [Epi p.unop] :
    IndexSet Δ₂
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
@[simp] theorem divInt_ofNat (num den) : num /. (den : Nat) = mkRat num den
-- Mathlib/Control/Basic.lean
@[functor_norm]
theorem fish_pipe {α β} (f : α → m β) : pure >=> f = f
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
@[simp]
theorem sameCycle_one : SameCycle 1 x y ↔ x = y
-- Mathlib/Topology/Bornology/Absorbs.lean
theorem absorbs_finite (hs : Absorbent M s) (ht : t.Finite) : Absorbs M s t
-- Mathlib/CategoryTheory/Quotient.lean
@[reassoc]
lemma comp_natTransLift {F G H : Quotient r ⥤ D}
    (τ : Quotient.functor r ⋙ F ⟶ Quotient.functor r ⋙ G)
    (τ' : Quotient.functor r ⋙ G ⟶ Quotient.functor r ⋙ H) :
    natTransLift r τ ≫ natTransLift r τ' =  natTransLift r (τ ≫ τ')
-- Mathlib/Algebra/Algebra/Unitization.lean
theorem inr_mul_inl [Semiring R] [NonUnitalNonAssocSemiring A] [DistribMulAction R A] (r : R)
    (a : A) : a * (inl r : Unitization R A) = ↑(r • a)
-- Mathlib/Algebra/Polynomial/EraseLead.lean
theorem eraseLead_natDegree_lt_or_eraseLead_eq_zero (f : R[X]) :
    (eraseLead f).natDegree < f.natDegree ∨ f.eraseLead = 0
-- Mathlib/Data/Rat/Cast/Order.lean
@[simp]
theorem castHom_rat : castHom ℚ = RingHom.id ℚ
-- Mathlib/Logic/Function/Basic.lean
/-- A symmetric relation `r : α → α → Prop` is "function-like"
(for each `a` there exists a unique `b` such that `r a b`)
if and only if it is `(f · = ·)` for some involutive function `f`. -/
protected lemma Symmetric.forall_existsUnique_iff' {r : α → α → Prop} (hr : Symmetric r) :
    (∀ a, ∃! b, r a b) ↔ ∃ f : α → α, Involutive f ∧ r = (f · = ·)
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
/-- A measure `μ` on the `AddQuotient` of `α` mod `G` satisfies
  `AddQuotientMeasureEqMeasurePreimage` if: for any fundamental domain `t`, and any measurable
  subset `U` of the quotient, `μ U = volume ((π ⁻¹' U) ∩ t)`. -/
class AddQuotientMeasureEqMeasurePreimage (ν : Measure α := by volume_tac)
    (μ : Measure (Quotient α_mod_G)) : Prop where
  addProjection_respects_measure' : ∀ (t : Set α) (_ : IsAddFundamentalDomain G t ν),
    μ = (ν.restrict t).map π
-- Mathlib/Combinatorics/SimpleGraph/Finite.lean
theorem neighborFinset_eq_filter {v : V} [DecidableRel G.Adj] :
    G.neighborFinset v = Finset.univ.filter (G.Adj v)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma dblZ_ne_zero_of_Y_ne' [NoZeroDivisors R] {P Q : Fin 3 → R} (hP : W'.Equation P)
    (hQ : W'.Equation Q) (hPz : P z ≠ 0) (hx : P x * Q z ^ 2 = Q x * P z ^ 2)
    (hy : P y * Q z ^ 3 ≠ W'.negY Q * P z ^ 3) : W'.dblZ P ≠ 0
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem max_min_distrib_right (a b c : Nat) :
    max (min a b) c = min (max a c) (max b c)
-- Mathlib/Topology/Instances/ENNReal.lean
theorem nhds_coe {r : ℝ≥0} : 𝓝 (r : ℝ≥0∞) = (𝓝 r).map (↑)
-- Mathlib/NumberTheory/PythagoreanTriples.lean
theorem even_odd_of_coprime (hc : Int.gcd x y = 1) :
    x % 2 = 0 ∧ y % 2 = 1 ∨ x % 2 = 1 ∧ y % 2 = 0
-- Mathlib/MeasureTheory/Measure/MutuallySingular.lean
@[simp]
lemma restrict_nullSet (h : μ ⟂ₘ ν) : μ.restrict h.nullSet = 0
-- Mathlib/CategoryTheory/Sites/OneHypercover.lean
/-- In order to check that a certain data is a `1`-hypercover of `S`, it suffices to
check that the data provides a covering of `S` and of the fibre products. -/
@[simps toPreOneHypercover]
def mk' {S : C} (E : PreOneHypercover S) [E.HasPullbacks]
    (mem₀ : E.sieve₀ ∈ J S) (mem₁' : ∀ (i₁ i₂ : E.I₀), E.sieve₁' i₁ i₂ ∈ J _) :
    J.OneHypercover S
-- Mathlib/Algebra/Homology/Homotopy.lean
@[simp 1100]
theorem prevD_comp_left (f : C ⟶ D) (g : ∀ i j, D.X i ⟶ E.X j) (j : ι) :
    (prevD j fun i j => f.f i ≫ g i j) = f.f j ≫ prevD j g
-- Mathlib/Topology/Order/DenselyOrdered.lean
@[simp]
theorem tendsto_Ioo_atBot {f : β → Ioo a b} :
    Tendsto f l atBot ↔ Tendsto (fun x => (f x : α)) l (𝓝[>] a)
-- Mathlib/LinearAlgebra/Matrix/Circulant.lean
theorem circulant_col_zero_eq [AddGroup n] (v : n → α) (i : n) : circulant v i 0 = v i
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem Monotone.const_mul [PosMulMono α]
    (hf : Monotone f) (ha : 0 ≤ a) : Monotone fun x => a * f x
-- Mathlib/Algebra/Field/Subfield.lean
@[simp, norm_cast]
theorem coe_add (x y : s) : (↑(x + y) : K) = ↑x + ↑y
-- Mathlib/Data/ENNReal/Real.lean
@[simp]
lemma one_le_ofReal {p : ℝ} : 1 ≤ ENNReal.ofReal p ↔ 1 ≤ p
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem coprime_of_lt_prime {n p} (n_pos : 0 < n) (hlt : n < p) (pp : Prime p) : Coprime p n
-- Mathlib/Data/Real/ConjExponents.lean
theorem sub_one_mul_conj : (p - 1) * q = p
-- Mathlib/RingTheory/WittVector/Identities.lean
theorem coeff_p_pow [CharP R p] (i : ℕ) : ((p : 𝕎 R) ^ i).coeff i = 1
-- Mathlib/Analysis/Calculus/Deriv/AffineMap.lean
theorem hasStrictDerivAt : HasStrictDerivAt f (f.linear 1) x
-- .lake/packages/lean4/src/lean/Init/Data/Option/Basic.lean
@[simp] theorem max_none_some [Max α] {b : α} : max none (some b) = some b
-- Mathlib/Order/Lattice.lean
theorem ite_le_sup (s s' : α) (P : Prop) [Decidable P] : ite P s s' ≤ s ⊔ s'
-- Mathlib/Topology/Algebra/MulAction.lean
/-- If an action is continuous, then composing this action with a continuous homomorphism gives
again a continuous action. -/
@[to_additive]
theorem MulAction.continuousSMul_compHom
    {N : Type*} [TopologicalSpace N] [Monoid N] {f : N →* M} (hf : Continuous f) :
    letI : MulAction N X := MulAction.compHom _ f
    ContinuousSMul N X
-- Mathlib/Logic/Equiv/Defs.lean
theorem psigmaCongrRight_symm {α} {β₁ β₂ : α → Sort*} (F : ∀ a, β₁ a ≃ β₂ a) :
    (psigmaCongrRight F).symm = psigmaCongrRight fun a => (F a).symm
-- Mathlib/GroupTheory/Solvable.lean
theorem solvable_of_ker_le_range {G' G'' : Type*} [Group G'] [Group G''] (f : G' →* G)
    (g : G →* G'') (hfg : g.ker ≤ f.range) [hG' : IsSolvable G'] [hG'' : IsSolvable G''] :
    IsSolvable G
-- Mathlib/Algebra/IsPrimePow.lean
theorem Nat.disjoint_divisors_filter_isPrimePow {a b : ℕ} (hab : a.Coprime b) :
    Disjoint (a.divisors.filter IsPrimePow) (b.divisors.filter IsPrimePow)
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
@[simp] lemma toUpperSet_ofUpperSet (a : WithUpperSet α) : toUpperSet (ofUpperSet a) = a
-- Mathlib/Data/FunLike/Basic.lean
/-- This is not an instance to avoid slowing down every single `Subsingleton` typeclass search. -/
lemma subsingleton_cod [∀ a, Subsingleton (β a)] : Subsingleton F
-- Mathlib/Geometry/Manifold/ContMDiff/NormedSpace.lean
theorem contMDiffWithinAt_iff_contDiffWithinAt {f : E → E'} {s : Set E} {x : E} :
    ContMDiffWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') n f s x ↔ ContDiffWithinAt 𝕜 n f s x
-- Mathlib/Combinatorics/SetFamily/LYM.lean
theorem slice_subset_falling : 𝒜 # k ⊆ falling k 𝒜
-- Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean
lemma dist_eq (x y : ULift β) : dist x y = dist x.down y.down
-- Mathlib/Order/Bounds/Basic.lean
/-- If `t` is bounded, then so is `s ∩ t` -/
theorem BddBelow.inter_of_right (h : BddBelow t) : BddBelow (s ∩ t)
-- Mathlib/Order/Heyting/Basic.lean
theorem Disjoint.sdiff_eq_left (h : Disjoint a b) : a \ b = a