ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Analysis/Normed/Operator/BanachSteinhaus.lean

full_name: banach_steinhaus
code: /-- This is the standard Banach-Steinhaus theorem, or Uniform Boundedness Principle.
If a family of continuous linear maps from a Banach space into a normed space is pointwise
bounded, then the norms of these linear maps are uniformly bounded.

See also `WithSeminorms.banach_steinhaus` for the general statement in barrelled spaces. -/
theorem banach_steinhaus {ι : Type*} [CompleteSpace E] {g : ι → E →SL[σ₁₂] F}
    (h : ∀ x, ∃ C, ∀ i, ‖g i x‖ ≤ C) : ∃ C', ∀ i, ‖g i‖ ≤ C' 
goal: ∃ C', ∀ (i : ι), ‖g i‖ ≤ C'

full_name: banach_steinhaus_iSup_nnnorm
code: /-- This version of Banach-Steinhaus is stated in terms of suprema of `↑‖·‖₊ : ℝ≥0∞`
for convenience. -/
theorem banach_steinhaus_iSup_nnnorm {ι : Type*} [CompleteSpace E] {g : ι → E →SL[σ₁₂] F}
    (h : ∀ x, (⨆ i, ↑‖g i x‖₊) < ∞) : (⨆ i, ↑‖g i‖₊) < ∞ 
goal: ⨆ i, ↑‖g i‖₊ < ⊤

full_name: continuousLinearMapOfTendsto
code: /-- Given a *sequence* of continuous linear maps which converges pointwise and for which the
domain is complete, the Banach-Steinhaus theorem is used to guarantee that the limit map
is a *continuous* linear map as well. -/
abbrev continuousLinearMapOfTendsto {α : Type*} [CompleteSpace E] [T2Space F] {l : Filter α}
    [l.IsCountablyGenerated] [l.NeBot] (g : α → E →SL[σ₁₂] F) {f : E → F}
    (h : Tendsto (fun n x ↦ g n x) l (𝓝 f)) :
    E →SL[σ₁₂] F 
goal: E →SL[σ₁₂] F
File: Mathlib/Analysis/Normed/Group/Lemmas.lean

full_name: eventually_nnnorm_sub_lt
code: theorem eventually_nnnorm_sub_lt (x₀ : E) {ε : ℝ≥0} (ε_pos : 0 < ε) :
    ∀ᶠ x in 𝓝 x₀, ‖x - x₀‖₊ < ε 
goal: ∀ᶠ (x : E) in 𝓝 x₀, ‖x - x₀‖₊ < ε

full_name: eventually_norm_sub_lt
code: theorem eventually_norm_sub_lt (x₀ : E) {ε : ℝ} (ε_pos : 0 < ε) :
    ∀ᶠ x in 𝓝 x₀, ‖x - x₀‖ < ε 
goal: ∀ᶠ (x : E) in 𝓝 x₀, ‖x - x₀‖ < ε
File: Mathlib/Analysis/Normed/Group/Int.lean

full_name: Int.instNormedAddCommGroup
code: instance instNormedAddCommGroup : NormedAddCommGroup ℤ 
goal: NormedAddCommGroup ℤ

full_name: Int.norm_cast_real
code: @[norm_cast]
theorem norm_cast_real (m : ℤ) : ‖(m : ℝ)‖ = ‖m‖ 
goal: ‖↑m‖ = ‖m‖

full_name: Int.norm_eq_abs
code: theorem norm_eq_abs (n : ℤ) : ‖n‖ = |(n : ℝ)| 
goal: ‖n‖ = |↑n|

full_name: Int.norm_natCast
code: @[simp]
theorem norm_natCast (n : ℕ) : ‖(n : ℤ)‖ = n 
goal: ‖↑n‖ = ↑n

full_name: NNReal.natCast_natAbs
code: theorem _root_.NNReal.natCast_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ 
goal: ↑n.natAbs = ‖n‖₊

full_name: Int.abs_le_floor_nnreal_iff
code: theorem abs_le_floor_nnreal_iff (z : ℤ) (c : ℝ≥0) : |z| ≤ ⌊c⌋₊ ↔ ‖z‖₊ ≤ c 
goal: |z| ≤ ↑⌊c⌋₊ ↔ ‖z‖₊ ≤ c

