ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Analysis/Fourier/ZMod.lean

full_name: ZMod.dft
code: /-- The discrete Fourier transform on `ℤ / N ℤ` (with the counting measure) -/
noncomputable def dft (Φ : ZMod N → ℂ) (k : ZMod N) : ℂ 
goal: ℂ

full_name: ZMod._aux_Mathlib_Analysis_Fourier_ZMod___macroRules_ZMod_term𝓕_1
code: @[inherit_doc] scoped notation "𝓕" => dft
goal: Lean.Macro

full_name: ZMod._aux_Mathlib_Analysis_Fourier_ZMod___unexpand_ZMod_dft_1
code: @[inherit_doc] scoped notation "𝓕" => dft
goal: Lean.PrettyPrinter.Unexpander

full_name: ZMod.dft_apply
code: lemma dft_apply (Φ : ZMod N → ℂ) (k : ZMod N) :
    𝓕 Φ k = ∑ j : ZMod N, toCircle (-(j * k)) • Φ j 
goal: 𝓕 Φ k = ∑ j : ZMod N, ZMod.toCircle (-(j * k)) • Φ j

full_name: ZMod.dft_def
code: lemma dft_def (Φ : ZMod N → ℂ) : 𝓕 Φ = fun k ↦ ∑ j : ZMod N, toCircle (-(j * k)) • Φ j 
goal: 𝓕 Φ = fun k => ∑ j : ZMod N, ZMod.toCircle (-(j * k)) • Φ j

full_name: DirichletCharacter.fourierTransform_eq_gaussSum_mulShift
code: lemma fourierTransform_eq_gaussSum_mulShift (k : ZMod N) :
    𝓕 χ k = gaussSum χ (stdAddChar.mulShift (-k)) 
goal: 𝓕 (⇑χ) k = gaussSum χ (ZMod.stdAddChar.mulShift (-k))

full_name: DirichletCharacter.fourierTransform_eq_inv_mul_gaussSum
code: /-- For a primitive Dirichlet character `χ`, the Fourier transform of `χ` is a constant multiple
of `χ⁻¹` (and the constant is essentially the Gauss sum). -/
lemma fourierTransform_eq_inv_mul_gaussSum (k : ZMod N) (hχ : IsPrimitive χ) :
    𝓕 χ k = χ⁻¹ (-k) * gaussSum χ stdAddChar 
goal: 𝓕 (⇑χ) k = χ⁻¹ (-k) * gaussSum χ ZMod.stdAddChar
File: Mathlib/Analysis/LocallyConvex/StrongTopology.lean

full_name: UniformConvergenceCLM.locallyConvexSpace
code: theorem locallyConvexSpace (𝔖 : Set (Set E)) (h𝔖₁ : 𝔖.Nonempty)
    (h𝔖₂ : DirectedOn (· ⊆ ·) 𝔖) :
    LocallyConvexSpace R (UniformConvergenceCLM σ F 𝔖) 
goal: LocallyConvexSpace R (UniformConvergenceCLM σ F 𝔖)

full_name: ContinuousLinearMap.instLocallyConvexSpace
code: instance instLocallyConvexSpace : LocallyConvexSpace R (E →SL[σ] F) 
goal: LocallyConvexSpace R (E →SL[σ] F)
File: Mathlib/Analysis/LocallyConvex/AbsConvex.lean

full_name: nhds_basis_abs_convex
code: theorem nhds_basis_abs_convex :
    (𝓝 (0 : E)).HasBasis (fun s : Set E => s ∈ 𝓝 (0 : E) ∧ Balanced 𝕜 s ∧ Convex ℝ s) id 
goal: (𝓝 0).HasBasis (fun s => s ∈ 𝓝 0 ∧ Balanced 𝕜 s ∧ Convex ℝ s) id

full_name: nhds_basis_abs_convex_open
code: theorem nhds_basis_abs_convex_open :
    (𝓝 (0 : E)).HasBasis (fun s => (0 : E) ∈ s ∧ IsOpen s ∧ Balanced 𝕜 s ∧ Convex ℝ s) id 
goal: (𝓝 0).HasBasis (fun s => 0 ∈ s ∧ IsOpen s ∧ Balanced 𝕜 s ∧ Convex ℝ s) id

full_name: AbsConvexOpenSets
code: /-- The type of absolutely convex open sets. -/
def AbsConvexOpenSets 
goal: Type u_2

full_name: AbsConvexOpenSets.instCoeTC
code: noncomputable instance AbsConvexOpenSets.instCoeTC : CoeTC (AbsConvexOpenSets 𝕜 E) (Set E) 
goal: CoeTC (AbsConvexOpenSets 𝕜 E) (Set E)

