ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Set/Function.lean
lemma MapsTo.prodMap (h₁ : MapsTo f₁ s₁ t₁) (h₂ : MapsTo f₂ s₂ t₂) :
    MapsTo (fun x ↦ (f₁ x.1, f₂ x.2)) (s₁ ×ˢ s₂) (t₁ ×ˢ t₂)
-- Mathlib/Order/Interval/Set/Basic.lean
theorem left_mem_Ico : a ∈ Ico a b ↔ a < b
-- Mathlib/Order/Interval/Set/WithBotTop.lean
theorem image_coe_Icc : (some : α → WithTop α) '' Icc a b = Icc (a : WithTop α) b
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nadd_lt_nadd_iff_left : ∀ (a) {b c}, a ♯ b < a ♯ c ↔ b < c
-- Mathlib/CategoryTheory/Whiskering.lean
/-- The right unitor, a natural isomorphism `(F ⋙ (𝟭 B)) ≅ F`.
-/
@[simps]
def rightUnitor (F : A ⥤ B) :
    F ⋙ 𝟭 B ≅ F
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem extChartAt_source_mem_nhds' {x x' : M} (h : x' ∈ (extChartAt I x).source) :
    (extChartAt I x).source ∈ 𝓝 x'
-- Mathlib/Algebra/Algebra/Subalgebra/Tower.lean
@[simp]
theorem mem_restrictScalars {U : Subalgebra S A} {x : A} : x ∈ restrictScalars R U ↔ x ∈ U
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
/-- If a measure `μ` on a quotient satisfies `QuotientMeasureEqMeasurePreimage` with respect to a
sigma-finite measure `ν`, then it is itself `SigmaFinite`. -/
@[to_additive]
lemma QuotientMeasureEqMeasurePreimage.sigmaFiniteQuotient
    [i : SigmaFinite ν] [i' : HasFundamentalDomain G α ν]
    (μ : Measure (Quotient α_mod_G)) [QuotientMeasureEqMeasurePreimage ν μ] :
    SigmaFinite μ
-- Mathlib/Data/List/Nodup.lean
theorem Nodup.erase [DecidableEq α] (a : α) : Nodup l → Nodup (l.erase a)
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[simp, fun_prop]
theorem Differentiable.smul (hc : Differentiable 𝕜 c) (hf : Differentiable 𝕜 f) :
    Differentiable 𝕜 fun y => c y • f y
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem ciInf_le' (f : ι → α) (i : ι) : iInf f ≤ f i
-- Mathlib/Order/Interval/Finset/Fin.lean
@[simp]
theorem map_valEmbedding_Ioc : (Ioc a b).map Fin.valEmbedding = Ioc ↑a ↑b
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
theorem sub_one_ne_zero : ζ - 1 ≠ 0
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
theorem lift_reindex
    (e : ι ≃ ι₂) (φ : MultilinearMap R (fun i ↦ s (e.symm i)) E) (x : ⨂[R] i, s i) :
    lift φ (reindex R s e x) = lift ((domDomCongrLinearEquiv' R R s _ e).symm φ) x
-- Mathlib/Data/Finset/Lattice.lean
theorem set_biInter_biUnion (s : Finset γ) (t : γ → Finset α) (f : α → Set β) :
    ⋂ y ∈ s.biUnion t, f y = ⋂ (x ∈ s) (y ∈ t x), f y
-- Mathlib/Analysis/Convex/Gauge.lean
/-- If `s` is a neighborhood of the origin, then `gauge s` is continuous at the origin.
See also `continuousAt_gauge`. -/
theorem continuousAt_gauge_zero (hs : s ∈ 𝓝 0) : ContinuousAt (gauge s) 0
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem DifferentiableAt.clm_apply (hc : DifferentiableAt 𝕜 c x) (hu : DifferentiableAt 𝕜 u x) :
    DifferentiableAt 𝕜 (fun y => (c y) (u y)) x
-- Mathlib/Order/CompleteLattice.lean
@[simp]
theorem iInf_eq_top : iInf s = ⊤ ↔ ∀ i, s i = ⊤
-- Mathlib/Order/Circular.lean
theorem btw_of_sbtw {a b c : α} (h : sbtw a b c) : btw a b c
-- Mathlib/Topology/Algebra/InfiniteSum/Defs.lean
@[to_additive]
theorem tprod_eq_one_of_not_multipliable (h : ¬Multipliable f) : ∏' b, f b = 1
-- Mathlib/Algebra/Group/UniqueProds.lean
@[to_additive]
theorem iff_card_le_one [DecidableEq G] (ha0 : a0 ∈ A) (hb0 : b0 ∈ B) :
    UniqueMul A B a0 b0 ↔ ((A ×ˢ B).filter (fun p ↦ p.1 * p.2 = a0 * b0)).card ≤ 1
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
@[simp]
theorem sameCycle_inv : SameCycle f⁻¹ x y ↔ SameCycle f x y
-- Mathlib/Analysis/Normed/Operator/Compact.lean
theorem compactOperator_topologicalClosure {𝕜₁ 𝕜₂ : Type*} [NontriviallyNormedField 𝕜₁]
    [NormedField 𝕜₂] {σ₁₂ : 𝕜₁ →+* 𝕜₂} {M₁ M₂ : Type*} [SeminormedAddCommGroup M₁]
    [AddCommGroup M₂] [NormedSpace 𝕜₁ M₁] [Module 𝕜₂ M₂] [UniformSpace M₂] [UniformAddGroup M₂]
    [ContinuousConstSMul 𝕜₂ M₂] [T2Space M₂] [CompleteSpace M₂] :
    (compactOperator σ₁₂ M₁ M₂).topologicalClosure = compactOperator σ₁₂ M₁ M₂
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma IsConj.ext {σ₁ σ₂ : K ≃ₐ[k] K} (h₁ : IsConj φ σ₁) (h₂ : IsConj φ σ₂) : σ₁ = σ₂
-- Mathlib/GroupTheory/GroupAction/ConjAct.lean
theorem toConjAct_one : toConjAct (1 : G) = 1
-- Mathlib/Order/RelSeries.lean
/--
If `a₀ -r→ a₁ -r→ ... -r→ aₙ` is an `r`-series and `a` is such that
`aᵢ -r→ a -r→ a_ᵢ₊₁`, then
`a₀ -r→ a₁ -r→ ... -r→ aᵢ -r→ a -r→ aᵢ₊₁ -r→ ... -r→ aₙ`
is another `r`-series
-/
@[simps]
def insertNth (p : RelSeries r) (i : Fin p.length) (a : α)
    (prev_connect : r (p (Fin.castSucc i)) a) (connect_next : r a (p i.succ)) : RelSeries r
-- Mathlib/Order/LiminfLimsup.lean
theorem HasBasis.liminf_eq_sSup_iUnion_iInter {ι ι' : Type*} {f : ι → α} {v : Filter ι}
    {p : ι' → Prop} {s : ι' → Set ι} (hv : v.HasBasis p s) :
    liminf f v = sSup (⋃ (j : Subtype p), ⋂ (i : s j), Iic (f i))
-- Mathlib/GroupTheory/QuotientGroup.lean
@[to_additive]
theorem comap_comap_center {H₁ : Subgroup G} [H₁.Normal] {H₂ : Subgroup (G ⧸ H₁)} [H₂.Normal] :
    ((Subgroup.center ((G ⧸ H₁) ⧸ H₂)).comap (mk' H₂)).comap (mk' H₁) =
      (Subgroup.center (G ⧸ H₂.comap (mk' H₁))).comap (mk' (H₂.comap (mk' H₁)))
-- Mathlib/Order/Filter/Extr.lean
theorem IsMinFilter.sup (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
    IsMinFilter (fun x => f x ⊔ g x) l a
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[to_additive]
theorem mul_iff_left [CommGroup β] [TopologicalGroup β] (hf : AEStronglyMeasurable f μ) :
    AEStronglyMeasurable (g * f) μ ↔ AEStronglyMeasurable g μ
-- Mathlib/LinearAlgebra/TensorProduct/DirectLimit.lean
@[simp] lemma directLimitLeft_tmul_of {i : ι} (g : G i) (m : M) :
    directLimitLeft f M (of _ _ _ _ _ g ⊗ₜ m) = of _ _ _ (f ▷ M) _ (g ⊗ₜ m)
-- Mathlib/Data/Fintype/Card.lean
theorem Finset.card_eq_of_equiv {s : Finset α} {t : Finset β} (i : s ≃ t) : s.card = t.card
-- Mathlib/Algebra/Order/Sub/Defs.lean
/-- See `add_tsub_cancel_right` for the equality if `ContravariantClass α α (+) (≤)`. -/
theorem add_tsub_le_right : a + b - b ≤ a
-- Mathlib/CategoryTheory/Equivalence.lean
/-- Compatibility of `changeFunctor` with the composition of isomorphisms of functors -/
theorem changeFunctor_trans (e : C ≌ D) {G G' : C ⥤ D} (iso₁ : e.functor ≅ G) (iso₂ : G ≅ G') :
    (e.changeFunctor iso₁).changeFunctor iso₂ = e.changeFunctor (iso₁ ≪≫ iso₂)
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
/-- An `L : Addsubgroup E` where `E` is a vector space over a normed field `K` is a `ℤ`-lattice if
it is discrete and spans `E` over `K`. -/
class IsZlattice (K : Type*) [NormedField K] {E : Type*} [NormedAddCommGroup E] [NormedSpace K E]
    (L : AddSubgroup E) [DiscreteTopology L] : Prop where
  /-- `L` spans the full space `E` over `K`. -/
  span_top : span K (L : Set E) = ⊤
-- Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
@[reassoc (attr := simp)]
lemma inr_f_snd_v (p : ℤ) :
    (inr φ).f p ≫ (snd φ).v p p (add_zero p) = 𝟙 _
-- Mathlib/Algebra/MvPolynomial/Equiv.lean
theorem finSuccEquiv_X_succ {j : Fin n} : finSuccEquiv R n (X j.succ) = Polynomial.C (X j)
-- Mathlib/Analysis/Convex/Intrinsic.lean
@[simp]
theorem intrinsicClosure_eq_closure : intrinsicClosure 𝕜 s = closure s
-- Mathlib/Topology/MetricSpace/Dilation.lean
theorem comp_apply (g : β →ᵈ γ) (f : α →ᵈ β) (x : α) : (g.comp f : α → γ) x = g (f x)
-- Mathlib/Data/List/Zip.lean
theorem lt_length_left_of_zipWith {f : α → β → γ} {i : ℕ} {l : List α} {l' : List β}
    (h : i < (zipWith f l l').length) : i < l.length
-- Mathlib/RingTheory/Kaehler/CotangentComplex.lean
lemma Hom.sub_one_tmul (f g : Hom P P') (x) :
    f.sub g (1 ⊗ₜ .D _ _ x) = Cotangent.mk (f.subToKer g x)
-- Mathlib/Combinatorics/SimpleGraph/Prod.lean
protected theorem Connected.ofBoxProdRight (h : (G □ H).Connected) : H.Connected
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp] lemma toFun_eq_coe (f : sInfHom α β) : f.toFun = f
-- Mathlib/Probability/Integration.lean
theorem lintegral_mul_eq_lintegral_mul_lintegral_of_indepFun'' (h_meas_f : AEMeasurable f μ)
    (h_meas_g : AEMeasurable g μ) (h_indep_fun : IndepFun f g μ) :
    ∫⁻ ω, f ω * g ω ∂μ = (∫⁻ ω, f ω ∂μ) * ∫⁻ ω, g ω ∂μ
-- Mathlib/Algebra/Group/Hom/End.lean
lemma AddMonoidHom.mulRight_eq_mulLeft_iff_forall_commute {b : R} :
    mulRight b = mulLeft b ↔ ∀ a, Commute a b
-- Mathlib/Data/Rat/Lemmas.lean
theorem substr_num_den' (q r : ℚ) :
    (q - r).num * q.den * r.den = (q.num * r.den - r.num * q.den) * (q - r).den
-- Mathlib/Topology/Algebra/InfiniteSum/Ring.lean
theorem hasSum_mul_right_iff (h : a₂ ≠ 0) : HasSum (fun i ↦ f i * a₂) (a₁ * a₂) ↔ HasSum f a₁
-- Mathlib/Data/Complex/Exponential.lean
lemma exp_nonneg (x : ℝ) : 0 ≤ exp x
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- The identity is `C^∞`.
-/
theorem contDiff_id : ContDiff 𝕜 n (id : E → E)
-- Mathlib/Geometry/Manifold/Instances/Sphere.lean
/-- Consider the differential of the inclusion of the sphere in `E` at the point `v` as a continuous
linear map from `TangentSpace (𝓡 n) v` to `E`.  This map is injective. -/
theorem mfderiv_coe_sphere_injective {n : ℕ} [Fact (finrank ℝ E = n + 1)] (v : sphere (0 : E) 1) :
    Injective (mfderiv (𝓡 n) 𝓘(ℝ, E) ((↑) : sphere (0 : E) 1 → E) v)
-- Mathlib/RingTheory/AdicCompletion/Functoriality.lean
@[simp]
theorem congr_apply (f : M ≃ₗ[R] N) (x : AdicCompletion I M) :
    congr I f x = map I f x
-- Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean
theorem candidatesBOfCandidates_mem (f : ProdSpaceFun X Y) (fA : f ∈ candidates X Y) :
    candidatesBOfCandidates f fA ∈ candidatesB X Y
-- Mathlib/Data/Matrix/Kronecker.lean
theorem one_kronecker_one [MulZeroOneClass α] [DecidableEq m] [DecidableEq n] :
    (1 : Matrix m m α) ⊗ₖ (1 : Matrix n n α) = 1
-- Mathlib/Order/Max.lean
theorem noTopOrder_iff_noMaxOrder (α : Type*) [LinearOrder α] : NoTopOrder α ↔ NoMaxOrder α
-- Mathlib/Topology/Algebra/Star.lean
theorem continuousWithinAt_star {s : Set R} {x : R} : ContinuousWithinAt star s x
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem lt_of_sub_neg {a b : Int} (h : a - b < 0) : a < b
-- Mathlib/Algebra/Quaternion.lean
@[simp]
theorem im_imJ : a.im.imJ = a.imJ
-- Mathlib/RingTheory/Binomial.lean
theorem descPochhammer_eq_factorial_smul_choose [NatPowAssoc R] (r : R) (n : ℕ) :
    (descPochhammer ℤ n).smeval r = n.factorial • choose r n
-- Mathlib/Data/Sum/Basic.lean
@[simp]
theorem update_inl_comp_inr [DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : α} {x : γ} :
    update f (inl i) x ∘ inr = f ∘ inr
-- Mathlib/Logic/Equiv/Defs.lean
@[simp] theorem cast_symm {α β} (h : α = β) : (Equiv.cast h).symm = Equiv.cast h.symm
-- Mathlib/Data/Matroid/Constructions.lean
@[simp] theorem freeOn_base_iff : (freeOn E).Base B ↔ B = E
-- Mathlib/LinearAlgebra/Dual.lean
theorem total_dualBasis (f : ι →₀ R) (i : ι) :
    Finsupp.total ι (Dual R M) R b.dualBasis f (b i) = f i
-- Mathlib/NumberTheory/SmoothNumbers.lean
/-- A number that divides an `s`-factored number is itself `s`-factored. -/
lemma mem_factoredNumbers_of_dvd {s : Finset ℕ} {m k : ℕ} (h : m ∈ factoredNumbers s)
    (h' : k ∣ m) :
    k ∈ factoredNumbers s
-- Mathlib/Analysis/Quaternion.lean
@[simp, norm_cast]
theorem nnnorm_coe (a : ℝ) : ‖(a : ℍ)‖₊ = ‖a‖₊
-- Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean
@[reassoc]
theorem leftUnitor_tensor'' (X Y : C) :
    (α_ (𝟙_ C) X Y).hom ≫ (λ_ (X ⊗ Y)).hom = (λ_ X).hom ⊗ 𝟙 Y
-- Mathlib/Algebra/Group/Submonoid/Units.lean
@[to_additive]
lemma Submonoid.units_mono : Monotone (Submonoid.units (M := M))
-- Mathlib/Tactic/Linarith/Lemmas.lean
theorem eq_of_eq_of_eq {α} [OrderedSemiring α] {a b : α} (ha : a = 0) (hb : b = 0) : a + b = 0
-- Mathlib/Topology/Order/IsLUB.lean
theorem IsLUB.mem_of_isClosed {a : α} {s : Set α} (ha : IsLUB s a) (hs : s.Nonempty)
    (sc : IsClosed s) : a ∈ s
-- Mathlib/Data/Nat/ModEq.lean
theorem le_mod_add_mod_of_dvd_add_of_not_dvd {a b c : ℕ} (h : c ∣ a + b) (ha : ¬c ∣ a) :
    c ≤ a % c + b % c
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem curry_apply (f : α × β →o γ) (x : α) (y : β) : curry f x y = f (x, y)
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
/-- When a function has a limit at infinity `l`, and its derivative is nonnegative, then the
integral of the derivative on `(a, +∞)` is `l - g a` (and the derivative is integrable, see
`integrable_on_Ioi_deriv_of_nonneg`). Version assuming differentiability on `(a, +∞)` and
continuity at `a⁺`. -/
theorem integral_Ioi_of_hasDerivAt_of_nonneg (hcont : ContinuousWithinAt g (Ici a) a)
    (hderiv : ∀ x ∈ Ioi a, HasDerivAt g (g' x) x) (g'pos : ∀ x ∈ Ioi a, 0 ≤ g' x)
    (hg : Tendsto g atTop (𝓝 l)) : ∫ x in Ioi a, g' x = l - g a
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem integrable_inv_smul_measure {f : α → β} {c : ℝ≥0∞} (h₁ : c ≠ 0) (h₂ : c ≠ ∞) :
    Integrable f (c⁻¹ • μ) ↔ Integrable f μ
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
/-- A version of `WithBot.map` for `OneHom`s. -/
@[to_additive (attr := simps (config := .asFn))
  "A version of `WithBot.map` for `ZeroHom`s"]
protected def _root_.OneHom.withBotMap {M N : Type*} [One M] [One N] (f : OneHom M N) :
    OneHom (WithBot M) (WithBot N)
-- Mathlib/Order/UpperLower/Basic.lean
lemma IsLowerSet.isUpperSet_preimage_coe (hs : IsLowerSet s) :
    IsUpperSet ((↑) ⁻¹' t : Set s) ↔ ∀ b ∈ s, ∀ c ∈ t, c ≤ b → b ∈ t
-- Mathlib/Analysis/Convex/Strict.lean
theorem strictConvex_iff_openSegment_subset :
    StrictConvex 𝕜 s ↔ s.Pairwise fun x y => openSegment 𝕜 x y ⊆ interior s
-- Mathlib/Algebra/CubicDiscriminant.lean
@[simp]
theorem leadingCoeff_of_b_ne_zero (ha : P.a = 0) (hb : P.b ≠ 0) : P.toPoly.leadingCoeff = P.b
-- Mathlib/RingTheory/WittVector/MulCoeff.lean
theorem remainder_vars (n : ℕ) : (remainder p n).vars ⊆ univ ×ˢ range (n + 1)
-- Mathlib/Order/Basic.lean
theorem ne' [Preorder α] {x y : α} (h : x < y) : y ≠ x
-- Mathlib/Analysis/CstarAlgebra/Basic.lean
theorem norm_star_mul_self {x : E} : ‖x⋆ * x‖ = ‖x‖ * ‖x‖
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem differentiable_cosh : Differentiable ℂ cosh
-- Mathlib/Probability/Process/Stopping.lean
theorem stoppedValue_stoppedProcess {u : ι → Ω → β} {τ σ : Ω → ι} :
    stoppedValue (stoppedProcess u τ) σ = stoppedValue u fun ω => min (σ ω) (τ ω)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem mem_toSubmonoid (K : Subgroup G) (x : G) : x ∈ K.toSubmonoid ↔ x ∈ K
-- Mathlib/LinearAlgebra/TensorAlgebra/ToTensorPower.lean
theorem toDirectSum_tensorPower_tprod {n} (x : Fin n → M) :
    toDirectSum (tprod R M n x) = DirectSum.of _ n (PiTensorProduct.tprod R x)
-- Mathlib/Topology/MetricSpace/Dilation.lean
@[simp]
theorem id_comp (f : α →ᵈ β) : (Dilation.id β).comp f = f
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[simp]
theorem closure_empty : closure (∅ : Set R) = ⊥
-- Mathlib/Order/Basic.lean
lemma ltTrichotomy_ne (h : x ≠ y) :
    ltTrichotomy x y p q r = if x < y then p else r
-- Mathlib/Order/Basic.lean
@[simp]
theorem Pi.sdiff_apply [∀ i, SDiff (π i)] (x y : ∀ i, π i) (i : ι) :
    (x \ y) i = x i \ y i
-- Mathlib/ModelTheory/Basic.lean
theorem ext_iff {f g : M ↪[L] N} : f = g ↔ ∀ x, f x = g x
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem Metric.cobounded_eq_cocompact [ProperSpace α] : cobounded α = cocompact α
-- Mathlib/Order/JordanHolder.lean
theorem IsMaximal.iso_refl {x y : X} (h : IsMaximal x y) : Iso (x, y) (x, y)
-- Mathlib/NumberTheory/PythagoreanTriples.lean
private theorem coprime_sq_sub_mul {m n : ℤ} (h : Int.gcd m n = 1)
    (hmn : m % 2 = 0 ∧ n % 2 = 1 ∨ m % 2 = 1 ∧ n % 2 = 0) :
    Int.gcd (m ^ 2 - n ^ 2) (2 * m * n) = 1
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
@[simp]
theorem map_add_int (x : ℝ) (m : ℤ) : f (x + m) = f x + m
-- Mathlib/RingTheory/Flat/Algebra.lean
/-- A ring homomorphism `f : R →+* S` is flat if `S` is flat as an `R` algebra. -/
class RingHom.Flat {R : Type u} {S : Type v} [CommRing R] [CommRing S] (f : R →+* S) : Prop where
  out : f.toAlgebra.Flat := by infer_instance
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
@[reassoc] -- Porting note (#10618): simp can prove this, removed attribute
theorem π_desc (W : C) (k : ∀ b, I.right b ⟶ W)
    (h : ∀ a, I.fst a ≫ k (I.fstFrom a) = I.snd a ≫ k (I.sndFrom a)) (b) :
    Multicoequalizer.π I b ≫ Multicoequalizer.desc I _ k h = k _
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
theorem uniformEquicontinuous_iInf_rng {u : κ → UniformSpace α'} {F : ι → β → α'} :
    UniformEquicontinuous (uα := ⨅ k, u k) F ↔ ∀ k, UniformEquicontinuous (uα := u k) F
-- Mathlib/RingTheory/Localization/Away/Basic.lean
@[simp]
theorem selfZPow_natCast (d : ℕ) : selfZPow x B d = algebraMap R B x ^ d
-- Mathlib/Algebra/DirectSum/Basic.lean
@[simp]
theorem coeAddMonoidHom_of {M S : Type*} [DecidableEq ι] [AddCommMonoid M] [SetLike S M]
    [AddSubmonoidClass S M] (A : ι → S) (i : ι) (x : A i) :
    DirectSum.coeAddMonoidHom A (of (fun i => A i) i x) = x
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Div.lean
theorem mul_sub_div (x n p : Nat) (h₁ : x < n*p) : (n * p - (x + 1)) / n = p - ((x / n) + 1)
-- Mathlib/Analysis/Calculus/FDeriv/Pi.lean
@[fun_prop]
theorem hasFDerivAt_update (x : ∀ i, E i) {i : ι} (y : E i) :
    HasFDerivAt (Function.update x i) (.pi (Pi.single i (.id 𝕜 (E i)))) y
-- Mathlib/Data/Finset/Density.lean
lemma dens_ne_zero : dens s ≠ 0 ↔ s.Nonempty
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem nfpBFamily_eq_nfpFamily {o : Ordinal} (f : ∀ b < o, Ordinal → Ordinal) :
    nfpBFamily.{u, v} o f = nfpFamily.{u, v} (familyOfBFamily o f)
-- Mathlib/SetTheory/Game/PGame.lean
theorem add_lf_add_of_lf_of_le {w x y z : PGame} (hwx : w ⧏ x) (hyz : y ≤ z) : w + y ⧏ x + z
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
theorem normalCore_idempotent (H : Subgroup G) : H.normalCore.normalCore = H.normalCore
-- Mathlib/Data/Finsupp/Basic.lean
theorem equivMapDomain_trans (f : α ≃ β) (g : β ≃ γ) (l : α →₀ M) :
    equivMapDomain (f.trans g) l = equivMapDomain g (equivMapDomain f l)
-- Mathlib/Analysis/Calculus/Deriv/Slope.lean
theorem hasDerivAt_iff_tendsto_slope_zero :
    HasDerivAt f f' x ↔ Tendsto (fun t ↦ t⁻¹ • (f (x + t) - f x)) (𝓝[≠] 0) (𝓝 f')
-- Mathlib/Algebra/Order/Group/Action.lean
theorem smul_inf_le [SMul M α] [SemilatticeInf α] [CovariantClass M α HSMul.hSMul LE.le]
    (m : M) (a₁ a₂ : α) : m • (a₁ ⊓ a₂) ≤ m • a₁ ⊓ m • a₂
-- Mathlib/Data/Option/Basic.lean
theorem bind_congr {f g : α → Option β} {x : Option α}
    (h : ∀ a ∈ x, f a = g a) : x.bind f = x.bind g
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem image_const_sub_Ico : (fun x => a - x) '' Ico b c = Ioc (a - c) (a - b)
-- Mathlib/Topology/ContinuousFunction/ZeroAtInfty.lean
theorem zero_apply [Zero β] : (0 : C₀(α, β)) x = 0
-- Mathlib/Topology/Algebra/Monoid.lean
@[to_additive]
theorem Continuous.units_map [Monoid M] [Monoid N] [TopologicalSpace M] [TopologicalSpace N]
    (f : M →* N) (hf : Continuous f) : Continuous (Units.map f)
-- Mathlib/Algebra/Order/AbsoluteValue.lean
protected theorem map_mul (x y : R) : abv (x * y) = abv x * abv y
-- Mathlib/Data/Set/Image.lean
theorem range_eq {α β} (f : Option α → β) : range f = insert (f none) (range (f ∘ some))
-- Mathlib/Algebra/Group/Action/Basic.lean
@[to_additive]
lemma smul_left_cancel (g : α) {x y : β} (h : g • x = g • y) : x = y
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp (default + 1))]
lemma sup_mul_le [SemilatticeSup β] [OrderBot β] {s t : Finset α} {f : α → β} {a : β} :
    sup (s * t) f ≤ a ↔ ∀ x ∈ s, ∀ y ∈ t, f (x * y) ≤ a
-- Mathlib/GroupTheory/GroupAction/Blocks.lean
theorem IsBlock.preimage {H Y : Type*} [Group H] [MulAction H Y]
    {φ : H → G} (j : Y →ₑ[φ] X) {B : Set X} (hB : IsBlock G B) :
    IsBlock H (j ⁻¹' B)
-- Mathlib/Data/Set/Function.lean
lemma MapsTo.comp_right {s : Set β} {t : Set γ} (hg : MapsTo g s t) (f : α → β) :
    MapsTo (g ∘ f) (f ⁻¹' s) t
-- Mathlib/Topology/Defs/Filter.lean
/-- A set is called a neighborhood of `x` if it contains an open set around `x`. The set of all
neighborhoods of `x` forms a filter, the neighborhood filter at `x`, is here defined as the
infimum over the principal filters of all open sets containing `x`. -/
irreducible_def nhds (x : X) : Filter X
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem foldlM_eq_foldlM_data.aux [Monad m]
    (f : β → α → m β) (arr : Array α) (i j) (H : arr.size ≤ i + j) (b) :
    foldlM.loop f arr arr.size (Nat.le_refl _) i j b = (arr.data.drop j).foldlM f b
-- Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
@[simp, norm_cast]
theorem lift_add : (↑(X + Y) : Derivation 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯) = X + Y
-- Mathlib/Algebra/Divisibility/Basic.lean
@[simp]
theorem dvd_mul_right (a b : α) : a ∣ a * b
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem smul_subset_iff : s • t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a • b ∈ u
-- Mathlib/CategoryTheory/Category/Grpd.lean
/-- Converts identity in the category of groupoids to the functor identity -/
theorem id_to_functor {C : Grpd.{v, u}} : 𝟭 C = 𝟙 C
-- Mathlib/Data/Fin/Basic.lean
theorem eq_castSucc_or_eq_last {n : Nat} (i : Fin (n + 1)) :
    (∃ j : Fin n, i = j.castSucc) ∨ i = last n
-- Mathlib/Analysis/Complex/PhragmenLindelof.lean
/-- **Phragmen-Lindelöf principle** in the fourth quadrant. Let `f : ℂ → E` be a function such that

* `f` is differentiable in the open fourth quadrant and is continuous on its closure;
* `‖f z‖` is bounded from above by `A * exp(B * (abs z) ^ c)` on the open fourth quadrant
  for some `c < 2`;
* `‖f z‖` is bounded from above by a constant `C` on the boundary of the fourth quadrant.

Then `‖f z‖` is bounded from above by the same constant on the closed fourth quadrant. -/
theorem quadrant_IV (hd : DiffContOnCl ℂ f (Ioi 0 ×ℂ Iio 0))
    (hB : ∃ c < (2 : ℝ), ∃ B,
      f =O[cobounded ℂ ⊓ 𝓟 (Ioi 0 ×ℂ Iio 0)] fun z => expR (B * abs z ^ c))
    (hre : ∀ x : ℝ, 0 ≤ x → ‖f x‖ ≤ C) (him : ∀ x : ℝ, x ≤ 0 → ‖f (x * I)‖ ≤ C) (hz_re : 0 ≤ z.re)
    (hz_im : z.im ≤ 0) : ‖f z‖ ≤ C
-- Mathlib/RingTheory/PowerSeries/Trunc.lean
theorem trunc_succ (f : R⟦X⟧) (n : ℕ) :
    trunc n.succ f = trunc n f + Polynomial.monomial n (coeff R n f)
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem mul_lt_mul_of_le_of_lt_of_pos_of_nonneg [PosMulStrictMono α] [MulPosMono α]
    (h₁ : a ≤ b) (h₂ : c < d) (a0 : 0 < a) (d0 : 0 ≤ d) : a * c < b * d
-- Mathlib/Algebra/Lie/Semisimple/Basic.lean
lemma eq_top_of_isAtom (I : LieIdeal R L) (hI : IsAtom I) : I = ⊤
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem insert_diff_of_mem (s) (h : a ∈ t) : insert a s \ t = s \ t
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.sup {ι ι' : Type*} {p : ι → Prop} {s : ι → Set α} {p' : ι' → Prop}
    {s' : ι' → Set α} (hl : l.HasBasis p s) (hl' : l'.HasBasis p' s') :
    (l ⊔ l').HasBasis (fun i : ι × ι' => p i.1 ∧ p' i.2) fun i => s i.1 ∪ s' i.2
-- Mathlib/Algebra/Algebra/Quasispectrum.lean
@[simp]
theorem quasispectrum.preimage_algebraMap (S : Type*) {R A : Type*} [Semifield R] [Field S]
    [NonUnitalRing A] [Algebra R S] [Module S A] [IsScalarTower S A A]
    [SMulCommClass S A A] [Module R A] [IsScalarTower R S A] {a : A} :
    algebraMap R S ⁻¹' quasispectrum S a = quasispectrum R a
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem SigmaFinite.out (h : SigmaFinite μ) : Nonempty (μ.FiniteSpanningSetsIn univ)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem mem_merge_left (s : α → α → Bool) (h : x ∈ l) : x ∈ merge s l r
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem le_trans {a b c : Int} (h₁ : a ≤ b) (h₂ : b ≤ c) : a ≤ c
-- Mathlib/SetTheory/ZFC/Basic.lean
@[refl]
protected theorem Equiv.refl : ∀ x, Equiv x x
-- Mathlib/Topology/Order/LawsonTopology.lean
@[simp] lemma toLawson_ofLawson (a : WithLawson α) : toLawson (ofLawson a) = a