full_name: norm_zsmul_le
code: @[to_additive norm_zsmul_le]
theorem norm_zpow_le_mul_norm (n : ℤ) (a : α) : ‖a ^ n‖ ≤ ‖n‖ * ‖a‖ 
goal: ‖n • a‖ ≤ ‖n‖ * ‖a‖

full_name: norm_zpow_le_mul_norm
code: @[to_additive norm_zsmul_le]
theorem norm_zpow_le_mul_norm (n : ℤ) (a : α) : ‖a ^ n‖ ≤ ‖n‖ * ‖a‖ 
goal: ‖a ^ n‖ ≤ ‖n‖ * ‖a‖

full_name: nnnorm_zpow_le_mul_norm
code: @[to_additive nnnorm_zsmul_le]
theorem nnnorm_zpow_le_mul_norm (n : ℤ) (a : α) : ‖a ^ n‖₊ ≤ ‖n‖₊ * ‖a‖₊ 
goal: ‖a ^ n‖₊ ≤ ‖n‖₊ * ‖a‖₊

full_name: nnnorm_zsmul_le
code: @[to_additive nnnorm_zsmul_le]
theorem nnnorm_zpow_le_mul_norm (n : ℤ) (a : α) : ‖a ^ n‖₊ ≤ ‖n‖₊ * ‖a‖₊ 
goal: ‖n • a‖₊ ≤ ‖n‖₊ * ‖a‖₊
File: Mathlib/Analysis/Normed/Group/BallSphere.lean

full_name: instInvolutiveNegElemSphereOfNat
code: /-- We equip the sphere, in a seminormed group, with a formal operation of negation, namely the
antipodal map. -/
instance : InvolutiveNeg (sphere (0 : E) r) 
goal: InvolutiveNeg ↑(Metric.sphere 0 r)

full_name: coe_neg_sphere
code: @[simp]
theorem coe_neg_sphere {r : ℝ} (v : sphere (0 : E) r) : ↑(-v) = (-v : E) 
goal: ↑(-v) = -↑v

full_name: instContinuousNegElemSphereOfNat
code: instance : ContinuousNeg (sphere (0 : E) r) 
goal: ContinuousNeg ↑(Metric.sphere 0 r)

full_name: instInvolutiveNegElemBallOfNat
code: /-- We equip the ball, in a seminormed group, with a formal operation of negation, namely the
antipodal map. -/
instance {r : ℝ} : InvolutiveNeg (ball (0 : E) r) 
goal: InvolutiveNeg ↑(Metric.ball 0 r)

full_name: coe_neg_ball
code: @[simp] theorem coe_neg_ball {r : ℝ} (v : ball (0 : E) r) : ↑(-v) = (-v : E) 
goal: ↑(-v) = -↑v

full_name: instContinuousNegElemBallOfNat
code: instance : ContinuousNeg (ball (0 : E) r) 
goal: ContinuousNeg ↑(Metric.ball 0 r)

full_name: instInvolutiveNegElemClosedBallOfNat
code: /-- We equip the closed ball, in a seminormed group, with a formal operation of negation, namely the
antipodal map. -/
instance {r : ℝ} : InvolutiveNeg (closedBall (0 : E) r) 
goal: InvolutiveNeg ↑(Metric.closedBall 0 r)

full_name: coe_neg_closedBall
code: @[simp] theorem coe_neg_closedBall {r : ℝ} (v : closedBall (0 : E) r) : ↑(-v) = (-v : E) 
goal: ↑(-v) = -↑v

full_name: instContinuousNegElemClosedBallOfNat
code: instance : ContinuousNeg (closedBall (0 : E) r) 
goal: ContinuousNeg ↑(Metric.closedBall 0 r)
File: Mathlib/Analysis/Normed/Group/Rat.lean

full_name: Rat.instNormedAddCommGroup
code: instance instNormedAddCommGroup : NormedAddCommGroup ℚ 
goal: NormedAddCommGroup ℚ

full_name: Rat.norm_cast_real
code: @[norm_cast, simp 1001]
-- Porting note: increase priority to prevent the left-hand side from simplifying
theorem norm_cast_real (r : ℚ) : ‖(r : ℝ)‖ = ‖r‖ 
goal: ‖↑r‖ = ‖r‖

full_name: Int.norm_cast_rat
code: @[norm_cast, simp]
theorem _root_.Int.norm_cast_rat (m : ℤ) : ‖(m : ℚ)‖ = ‖m‖ 
goal: ‖↑m‖ = ‖m‖
File: Mathlib/Analysis/Normed/Group/Tannery.lean