full_name: AbsConvexOpenSets.coe_zero_mem
code: theorem coe_zero_mem (s : AbsConvexOpenSets 𝕜 E) : (0 : E) ∈ (s : Set E) 
goal: 0 ∈ ↑s

full_name: AbsConvexOpenSets.coe_isOpen
code: theorem coe_isOpen (s : AbsConvexOpenSets 𝕜 E) : IsOpen (s : Set E) 
goal: IsOpen ↑s

full_name: AbsConvexOpenSets.coe_nhds
code: theorem coe_nhds (s : AbsConvexOpenSets 𝕜 E) : (s : Set E) ∈ 𝓝 (0 : E) 
goal: ↑s ∈ 𝓝 0

full_name: AbsConvexOpenSets.coe_balanced
code: theorem coe_balanced (s : AbsConvexOpenSets 𝕜 E) : Balanced 𝕜 (s : Set E) 
goal: Balanced 𝕜 ↑s

full_name: AbsConvexOpenSets.coe_convex
code: theorem coe_convex (s : AbsConvexOpenSets 𝕜 E) : Convex ℝ (s : Set E) 
goal: Convex ℝ ↑s

full_name: AbsConvexOpenSets.instNonempty
code: instance AbsConvexOpenSets.instNonempty : Nonempty (AbsConvexOpenSets 𝕜 E) 
goal: Nonempty (AbsConvexOpenSets 𝕜 E)

full_name: gaugeSeminormFamily
code: /-- The family of seminorms defined by the gauges of absolute convex open sets. -/
noncomputable def gaugeSeminormFamily : SeminormFamily 𝕜 E (AbsConvexOpenSets 𝕜 E) 
goal: SeminormFamily 𝕜 E (AbsConvexOpenSets 𝕜 E)

full_name: gaugeSeminormFamily_ball
code: theorem gaugeSeminormFamily_ball (s : AbsConvexOpenSets 𝕜 E) :
    (gaugeSeminormFamily 𝕜 E s).ball 0 1 = (s : Set E) 
goal: (gaugeSeminormFamily 𝕜 E s).ball 0 1 = ↑s

full_name: with_gaugeSeminormFamily
code: /-- The topology of a locally convex space is induced by the gauge seminorm family. -/
theorem with_gaugeSeminormFamily : WithSeminorms (gaugeSeminormFamily 𝕜 E) 
goal: WithSeminorms (gaugeSeminormFamily 𝕜 E)
File: Mathlib/Analysis/LocallyConvex/WeakDual.lean

full_name: LinearMap.toSeminorm
code: /-- Construct a seminorm from a linear form `f : E →ₗ[𝕜] 𝕜` over a normed field `𝕜` by
`fun x => ‖f x‖` -/
def toSeminorm (f : E →ₗ[𝕜] 𝕜) : Seminorm 𝕜 E 
goal: Seminorm 𝕜 E

full_name: LinearMap.coe_toSeminorm
code: theorem coe_toSeminorm {f : E →ₗ[𝕜] 𝕜} : ⇑f.toSeminorm = fun x => ‖f x‖ 
goal: ⇑f.toSeminorm = fun x => ‖f x‖

full_name: LinearMap.toSeminorm_apply
code: @[simp]
theorem toSeminorm_apply {f : E →ₗ[𝕜] 𝕜} {x : E} : f.toSeminorm x = ‖f x‖ 
goal: f.toSeminorm x = ‖f x‖

full_name: LinearMap.toSeminorm_ball_zero
code: theorem toSeminorm_ball_zero {f : E →ₗ[𝕜] 𝕜} {r : ℝ} :
    Seminorm.ball f.toSeminorm 0 r = { x : E | ‖f x‖ < r } 
goal: f.toSeminorm.ball 0 r = {x | ‖f x‖ < r}

full_name: LinearMap.toSeminorm_comp
code: theorem toSeminorm_comp (f : F →ₗ[𝕜] 𝕜) (g : E →ₗ[𝕜] F) :
    f.toSeminorm.comp g = (f.comp g).toSeminorm 
goal: f.toSeminorm.comp g = (f ∘ₗ g).toSeminorm

full_name: LinearMap.toSeminormFamily
code: /-- Construct a family of seminorms from a bilinear form. -/
def toSeminormFamily (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) : SeminormFamily 𝕜 E F 
goal: SeminormFamily 𝕜 E F

full_name: LinearMap.toSeminormFamily_apply
code: @[simp]
theorem toSeminormFamily_apply {B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜} {x y} : (B.toSeminormFamily y) x = ‖B x y‖ 
goal: (B.toSeminormFamily y) x = ‖(B x) y‖

full_name: LinearMap.hasBasis_weakBilin
code: theorem LinearMap.hasBasis_weakBilin (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) :
    (𝓝 (0 : WeakBilin B)).HasBasis B.toSeminormFamily.basisSets _root_.id 
goal: (𝓝 0).HasBasis B.toSeminormFamily.basisSets id

full_name: LinearMap.weakBilin_withSeminorms
code: theorem LinearMap.weakBilin_withSeminorms (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) :
    WithSeminorms (LinearMap.toSeminormFamily B : F → Seminorm 𝕜 (WeakBilin B)) 
goal: WithSeminorms B.toSeminormFamily

full_name: WeakBilin.locallyConvexSpace
code: instance WeakBilin.locallyConvexSpace {B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜} :
    LocallyConvexSpace ℝ (WeakBilin B) 
goal: LocallyConvexSpace ℝ (WeakBilin B)
File: Mathlib/Analysis/SumIntegralComparisons.lean

full_name: AntitoneOn.integral_le_sum
code: theorem AntitoneOn.integral_le_sum (hf : AntitoneOn f (Icc x₀ (x₀ + a))) :
    (∫ x in x₀..x₀ + a, f x) ≤ ∑ i ∈ Finset.range a, f (x₀ + i) 
goal: ∫ (x : ℝ) in x₀..x₀ + ↑a, f x ≤ ∑ i ∈ Finset.range a, f (x₀ + ↑i)

full_name: AntitoneOn.integral_le_sum_Ico
code: theorem AntitoneOn.integral_le_sum_Ico (hab : a ≤ b) (hf : AntitoneOn f (Set.Icc a b)) :
    (∫ x in a..b, f x) ≤ ∑ x ∈ Finset.Ico a b, f x 
goal: ∫ (x : ℝ) in ↑a..↑b, f x ≤ ∑ x ∈ Finset.Ico a b, f ↑x

full_name: AntitoneOn.sum_le_integral
code: theorem AntitoneOn.sum_le_integral (hf : AntitoneOn f (Icc x₀ (x₀ + a))) :
    (∑ i ∈ Finset.range a, f (x₀ + (i + 1 : ℕ))) ≤ ∫ x in x₀..x₀ + a, f x 
goal: ∑ i ∈ Finset.range a, f (x₀ + ↑(i + 1)) ≤ ∫ (x : ℝ) in x₀..x₀ + ↑a, f x

full_name: AntitoneOn.sum_le_integral_Ico
code: theorem AntitoneOn.sum_le_integral_Ico (hab : a ≤ b) (hf : AntitoneOn f (Set.Icc a b)) :
    (∑ i ∈ Finset.Ico a b, f (i + 1 : ℕ)) ≤ ∫ x in a..b, f x 
goal: ∑ i ∈ Finset.Ico a b, f ↑(i + 1) ≤ ∫ (x : ℝ) in ↑a..↑b, f x

full_name: MonotoneOn.sum_le_integral
code: theorem MonotoneOn.sum_le_integral (hf : MonotoneOn f (Icc x₀ (x₀ + a))) :
    (∑ i ∈ Finset.range a, f (x₀ + i)) ≤ ∫ x in x₀..x₀ + a, f x 
goal: ∑ i ∈ Finset.range a, f (x₀ + ↑i) ≤ ∫ (x : ℝ) in x₀..x₀ + ↑a, f x

full_name: MonotoneOn.sum_le_integral_Ico
code: theorem MonotoneOn.sum_le_integral_Ico (hab : a ≤ b) (hf : MonotoneOn f (Set.Icc a b)) :
    ∑ x ∈ Finset.Ico a b, f x ≤ ∫ x in a..b, f x 
goal: ∑ x ∈ Finset.Ico a b, f ↑x ≤ ∫ (x : ℝ) in ↑a..↑b, f x

full_name: MonotoneOn.integral_le_sum
code: theorem MonotoneOn.integral_le_sum (hf : MonotoneOn f (Icc x₀ (x₀ + a))) :
    (∫ x in x₀..x₀ + a, f x) ≤ ∑ i ∈ Finset.range a, f (x₀ + (i + 1 : ℕ)) 
goal: ∫ (x : ℝ) in x₀..x₀ + ↑a, f x ≤ ∑ i ∈ Finset.range a, f (x₀ + ↑(i + 1))

full_name: MonotoneOn.integral_le_sum_Ico
code: theorem MonotoneOn.integral_le_sum_Ico (hab : a ≤ b) (hf : MonotoneOn f (Set.Icc a b)) :
    (∫ x in a..b, f x) ≤ ∑ i ∈ Finset.Ico a b, f (i + 1 : ℕ) 