full_name: tendsto_tsum_of_dominated_convergence
code: /-- **Tannery's theorem**: topological sums commute with termwise limits, when the norms of the
summands are eventually uniformly bounded by a summable function.

(This is the special case of the Lebesgue dominated convergence theorem for the counting measure
on a discrete set. However, we prove it under somewhat weaker assumptions than the general
measure-theoretic result, e.g. `G` is not assumed to be an `ℝ`-vector space or second countable,
and the limit is along an arbitrary filter rather than `atTop ℕ`.)

See also:
* `MeasureTheory.tendsto_integral_of_dominated_convergence` (for general integrals, but
  with more assumptions on `G`)
* `continuous_tsum` (continuity of infinite sums in a parameter)
-/
lemma tendsto_tsum_of_dominated_convergence {α β G : Type*} {𝓕 : Filter α}
    [NormedAddCommGroup G] [CompleteSpace G]
    {f : α → β → G} {g : β → G} {bound : β → ℝ} (h_sum : Summable bound)
    (hab : ∀ k : β, Tendsto (f · k) 𝓕 (𝓝 (g k)))
    (h_bound : ∀ᶠ n in 𝓕, ∀ k, ‖f n k‖ ≤ bound k) :
    Tendsto (∑' k, f · k) 𝓕 (𝓝 (∑' k, g k)) 
goal: Filter.Tendsto (fun x => ∑' (k : β), f x k) 𝓕 (𝓝 (∑' (k : β), g k))
File: Mathlib/Analysis/Normed/Group/CocompactMap.lean

full_name: CocompactMapClass.norm_le
code: theorem CocompactMapClass.norm_le [FunLike 𝓕 E F] [CocompactMapClass 𝓕 E F] (ε : ℝ) :
    ∃ r : ℝ, ∀ x : E, r < ‖x‖ → ε < ‖f x‖ 
goal: ∃ r, ∀ (x : E), r < ‖x‖ → ε < ‖f x‖

full_name: Filter.tendsto_cocompact_cocompact_of_norm
code: theorem Filter.tendsto_cocompact_cocompact_of_norm {f : E → F}
    (h : ∀ ε : ℝ, ∃ r : ℝ, ∀ x : E, r < ‖x‖ → ε < ‖f x‖) :
    Tendsto f (cocompact E) (cocompact F) 
goal: Filter.Tendsto f (Filter.cocompact E) (Filter.cocompact F)

full_name: ContinuousMapClass.toCocompactMapClass_of_norm
code: theorem ContinuousMapClass.toCocompactMapClass_of_norm [FunLike 𝓕 E F] [ContinuousMapClass 𝓕 E F]
    (h : ∀ (f : 𝓕) (ε : ℝ), ∃ r : ℝ, ∀ x : E, r < ‖x‖ → ε < ‖f x‖) :
    CocompactMapClass 𝓕 E F 
goal: CocompactMapClass 𝓕 E F
File: Mathlib/Analysis/Normed/Group/Completeness.lean

full_name: Metric.exists_subseq_summable_dist_of_cauchySeq
code: lemma Metric.exists_subseq_summable_dist_of_cauchySeq (u : ℕ → α) (hu : CauchySeq u) :
    ∃ f : ℕ → ℕ, StrictMono f ∧ Summable fun i => dist (u (f (i+1))) (u (f i)) 
goal: ∃ f, StrictMono f ∧ Summable fun i => dist (u (f (i + 1))) (u (f i))

full_name: NormedAddCommGroup.completeSpace_of_summable_imp_tendsto
code: /-- A normed additive group is complete if any absolutely convergent series converges in the
space.  -/
lemma NormedAddCommGroup.completeSpace_of_summable_imp_tendsto
    (h : ∀ u : ℕ → E,
      Summable (‖u ·‖) → ∃ a, Tendsto (fun n => ∑ i ∈ range n, u i) atTop (𝓝 a)) :
    CompleteSpace E 
goal: CompleteSpace E

full_name: NormedAddCommGroup.summable_imp_tendsto_of_complete
code: /-- In a complete normed additive group, every absolutely convergent series converges in the
space.  -/
lemma NormedAddCommGroup.summable_imp_tendsto_of_complete [CompleteSpace E] (u : ℕ → E)
    (hu : Summable (‖u ·‖)) : ∃ a, Tendsto (fun n => ∑ i ∈ range n, u i) atTop (𝓝 a) 