goal: ∫ (x : ℝ) in ↑a..↑b, f x ≤ ∑ i ∈ Finset.Ico a b, f ↑(i + 1)
File: Mathlib/Analysis/PSeriesComplex.lean

full_name: Complex.summable_one_div_nat_cpow
code: lemma Complex.summable_one_div_nat_cpow {p : ℂ} :
    Summable (fun n : ℕ ↦ 1 / (n : ℂ) ^ p) ↔ 1 < re p 
goal: (Summable fun n => 1 / ↑n ^ p) ↔ 1 < p.re
File: Mathlib/Analysis/Fourier/Inversion.lean

full_name: Real.tendsto_integral_cexp_sq_smul
code: lemma tendsto_integral_cexp_sq_smul (hf : Integrable f) :
    Tendsto (fun (c : ℝ) ↦ (∫ v : V, cexp (- c⁻¹ * ‖v‖^2) • f v))
      atTop (𝓝 (∫ v : V, f v)) 
goal: Filter.Tendsto (fun c => ∫ (v : V), cexp (-↑c⁻¹ * ↑‖v‖ ^ 2) • f v) Filter.atTop (𝓝 (∫ (v : V), f v))

full_name: Real.tendsto_integral_gaussian_smul
code: lemma tendsto_integral_gaussian_smul (hf : Integrable f) (h'f : Integrable (𝓕 f)) (v : V) :
    Tendsto (fun (c : ℝ) ↦
      ∫ w : V, ((π * c) ^ (finrank ℝ V / 2 : ℂ) * cexp (-π ^ 2 * c * ‖v - w‖ ^ 2)) • f w)
    atTop (𝓝 (𝓕⁻ (𝓕 f) v)) 
goal: Filter.Tendsto
  (fun c => ∫ (w : V), ((↑π * ↑c) ^ (↑(FiniteDimensional.finrank ℝ V) / 2) * cexp (-↑π ^ 2 * ↑c * ↑‖v - w‖ ^ 2)) • f w)
  Filter.atTop (𝓝 (𝓕⁻ (𝓕 f) v))

full_name: Real.tendsto_integral_gaussian_smul'
code: lemma tendsto_integral_gaussian_smul' (hf : Integrable f) {v : V} (h'f : ContinuousAt f v) :
    Tendsto (fun (c : ℝ) ↦
      ∫ w : V, ((π * c : ℂ) ^ (finrank ℝ V / 2 : ℂ) * cexp (-π ^ 2 * c * ‖v - w‖ ^ 2)) • f w)
    atTop (𝓝 (f v)) 
goal: Filter.Tendsto
  (fun c => ∫ (w : V), ((↑π * ↑c) ^ (↑(FiniteDimensional.finrank ℝ V) / 2) * cexp (-↑π ^ 2 * ↑c * ↑‖v - w‖ ^ 2)) • f w)
  Filter.atTop (𝓝 (f v))