goal: ∃ a, Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, u i) Filter.atTop (𝓝 a)

full_name: NormedAddCommGroup.summable_imp_tendsto_iff_completeSpace
code: /-- In a normed additive group, every absolutely convergent series converges in the
space iff the space is complete.  -/
lemma NormedAddCommGroup.summable_imp_tendsto_iff_completeSpace :
    (∀ u : ℕ → E, Summable (‖u ·‖) → ∃ a, Tendsto (fun n => ∑ i ∈ range n, u i) atTop (𝓝 a))
     ↔ CompleteSpace E 
goal: (∀ (u : ℕ → E),
    (Summable fun x => ‖u x‖) → ∃ a, Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, u i) Filter.atTop (𝓝 a)) ↔
  CompleteSpace E
File: Mathlib/Analysis/Normed/Group/Completion.lean

full_name: UniformSpace.Completion.instNorm
code: instance [UniformSpace E] [Norm E] : Norm (Completion E) 
goal: Norm (UniformSpace.Completion E)

full_name: UniformSpace.Completion.norm_coe
code: @[simp]
theorem norm_coe {E} [SeminormedAddCommGroup E] (x : E) : ‖(x : Completion E)‖ = ‖x‖ 
goal: ‖↑E x‖ = ‖x‖

full_name: UniformSpace.Completion.instNormedAddCommGroup
code: instance [SeminormedAddCommGroup E] : NormedAddCommGroup (Completion E) 
goal: NormedAddCommGroup (UniformSpace.Completion E)

full_name: UniformSpace.Completion.nnnorm_coe
code: @[simp]
theorem nnnorm_coe {E} [SeminormedAddCommGroup E] (x : E) : ‖(x : Completion E)‖₊ = ‖x‖₊ 
goal: ‖↑E x‖₊ = ‖x‖₊
File: Mathlib/Analysis/Normed/Group/Submodule.lean

full_name: Submodule.seminormedAddCommGroup
code: /-- A submodule of a seminormed group is also a seminormed group, with the restriction of the norm.
-/
instance seminormedAddCommGroup [Ring 𝕜] [SeminormedAddCommGroup E] [Module 𝕜 E]
    (s : Submodule 𝕜 E) : SeminormedAddCommGroup s 
goal: SeminormedAddCommGroup ↥s

full_name: Submodule.coe_norm
code: /-- If `x` is an element of a submodule `s` of a normed group `E`, its norm in `s` is equal to its
norm in `E`. -/
@[simp]
theorem coe_norm [Ring 𝕜] [SeminormedAddCommGroup E] [Module 𝕜 E] {s : Submodule 𝕜 E}
    (x : s) : ‖x‖ = ‖(x : E)‖ 
goal: ‖x‖ = ‖↑x‖

full_name: Submodule.norm_coe
code: /-- If `x` is an element of a submodule `s` of a normed group `E`, its norm in `E` is equal to its
norm in `s`.

This is a reversed version of the `simp` lemma `Submodule.coe_norm` for use by `norm_cast`. -/
@[norm_cast]
theorem norm_coe [Ring 𝕜] [SeminormedAddCommGroup E] [Module 𝕜 E] {s : Submodule 𝕜 E}
    (x : s) : ‖(x : E)‖ = ‖x‖ 
goal: ‖↑x‖ = ‖x‖

full_name: Submodule.normedAddCommGroup
code: /-- A submodule of a normed group is also a normed group, with the restriction of the norm. -/
instance normedAddCommGroup [Ring 𝕜] [NormedAddCommGroup E] [Module 𝕜 E]
    (s : Submodule 𝕜 E) : NormedAddCommGroup s 
goal: NormedAddCommGroup ↥s
File: Mathlib/Analysis/Normed/Group/ZeroAtInfty.lean

full_name: ZeroAtInftyContinuousMapClass.norm_le
code: theorem ZeroAtInftyContinuousMapClass.norm_le (f : 𝓕) (ε : ℝ) (hε : 0 < ε) :
    ∃ (r : ℝ), ∀ (x : E) (_hx : r < ‖x‖), ‖f x‖ < ε 
goal: ∃ r, ∀ (x : E), r < ‖x‖ → ‖f x‖ < ε

full_name: zero_at_infty_of_norm_le
code: theorem zero_at_infty_of_norm_le (f : E → F)
    (h : ∀ (ε : ℝ) (_hε : 0 < ε), ∃ (r : ℝ), ∀ (x : E) (_hx : r < ‖x‖), ‖f x‖ < ε) :
    Tendsto f (cocompact E) (𝓝 0) 
goal: Filter.Tendsto f (Filter.cocompact E) (𝓝 0)
File: Mathlib/Analysis/Normed/Algebra/Basic.lean

full_name: WeakDual.CharacterSpace.norm_le_norm_one
code: theorem norm_le_norm_one (φ : characterSpace 𝕜 A) : ‖toNormedDual (φ : WeakDual 𝕜 A)‖ ≤ ‖(1 : A)‖ 
goal: ‖WeakDual.toNormedDual ↑φ‖ ≤ ‖1‖

full_name: WeakDual.CharacterSpace.instCompactSpaceElemCharacterSpaceOfProperSpace
code: instance [ProperSpace 𝕜] : CompactSpace (characterSpace 𝕜 A) 
goal: CompactSpace ↑(WeakDual.characterSpace 𝕜 A)
File: Mathlib/Analysis/Normed/Group/ControlledClosure.lean

full_name: controlled_closure_of_complete
code: /-- Given `f : NormedAddGroupHom G H` for some complete `G` and a subgroup `K` of `H`, if every
element `x` of `K` has a preimage under `f` whose norm is at most `C*‖x‖` then the same holds for
elements of the (topological) closure of `K` with constant `C+ε` instead of `C`, for any
positive `ε`.
-/
theorem controlled_closure_of_complete {f : NormedAddGroupHom G H} {K : AddSubgroup H} {C ε : ℝ}
    (hC : 0 < C) (hε : 0 < ε) (hyp : f.SurjectiveOnWith K C) :
    f.SurjectiveOnWith K.topologicalClosure (C + ε) 
goal: f.SurjectiveOnWith K.topologicalClosure (C + ε)

full_name: controlled_closure_range_of_complete
code: /-- Given `f : NormedAddGroupHom G H` for some complete `G`, if every element `x` of the image of
an isometric immersion `j : NormedAddGroupHom K H` has a preimage under `f` whose norm is at most
`C*‖x‖` then the same holds for elements of the (topological) closure of this image with constant
`C+ε` instead of `C`, for any positive `ε`.
This is useful in particular if `j` is the inclusion of a normed group into its completion
(in this case the closure is the full target group).
-/
theorem controlled_closure_range_of_complete {f : NormedAddGroupHom G H} {K : Type*}
    [SeminormedAddCommGroup K] {j : NormedAddGroupHom K H} (hj : ∀ x, ‖j x‖ = ‖x‖) {C ε : ℝ}
    (hC : 0 < C) (hε : 0 < ε) (hyp : ∀ k, ∃ g, f g = j k ∧ ‖g‖ ≤ C * ‖k‖) :
    f.SurjectiveOnWith j.range.topologicalClosure (C + ε) 
goal: f.SurjectiveOnWith j.range.topologicalClosure (C + ε)
File: Mathlib/Analysis/Calculus/ContDiff/FiniteDimension.lean

full_name: contDiffOn_clm_apply
code: /-- A family of continuous linear maps is `C^n` on `s` if all its applications are. -/
theorem contDiffOn_clm_apply {n : ℕ∞} {f : E → F →L[𝕜] G} {s : Set E} [FiniteDimensional 𝕜 F] :
    ContDiffOn 𝕜 n f s ↔ ∀ y, ContDiffOn 𝕜 n (fun x => f x y) s 
goal: ContDiffOn 𝕜 n f s ↔ ∀ (y : F), ContDiffOn 𝕜 n (fun x => (f x) y) s

full_name: contDiff_clm_apply_iff
code: theorem contDiff_clm_apply_iff {n : ℕ∞} {f : E → F →L[𝕜] G} [FiniteDimensional 𝕜 F] :
    ContDiff 𝕜 n f ↔ ∀ y, ContDiff 𝕜 n fun x => f x y 
goal: ContDiff 𝕜 n f ↔ ∀ (y : F), ContDiff 𝕜 n fun x => (f x) y