full_name: MeasureTheory.Integrable.fourier_inversion
code: /-- **Fourier inversion formula**: If a function `f` on a finite-dimensional real inner product
space is integrable, and its Fourier transform `𝓕 f` is also integrable, then `𝓕⁻ (𝓕 f) = f` at
continuity points of `f`. -/
theorem MeasureTheory.Integrable.fourier_inversion
    (hf : Integrable f) (h'f : Integrable (𝓕 f)) {v : V}
    (hv : ContinuousAt f v) : 𝓕⁻ (𝓕 f) v = f v 
goal: 𝓕⁻ (𝓕 f) v = f v

full_name: Continuous.fourier_inversion
code: /-- **Fourier inversion formula**: If a function `f` on a finite-dimensional real inner product
space is continuous, integrable, and its Fourier transform `𝓕 f` is also integrable,
then `𝓕⁻ (𝓕 f) = f`. -/
theorem Continuous.fourier_inversion (h : Continuous f)
    (hf : Integrable f) (h'f : Integrable (𝓕 f)) :
    𝓕⁻ (𝓕 f) = f 
goal: 𝓕⁻ (𝓕 f) = f

full_name: MeasureTheory.Integrable.fourier_inversion_inv
code: /-- **Fourier inversion formula**: If a function `f` on a finite-dimensional real inner product
space is integrable, and its Fourier transform `𝓕 f` is also integrable, then `𝓕 (𝓕⁻ f) = f` at
continuity points of `f`. -/
theorem MeasureTheory.Integrable.fourier_inversion_inv
    (hf : Integrable f) (h'f : Integrable (𝓕 f)) {v : V}
    (hv : ContinuousAt f v) : 𝓕 (𝓕⁻ f) v = f v 
goal: 𝓕 (𝓕⁻ f) v = f v

full_name: Continuous.fourier_inversion_inv
code: /-- **Fourier inversion formula**: If a function `f` on a finite-dimensional real inner product
space is continuous, integrable, and its Fourier transform `𝓕 f` is also integrable,
then `𝓕 (𝓕⁻ f) = f`. -/
theorem Continuous.fourier_inversion_inv (h : Continuous f)
    (hf : Integrable f) (h'f : Integrable (𝓕 f)) :
    𝓕 (𝓕⁻ f) = f 
goal: 𝓕 (𝓕⁻ f) = f
File: Mathlib/Analysis/Normed/MulAction.lean

full_name: norm_smul_le
code: theorem norm_smul_le (r : α) (x : β) : ‖r • x‖ ≤ ‖r‖ * ‖x‖ 
goal: ‖r • x‖ ≤ ‖r‖ * ‖x‖

full_name: nnnorm_smul_le
code: theorem nnnorm_smul_le (r : α) (x : β) : ‖r • x‖₊ ≤ ‖r‖₊ * ‖x‖₊ 
goal: ‖r • x‖₊ ≤ ‖r‖₊ * ‖x‖₊

full_name: dist_smul_le
code: theorem dist_smul_le (s : α) (x y : β) : dist (s • x) (s • y) ≤ ‖s‖ * dist x y 
goal: dist (s • x) (s • y) ≤ ‖s‖ * dist x y

full_name: nndist_smul_le
code: theorem nndist_smul_le (s : α) (x y : β) : nndist (s • x) (s • y) ≤ ‖s‖₊ * nndist x y 
goal: nndist (s • x) (s • y) ≤ ‖s‖₊ * nndist x y

full_name: lipschitzWith_smul
code: theorem lipschitzWith_smul (s : α) : LipschitzWith ‖s‖₊ (s • · : β → β) 
goal: LipschitzWith ‖s‖₊ fun x => s • x

full_name: edist_smul_le
code: theorem edist_smul_le (s : α) (x y : β) : edist (s • x) (s • y) ≤ ‖s‖₊ • edist x y 
goal: edist (s • x) (s • y) ≤ ‖s‖₊ • edist x y

full_name: NonUnitalSeminormedRing.to_boundedSMul
code: /-- Left multiplication is bounded. -/
instance NonUnitalSeminormedRing.to_boundedSMul [NonUnitalSeminormedRing α] : BoundedSMul α α 
goal: BoundedSMul α α

full_name: NonUnitalSeminormedRing.to_has_bounded_op_smul
code: /-- Right multiplication is bounded. -/
instance NonUnitalSeminormedRing.to_has_bounded_op_smul [NonUnitalSeminormedRing α] :
    BoundedSMul αᵐᵒᵖ α 
goal: BoundedSMul αᵐᵒᵖ α

full_name: BoundedSMul.of_norm_smul_le
code: theorem BoundedSMul.of_norm_smul_le (h : ∀ (r : α) (x : β), ‖r • x‖ ≤ ‖r‖ * ‖x‖) :
    BoundedSMul α β 
goal: BoundedSMul α β

full_name: BoundedSMul.of_nnnorm_smul_le
code: theorem BoundedSMul.of_nnnorm_smul_le (h : ∀ (r : α) (x : β), ‖r • x‖₊ ≤ ‖r‖₊ * ‖x‖₊) :
    BoundedSMul α β 
goal: BoundedSMul α β

full_name: norm_smul
code: theorem norm_smul (r : α) (x : β) : ‖r • x‖ = ‖r‖ * ‖x‖ 
goal: ‖r • x‖ = ‖r‖ * ‖x‖

full_name: nnnorm_smul
code: theorem nnnorm_smul (r : α) (x : β) : ‖r • x‖₊ = ‖r‖₊ * ‖x‖₊ 
goal: ‖r • x‖₊ = ‖r‖₊ * ‖x‖₊

full_name: dist_smul₀
code: theorem dist_smul₀ (s : α) (x y : β) : dist (s • x) (s • y) = ‖s‖ * dist x y 
goal: dist (s • x) (s • y) = ‖s‖ * dist x y

full_name: nndist_smul₀
code: theorem nndist_smul₀ (s : α) (x y : β) : nndist (s • x) (s • y) = ‖s‖₊ * nndist x y 
goal: nndist (s • x) (s • y) = ‖s‖₊ * nndist x y

full_name: edist_smul₀
code: theorem edist_smul₀ (s : α) (x y : β) : edist (s • x) (s • y) = ‖s‖₊ • edist x y 
goal: edist (s • x) (s • y) = ‖s‖₊ • edist x y
File: Mathlib/Analysis/LocallyConvex/ContinuousOfBounded.lean

full_name: LinearMap.clmOfExistsBoundedImage
code: /-- Construct a continuous linear map from a linear map `f : E →ₗ[𝕜] F` and the existence of a
neighborhood of zero that gets mapped into a bounded set in `F`. -/
def LinearMap.clmOfExistsBoundedImage (f : E →ₗ[𝕜] F)
    (h : ∃ V ∈ 𝓝 (0 : E), Bornology.IsVonNBounded 𝕜 (f '' V)) : E →L[𝕜] F 
goal: E →L[𝕜] F

full_name: LinearMap.clmOfExistsBoundedImage_coe
code: theorem LinearMap.clmOfExistsBoundedImage_coe {f : E →ₗ[𝕜] F}
    {h : ∃ V ∈ 𝓝 (0 : E), Bornology.IsVonNBounded 𝕜 (f '' V)} :
    (f.clmOfExistsBoundedImage h : E →ₗ[𝕜] F) = f 
goal: ↑(f.clmOfExistsBoundedImage h) = f

full_name: LinearMap.clmOfExistsBoundedImage_apply
code: @[simp]
theorem LinearMap.clmOfExistsBoundedImage_apply {f : E →ₗ[𝕜] F}
    {h : ∃ V ∈ 𝓝 (0 : E), Bornology.IsVonNBounded 𝕜 (f '' V)} {x : E} :
    f.clmOfExistsBoundedImage h x = f x 
goal: (f.clmOfExistsBoundedImage h) x = f x

full_name: LinearMap.continuousAt_zero_of_locally_bounded
code: theorem LinearMap.continuousAt_zero_of_locally_bounded (f : E →ₛₗ[σ] F)
    (hf : ∀ s, IsVonNBounded 𝕜 s → IsVonNBounded 𝕜' (f '' s)) : ContinuousAt f 0 
goal: ContinuousAt (⇑f) 0

full_name: LinearMap.continuous_of_locally_bounded
code: /-- If `E` is first countable, then every locally bounded linear map `E →ₛₗ[σ] F` is continuous. -/
theorem LinearMap.continuous_of_locally_bounded [UniformAddGroup F] (f : E →ₛₗ[σ] F)
    (hf : ∀ s, IsVonNBounded 𝕜 s → IsVonNBounded 𝕜' (f '' s)) : Continuous f 
goal: Continuous ⇑f
File: Mathlib/Analysis/Normed/Module/Ray.lean

full_name: SameRay.norm_add
code: /-- If `x` and `y` are on the same ray, then the triangle inequality becomes the equality: the norm
of `x + y` is the sum of the norms of `x` and `y`. The converse is true for a strictly convex
space. -/
theorem norm_add (h : SameRay ℝ x y) : ‖x + y‖ = ‖x‖ + ‖y‖ 
goal: ‖x + y‖ = ‖x‖ + ‖y‖

full_name: SameRay.norm_sub
code: theorem norm_sub (h : SameRay ℝ x y) : ‖x - y‖ = |‖x‖ - ‖y‖| 
goal: ‖x - y‖ = |‖x‖ - ‖y‖|

full_name: SameRay.norm_smul_eq
code: theorem norm_smul_eq (h : SameRay ℝ x y) : ‖x‖ • y = ‖y‖ • x 
goal: ‖x‖ • y = ‖y‖ • x

full_name: norm_injOn_ray_left
code: theorem norm_injOn_ray_left (hx : x ≠ 0) : { y | SameRay ℝ x y }.InjOn norm 
goal: Set.InjOn norm {y | SameRay ℝ x y}

full_name: norm_injOn_ray_right
code: theorem norm_injOn_ray_right (hy : y ≠ 0) : { x | SameRay ℝ x y }.InjOn norm 
goal: Set.InjOn norm {x | SameRay ℝ x y}

full_name: sameRay_iff_norm_smul_eq
code: theorem sameRay_iff_norm_smul_eq : SameRay ℝ x y ↔ ‖x‖ • y = ‖y‖ • x 
goal: SameRay ℝ x y ↔ ‖x‖ • y = ‖y‖ • x

full_name: sameRay_iff_inv_norm_smul_eq_of_ne
code: /-- Two nonzero vectors `x y` in a real normed space are on the same ray if and only if the unit
vectors `‖x‖⁻¹ • x` and `‖y‖⁻¹ • y` are equal. -/
theorem sameRay_iff_inv_norm_smul_eq_of_ne (hx : x ≠ 0) (hy : y ≠ 0) :
    SameRay ℝ x y ↔ ‖x‖⁻¹ • x = ‖y‖⁻¹ • y 
goal: SameRay ℝ x y ↔ ‖x‖⁻¹ • x = ‖y‖⁻¹ • y

full_name: sameRay_iff_inv_norm_smul_eq
code: /-- Two vectors `x y` in a real normed space are on the ray if and only if one of them is zero or
the unit vectors `‖x‖⁻¹ • x` and `‖y‖⁻¹ • y` are equal. -/
theorem sameRay_iff_inv_norm_smul_eq : SameRay ℝ x y ↔ x = 0 ∨ y = 0 ∨ ‖x‖⁻¹ • x = ‖y‖⁻¹ • y 
goal: SameRay ℝ x y ↔ x = 0 ∨ y = 0 ∨ ‖x‖⁻¹ • x = ‖y‖⁻¹ • y

full_name: sameRay_iff_of_norm_eq
code: /-- Two vectors of the same norm are on the same ray if and only if they are equal. -/
theorem sameRay_iff_of_norm_eq (h : ‖x‖ = ‖y‖) : SameRay ℝ x y ↔ x = y 
goal: SameRay ℝ x y ↔ x = y

full_name: not_sameRay_iff_of_norm_eq
code: theorem not_sameRay_iff_of_norm_eq (h : ‖x‖ = ‖y‖) : ¬SameRay ℝ x y ↔ x ≠ y 
goal: ¬SameRay ℝ x y ↔ x ≠ y

full_name: SameRay.eq_of_norm_eq
code: /-- If two points on the same ray have the same norm, then they are equal. -/
theorem SameRay.eq_of_norm_eq (h : SameRay ℝ x y) (hn : ‖x‖ = ‖y‖) : x = y 
goal: x = y

full_name: SameRay.norm_eq_iff
code: /-- The norms of two vectors on the same ray are equal if and only if they are equal. -/
theorem SameRay.norm_eq_iff (h : SameRay ℝ x y) : ‖x‖ = ‖y‖ ↔ x = y 
goal: ‖x‖ = ‖y‖ ↔ x = y
File: Mathlib/Analysis/Normed/Module/Span.lean

full_name: LinearMap.toSpanSingleton_homothety
code: theorem toSpanSingleton_homothety (x : E) (c : 𝕜) :
    ‖LinearMap.toSpanSingleton 𝕜 E x c‖ = ‖x‖ * ‖c‖ 
goal: ‖(LinearMap.toSpanSingleton 𝕜 E x) c‖ = ‖x‖ * ‖c‖

full_name: LinearEquiv.toSpanNonzeroSingleton_homothety
code: theorem _root_.LinearEquiv.toSpanNonzeroSingleton_homothety (x : E) (h : x ≠ 0) (c : 𝕜) :
    ‖LinearEquiv.toSpanNonzeroSingleton 𝕜 E x h c‖ = ‖x‖ * ‖c‖ 
goal: ‖(LinearEquiv.toSpanNonzeroSingleton 𝕜 E x h) c‖ = ‖x‖ * ‖c‖

full_name: ContinuousLinearEquiv.toSpanNonzeroSingleton
code: /-- Given a nonzero element `x` of a normed space `E₁` over a field `𝕜`, the natural
    continuous linear equivalence from `E₁` to the span of `x`. -/
noncomputable def toSpanNonzeroSingleton (x : E) (h : x ≠ 0) : 𝕜 ≃L[𝕜] 𝕜 ∙ x 
goal: 𝕜 ≃L[𝕜] ↥(Submodule.span 𝕜 {x})

full_name: ContinuousLinearEquiv.coord
code: /-- Given a nonzero element `x` of a normed space `E₁` over a field `𝕜`, the natural continuous
    linear map from the span of `x` to `𝕜`. -/
noncomputable def coord (x : E) (h : x ≠ 0) : (𝕜 ∙ x) →L[𝕜] 𝕜 
goal: ↥(Submodule.span 𝕜 {x}) →L[𝕜] 𝕜

full_name: ContinuousLinearEquiv.coe_toSpanNonzeroSingleton_symm
code: @[simp]
theorem coe_toSpanNonzeroSingleton_symm {x : E} (h : x ≠ 0) :
    ⇑(toSpanNonzeroSingleton 𝕜 x h).symm = coord 𝕜 x h 
goal: ⇑(ContinuousLinearEquiv.toSpanNonzeroSingleton 𝕜 x h).symm = ⇑(ContinuousLinearEquiv.coord 𝕜 x h)

full_name: ContinuousLinearEquiv.coord_toSpanNonzeroSingleton
code: @[simp]
theorem coord_toSpanNonzeroSingleton {x : E} (h : x ≠ 0) (c : 𝕜) :
    coord 𝕜 x h (toSpanNonzeroSingleton 𝕜 x h c) = c 
goal: (ContinuousLinearEquiv.coord 𝕜 x h) ((ContinuousLinearEquiv.toSpanNonzeroSingleton 𝕜 x h) c) = c

full_name: ContinuousLinearEquiv.toSpanNonzeroSingleton_coord
code: @[simp]
theorem toSpanNonzeroSingleton_coord {x : E} (h : x ≠ 0) (y : 𝕜 ∙ x) :
    toSpanNonzeroSingleton 𝕜 x h (coord 𝕜 x h y) = y 
goal: (ContinuousLinearEquiv.toSpanNonzeroSingleton 𝕜 x h) ((ContinuousLinearEquiv.coord 𝕜 x h) y) = y

full_name: ContinuousLinearEquiv.coord_self
code: @[simp]
theorem coord_self (x : E) (h : x ≠ 0) :
    (coord 𝕜 x h) (⟨x, Submodule.mem_span_singleton_self x⟩ : 𝕜 ∙ x) = 1 
goal: (ContinuousLinearEquiv.coord 𝕜 x h) ⟨x, ⋯⟩ = 1

full_name: LinearIsometryEquiv.toSpanUnitSingleton
code: /-- Given a unit element `x` of a normed space `E` over a field `𝕜`, the natural
    linear isometry equivalence from `E` to the span of `x`. -/
noncomputable def toSpanUnitSingleton (x : E) (hx : ‖x‖ = 1) :
    𝕜 ≃ₗᵢ[𝕜] 𝕜 ∙ x 
goal: 𝕜 ≃ₗᵢ[𝕜] ↥(Submodule.span 𝕜 {x})

full_name: LinearIsometryEquiv.toSpanUnitSingleton_apply
code: @[simp] theorem toSpanUnitSingleton_apply (x : E) (hx : ‖x‖ = 1) (r : 𝕜) :
    toSpanUnitSingleton x hx r = (⟨r • x, by aesop⟩ : 𝕜 ∙ x) 
goal: (LinearIsometryEquiv.toSpanUnitSingleton x hx) r = ⟨r • x, ⋯⟩
File: Mathlib/Analysis/Normed/Module/Completion.lean

full_name: UniformSpace.Completion.NormedSpace.to_uniformContinuousConstSMul
code: instance (priority := 100) NormedSpace.to_uniformContinuousConstSMul :
    UniformContinuousConstSMul 𝕜 E 
goal: UniformContinuousConstSMul 𝕜 E

full_name: UniformSpace.Completion.instNormedSpace
code: instance : NormedSpace 𝕜 (Completion E) 
goal: NormedSpace 𝕜 (UniformSpace.Completion E)

full_name: UniformSpace.Completion.toComplₗᵢ
code: /-- Embedding of a normed space to its completion as a linear isometry. -/
def toComplₗᵢ : E →ₗᵢ[𝕜] Completion E 
goal: E →ₗᵢ[𝕜] UniformSpace.Completion E

full_name: UniformSpace.Completion.coe_toComplₗᵢ
code: @[simp]
theorem coe_toComplₗᵢ : ⇑(toComplₗᵢ : E →ₗᵢ[𝕜] Completion E) = ((↑) : E → Completion E) 
goal: ⇑UniformSpace.Completion.toComplₗᵢ = ↑E

full_name: UniformSpace.Completion.toComplL
code: /-- Embedding of a normed space to its completion as a continuous linear map. -/
def toComplL : E →L[𝕜] Completion E 
goal: E →L[𝕜] UniformSpace.Completion E

full_name: UniformSpace.Completion.coe_toComplL
code: @[simp]
theorem coe_toComplL : ⇑(toComplL : E →L[𝕜] Completion E) = ((↑) : E → Completion E) 
goal: ⇑UniformSpace.Completion.toComplL = ↑E

full_name: UniformSpace.Completion.norm_toComplL
code: @[simp]
theorem norm_toComplL {𝕜 E : Type*} [NontriviallyNormedField 𝕜] [NormedAddCommGroup E]
    [NormedSpace 𝕜 E] [Nontrivial E] : ‖(toComplL : E →L[𝕜] Completion E)‖ = 1 
goal: ‖UniformSpace.Completion.toComplL‖ = 1

full_name: UniformSpace.Completion.instNormedRing
code: instance [SeminormedRing A] : NormedRing (Completion A) 
goal: NormedRing (UniformSpace.Completion A)

full_name: UniformSpace.Completion.instNormedAlgebraOfUniformContinuousConstSMul
code: instance [SeminormedCommRing A] [NormedAlgebra 𝕜 A] [UniformContinuousConstSMul 𝕜 A] :
    NormedAlgebra 𝕜 (Completion A) 
goal: NormedAlgebra 𝕜 (UniformSpace.Completion A)