full_name: contDiff_succ_iff_fderiv_apply
code: /-- This is a useful lemma to prove that a certain operation preserves functions being `C^n`.
When you do induction on `n`, this gives a useful characterization of a function being `C^(n+1)`,
assuming you have already computed the derivative. The advantage of this version over
`contDiff_succ_iff_fderiv` is that both occurrences of `ContDiff` are for functions with the same
domain and codomain (`E` and `F`). This is not the case for `contDiff_succ_iff_fderiv`, which
often requires an inconvenient need to generalize `F`, which results in universe issues
(see the discussion in the section of `ContDiff.comp`).

This lemma avoids these universe issues, but only applies for finite dimensional `E`. -/
theorem contDiff_succ_iff_fderiv_apply [FiniteDimensional 𝕜 E] {n : ℕ} {f : E → F} :
    ContDiff 𝕜 (n + 1 : ℕ) f ↔ Differentiable 𝕜 f ∧ ∀ y, ContDiff 𝕜 n fun x => fderiv 𝕜 f x y 
goal: ContDiff 𝕜 (↑(n + 1)) f ↔ Differentiable 𝕜 f ∧ ∀ (y : E), ContDiff 𝕜 ↑n fun x => (fderiv 𝕜 f x) y

full_name: contDiffOn_succ_of_fderiv_apply
code: theorem contDiffOn_succ_of_fderiv_apply [FiniteDimensional 𝕜 E] {n : ℕ} {f : E → F} {s : Set E}
    (hf : DifferentiableOn 𝕜 f s) (h : ∀ y, ContDiffOn 𝕜 n (fun x => fderivWithin 𝕜 f s x y) s) :
    ContDiffOn 𝕜 (n + 1 : ℕ) f s 
goal: ContDiffOn 𝕜 (↑(n + 1)) f s

full_name: contDiffOn_succ_iff_fderiv_apply
code: theorem contDiffOn_succ_iff_fderiv_apply [FiniteDimensional 𝕜 E] {n : ℕ} {f : E → F} {s : Set E}
    (hs : UniqueDiffOn 𝕜 s) :
    ContDiffOn 𝕜 (n + 1 : ℕ) f s ↔
      DifferentiableOn 𝕜 f s ∧ ∀ y, ContDiffOn 𝕜 n (fun x => fderivWithin 𝕜 f s x y) s 
goal: ContDiffOn 𝕜 (↑(n + 1)) f s ↔
  DifferentiableOn 𝕜 f s ∧ ∀ (y : E), ContDiffOn 𝕜 (↑n) (fun x => (fderivWithin 𝕜 f s x) y) s
File: Mathlib/Analysis/Calculus/Deriv/Support.lean

full_name: support_deriv_subset
code: theorem support_deriv_subset : support (deriv f) ⊆ tsupport f 
goal: Function.support (deriv f) ⊆ tsupport f

full_name: HasCompactSupport.deriv
code: protected theorem HasCompactSupport.deriv (hf : HasCompactSupport f) :
    HasCompactSupport (deriv f) 
goal: HasCompactSupport (deriv f)
File: Mathlib/Analysis/MellinInversion.lean

full_name: _private.Mathlib.Analysis.MellinInversion.0.rexp_neg_deriv_aux
code: private theorem rexp_neg_deriv_aux :
    ∀ x ∈ univ, HasDerivWithinAt (rexp ∘ Neg.neg) (-rexp (-x)) univ x 
goal: x ∈ Set.univ → HasDerivWithinAt (rexp ∘ Neg.neg) (-rexp (-x)) Set.univ x

full_name: _private.Mathlib.Analysis.MellinInversion.0.rexp_neg_image_aux
code: private theorem rexp_neg_image_aux : rexp ∘ Neg.neg '' univ = Ioi 0 
goal: rexp ∘ Neg.neg '' Set.univ = Set.Ioi 0

full_name: _private.Mathlib.Analysis.MellinInversion.0.rexp_neg_injOn_aux
code: private theorem rexp_neg_injOn_aux : univ.InjOn (rexp ∘ Neg.neg) 
goal: Set.InjOn (rexp ∘ Neg.neg) Set.univ

full_name: _private.Mathlib.Analysis.MellinInversion.0.rexp_cexp_aux
code: private theorem rexp_cexp_aux (x : ℝ) (s : ℂ) (f : E) :
    rexp (-x) • cexp (-↑x) ^ (s - 1) • f = cexp (-s * ↑x) • f 
goal: rexp (-x) • cexp (-↑x) ^ (s - 1) • f = cexp (-s * ↑x) • f

full_name: mellin_eq_fourierIntegral
code: theorem mellin_eq_fourierIntegral (f : ℝ → E) {s : ℂ} :
    mellin f s = 𝓕 (fun (u : ℝ) ↦ (Real.exp (-s.re * u) • f (Real.exp (-u)))) (s.im / (2 * π)) 
goal: mellin f s = 𝓕 (fun u => rexp (-s.re * u) • f (rexp (-u))) (s.im / (2 * π))

full_name: mellinInv_eq_fourierIntegralInv
code: theorem mellinInv_eq_fourierIntegralInv (σ : ℝ) (f : ℂ → E) {x : ℝ} (hx : 0 < x) :
    mellinInv σ f x =
    (x : ℂ) ^ (-σ : ℂ) • 𝓕⁻ (fun (y : ℝ) ↦ f (σ + 2 * π * y * I)) (-Real.log x) 
goal: mellinInv σ f x = ↑x ^ (-↑σ) • 𝓕⁻ (fun y => f (↑σ + 2 * ↑π * ↑y * Complex.I)) (-Real.log x)

full_name: mellin_inversion
code: /-- The inverse Mellin transform of the Mellin transform applied to `x > 0` is x. -/
theorem mellin_inversion (σ : ℝ) (f : ℝ → E) {x : ℝ} (hx : 0 < x) (hf : MellinConvergent f σ)
    (hFf : VerticalIntegrable (mellin f) σ) (hfx : ContinuousAt f x) :
    mellinInv σ (mellin f) x = f x 
goal: mellinInv σ (mellin f) x = f x
File: Mathlib/Analysis/Calculus/Deriv/Shift.lean

full_name: HasDerivAt.comp_const_add
code: /-- Translation in the domain does not change the derivative. -/
lemma HasDerivAt.comp_const_add {𝕜 : Type*} [NontriviallyNormedField 𝕜] (a x : 𝕜) {𝕜' : Type*}
    [NormedAddCommGroup 𝕜'] [NormedSpace 𝕜 𝕜'] {h : 𝕜 → 𝕜'} {h' : 𝕜'}
    (hh : HasDerivAt h h' (a + x)) :
    HasDerivAt (fun x ↦ h (a + x)) h' x 
goal: HasDerivAt (fun x => h (a + x)) h' x

full_name: HasDerivAt.comp_add_const
code: /-- Translation in the domain does not change the derivative. -/
lemma HasDerivAt.comp_add_const {𝕜 : Type*} [NontriviallyNormedField 𝕜] (x a : 𝕜) {𝕜' : Type*}
    [NormedAddCommGroup 𝕜'] [NormedSpace 𝕜 𝕜'] {h : 𝕜 → 𝕜'} {h' : 𝕜'}
    (hh : HasDerivAt h h' (x + a)) :
    HasDerivAt (fun x ↦ h (x + a)) h' x 
goal: HasDerivAt (fun x => h (x + a)) h' x

full_name: deriv_comp_neg
code: /-- The derivative of `x ↦ f (-x)` at `a` is the negative of the derivative of `f` at `-a`. -/
lemma deriv_comp_neg {𝕜 : Type*} [NontriviallyNormedField 𝕜] {F : Type*} [NormedAddCommGroup F]
    [NormedSpace 𝕜 F] (f : 𝕜 → F) (a : 𝕜) : deriv (fun x ↦ f (-x)) a = -deriv f (-a) 
goal: deriv (fun x => f (-x)) a = -deriv f (-a)

full_name: deriv_comp_const_add
code: /-- Translation in the domain does not change the derivative. -/
lemma deriv_comp_const_add {𝕜 : Type*} [NontriviallyNormedField 𝕜] (a x : 𝕜) {𝕜' : Type*}
    [NormedAddCommGroup 𝕜'] [NormedSpace 𝕜 𝕜'] {h : 𝕜 → 𝕜'}
    (hh : DifferentiableAt 𝕜 h (a + x)) :
    deriv (fun x ↦ h (a + x)) x = deriv h (a + x) 
goal: deriv (fun x => h (a + x)) x = deriv h (a + x)

full_name: deriv_comp_add_const
code: /-- Translation in the domain does not change the derivative. -/
lemma deriv_comp_add_const {𝕜 : Type*} [NontriviallyNormedField 𝕜] (a x : 𝕜) {𝕜' : Type*}
    [NormedAddCommGroup 𝕜'] [NormedSpace 𝕜 𝕜'] {h : 𝕜 → 𝕜'}
    (hh : DifferentiableAt 𝕜 h (x + a)) :
    deriv (fun x ↦ h (x + a)) x = deriv h (x + a) 
goal: deriv (fun x => h (x + a)) x = deriv h (x + a)
File: Mathlib/Analysis/Calculus/Deriv/AffineMap.lean

full_name: AffineMap.hasStrictDerivAt
code: theorem hasStrictDerivAt : HasStrictDerivAt f (f.linear 1) x 
goal: HasStrictDerivAt (⇑f) (f.linear 1) x

full_name: AffineMap.hasDerivAtFilter
code: theorem hasDerivAtFilter : HasDerivAtFilter f (f.linear 1) x L 
goal: HasDerivAtFilter (⇑f) (f.linear 1) x L

full_name: AffineMap.hasDerivWithinAt
code: theorem hasDerivWithinAt : HasDerivWithinAt f (f.linear 1) s x 
goal: HasDerivWithinAt (⇑f) (f.linear 1) s x

full_name: AffineMap.hasDerivAt
code: theorem hasDerivAt : HasDerivAt f (f.linear 1) x 
goal: HasDerivAt (⇑f) (f.linear 1) x

full_name: AffineMap.derivWithin
code: protected theorem derivWithin (hs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin f s x = f.linear 1 
goal: derivWithin (⇑f) s x = f.linear 1

full_name: AffineMap.deriv
code: @[simp] protected theorem deriv : deriv f x = f.linear 1 
goal: deriv (⇑f) x = f.linear 1

full_name: AffineMap.differentiableAt
code: protected theorem differentiableAt : DifferentiableAt 𝕜 f x 
goal: DifferentiableAt 𝕜 (⇑f) x

full_name: AffineMap.differentiable
code: protected theorem differentiable : Differentiable 𝕜 f 
goal: Differentiable 𝕜 ⇑f

full_name: AffineMap.differentiableWithinAt
code: protected theorem differentiableWithinAt : DifferentiableWithinAt 𝕜 f s x 
goal: DifferentiableWithinAt 𝕜 (⇑f) s x

full_name: AffineMap.differentiableOn
code: protected theorem differentiableOn : DifferentiableOn 𝕜 f s 
goal: DifferentiableOn 𝕜 (⇑f) s

full_name: AffineMap.hasStrictDerivAt_lineMap
code: theorem hasStrictDerivAt_lineMap : HasStrictDerivAt (lineMap a b) (b - a) x 
goal: HasStrictDerivAt (⇑(AffineMap.lineMap a b)) (b - a) x

full_name: AffineMap.hasDerivAt_lineMap
code: theorem hasDerivAt_lineMap :  HasDerivAt (lineMap a b) (b - a) x 
goal: HasDerivAt (⇑(AffineMap.lineMap a b)) (b - a) x

full_name: AffineMap.hasDerivWithinAt_lineMap
code: theorem hasDerivWithinAt_lineMap : HasDerivWithinAt (lineMap a b) (b - a) s x 
goal: HasDerivWithinAt (⇑(AffineMap.lineMap a b)) (b - a) s x
File: Mathlib/Analysis/Calculus/Deriv/Pi.lean

full_name: hasDerivAt_update
code: theorem hasDerivAt_update (x : ι → 𝕜) (i : ι) (y : 𝕜) :
    HasDerivAt (Function.update x i) (Pi.single i (1 : 𝕜)) y 
goal: HasDerivAt (Function.update x i) (Pi.single i 1) y

full_name: hasDerivAt_single
code: theorem hasDerivAt_single (i : ι) (y : 𝕜) :
    HasDerivAt (Pi.single (f := fun _ ↦ 𝕜) i) (Pi.single i (1 : 𝕜)) y 
goal: HasDerivAt (Pi.single i) (Pi.single i 1) y

full_name: deriv_update
code: theorem deriv_update (x : ι → 𝕜) (i : ι) (y : 𝕜) :
    deriv (Function.update x i) y = Pi.single i (1 : 𝕜) 
goal: deriv (Function.update x i) y = Pi.single i 1

full_name: deriv_single
code: theorem deriv_single (i : ι) (y : 𝕜) :
    deriv (Pi.single (f := fun _ ↦ 𝕜) i) y = Pi.single i (1 : 𝕜) 
goal: deriv (Pi.single i) y = Pi.single i 1