File: Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean

full_name: ContinuousMultilinearMap.continuous_eval
code: /-- Applying a multilinear map to a vector is continuous in both coordinates. -/
theorem ContinuousMultilinearMap.continuous_eval {𝕜 ι : Type*} {E : ι → Type*} {F : Type*}
    [NormedField 𝕜] [Finite ι] [∀ i, SeminormedAddCommGroup (E i)] [∀ i, NormedSpace 𝕜 (E i)]
    [TopologicalSpace F] [AddCommGroup F] [TopologicalAddGroup F] [Module 𝕜 F] :
    Continuous fun p : ContinuousMultilinearMap 𝕜 E F × ∀ i, E i => p.1 p.2 
goal: Continuous fun p => p.1 p.2

full_name: MultilinearMap.norm_map_coord_zero
code: /-- If `f` is a continuous multilinear map in finitely many variables on `E` and `m` is an element
of `∀ i, E i` such that one of the `m i` has norm `0`, then `f m` has norm `0`.

Note that we cannot drop the continuity assumption because `f (m : Unit → E) = f (m ())`,
where the domain has zero norm and the codomain has a nonzero norm
does not satisfy this condition. -/
lemma norm_map_coord_zero (hf : Continuous f) {m : ∀ i, E i} {i : ι} (hi : ‖m i‖ = 0) :
    ‖f m‖ = 0 
goal: ‖f m‖ = 0

full_name: MultilinearMap.bound_of_shell_of_norm_map_coord_zero
code: theorem bound_of_shell_of_norm_map_coord_zero (hf₀ : ∀ {m i}, ‖m i‖ = 0 → ‖f m‖ = 0)
    {ε : ι → ℝ} {C : ℝ} (hε : ∀ i, 0 < ε i) {c : ι → 𝕜} (hc : ∀ i, 1 < ‖c i‖)
    (hf : ∀ m : ∀ i, E i, (∀ i, ε i / ‖c i‖ ≤ ‖m i‖) → (∀ i, ‖m i‖ < ε i) → ‖f m‖ ≤ C * ∏ i, ‖m i‖)
    (m : ∀ i, E i) : ‖f m‖ ≤ C * ∏ i, ‖m i‖ 
goal: ‖f m‖ ≤ C * ∏ i : ι, ‖m i‖

full_name: MultilinearMap.bound_of_shell_of_continuous
code: /-- If a continuous multilinear map in finitely many variables on normed spaces satisfies
the inequality `‖f m‖ ≤ C * ∏ i, ‖m i‖` on a shell `ε i / ‖c i‖ < ‖m i‖ < ε i` for some positive
numbers `ε i` and elements `c i : 𝕜`, `1 < ‖c i‖`, then it satisfies this inequality for all `m`. -/
theorem bound_of_shell_of_continuous (hfc : Continuous f)
    {ε : ι → ℝ} {C : ℝ} (hε : ∀ i, 0 < ε i) {c : ι → 𝕜} (hc : ∀ i, 1 < ‖c i‖)
    (hf : ∀ m : ∀ i, E i, (∀ i, ε i / ‖c i‖ ≤ ‖m i‖) → (∀ i, ‖m i‖ < ε i) → ‖f m‖ ≤ C * ∏ i, ‖m i‖)
    (m : ∀ i, E i) : ‖f m‖ ≤ C * ∏ i, ‖m i‖ 
goal: ‖f m‖ ≤ C * ∏ i : ι, ‖m i‖

full_name: MultilinearMap.exists_bound_of_continuous
code: /-- If a multilinear map in finitely many variables on normed spaces is continuous, then it
satisfies the inequality `‖f m‖ ≤ C * ∏ i, ‖m i‖`, for some `C` which can be chosen to be
positive. -/
theorem exists_bound_of_continuous (hf : Continuous f) :
    ∃ C : ℝ, 0 < C ∧ ∀ m, ‖f m‖ ≤ C * ∏ i, ‖m i‖ 
goal: ∃ C, 0 < C ∧ ∀ (m : (i : ι) → E i), ‖f m‖ ≤ C * ∏ i : ι, ‖m i‖

full_name: MultilinearMap.norm_image_sub_le_of_bound'
code: /-- If `f` satisfies a boundedness property around `0`, one can deduce a bound on `f m₁ - f m₂`
using the multilinearity. Here, we give a precise but hard to use version. See
`norm_image_sub_le_of_bound` for a less precise but more usable version. The bound reads
`‖f m - f m'‖ ≤
  C * ‖m 1 - m' 1‖ * max ‖m 2‖ ‖m' 2‖ * max ‖m 3‖ ‖m' 3‖ * ... * max ‖m n‖ ‖m' n‖ + ...`,
where the other terms in the sum are the same products where `1` is replaced by any `i`. -/
theorem norm_image_sub_le_of_bound' [DecidableEq ι] {C : ℝ} (hC : 0 ≤ C)
    (H : ∀ m, ‖f m‖ ≤ C * ∏ i, ‖m i‖) (m₁ m₂ : ∀ i, E i) :
    ‖f m₁ - f m₂‖ ≤ C * ∑ i, ∏ j, if j = i then ‖m₁ i - m₂ i‖ else max ‖m₁ j‖ ‖m₂ j‖ 
goal: ‖f m₁ - f m₂‖ ≤ C * ∑ i : ι, ∏ j : ι, if j = i then ‖m₁ i - m₂ i‖ else max ‖m₁ j‖ ‖m₂ j‖

full_name: MultilinearMap.norm_image_sub_le_of_bound
code: /-- If `f` satisfies a boundedness property around `0`, one can deduce a bound on `f m₁ - f m₂`
using the multilinearity. Here, we give a usable but not very precise version. See
`norm_image_sub_le_of_bound'` for a more precise but less usable version. The bound is
`‖f m - f m'‖ ≤ C * card ι * ‖m - m'‖ * (max ‖m‖ ‖m'‖) ^ (card ι - 1)`. -/
theorem norm_image_sub_le_of_bound {C : ℝ} (hC : 0 ≤ C) (H : ∀ m, ‖f m‖ ≤ C * ∏ i, ‖m i‖)
    (m₁ m₂ : ∀ i, E i) :
    ‖f m₁ - f m₂‖ ≤ C * Fintype.card ι * max ‖m₁‖ ‖m₂‖ ^ (Fintype.card ι - 1) * ‖m₁ - m₂‖ 
goal: ‖f m₁ - f m₂‖ ≤ C * ↑(Fintype.card ι) * max ‖m₁‖ ‖m₂‖ ^ (Fintype.card ι - 1) * ‖m₁ - m₂‖

full_name: MultilinearMap.continuous_of_bound
code: /-- If a multilinear map satisfies an inequality `‖f m‖ ≤ C * ∏ i, ‖m i‖`, then it is
continuous. -/
theorem continuous_of_bound (C : ℝ) (H : ∀ m, ‖f m‖ ≤ C * ∏ i, ‖m i‖) : Continuous f 
goal: Continuous ⇑f

full_name: MultilinearMap.mkContinuous
code: /-- Constructing a continuous multilinear map from a multilinear map satisfying a boundedness
condition. -/
def mkContinuous (C : ℝ) (H : ∀ m, ‖f m‖ ≤ C * ∏ i, ‖m i‖) : ContinuousMultilinearMap 𝕜 E G 
goal: ContinuousMultilinearMap 𝕜 E G

full_name: MultilinearMap.coe_mkContinuous
code: @[simp]
theorem coe_mkContinuous (C : ℝ) (H : ∀ m, ‖f m‖ ≤ C * ∏ i, ‖m i‖) : ⇑(f.mkContinuous C H) = f 
goal: ⇑(f.mkContinuous C H) = ⇑f

full_name: MultilinearMap.restr_norm_le
code: /-- Given a multilinear map in `n` variables, if one restricts it to `k` variables putting `z` on
the other coordinates, then the resulting restricted function satisfies an inequality
`‖f.restr v‖ ≤ C * ‖z‖^(n-k) * Π ‖v i‖` if the original function satisfies `‖f v‖ ≤ C * Π ‖v i‖`. -/
theorem restr_norm_le {k n : ℕ} (f : (MultilinearMap 𝕜 (fun _ : Fin n => G) G' : _))
    (s : Finset (Fin n)) (hk : s.card = k) (z : G) {C : ℝ} (H : ∀ m, ‖f m‖ ≤ C * ∏ i, ‖m i‖)
    (v : Fin k → G) : ‖f.restr s hk z v‖ ≤ C * ‖z‖ ^ (n - k) * ∏ i, ‖v i‖ 
goal: ‖(f.restr s hk z) v‖ ≤ C * ‖z‖ ^ (n - k) * ∏ i : Fin k, ‖v i‖

full_name: ContinuousMultilinearMap.bound
code: theorem bound : ∃ C : ℝ, 0 < C ∧ ∀ m, ‖f m‖ ≤ C * ∏ i, ‖m i‖ 
goal: ∃ C, 0 < C ∧ ∀ (m : (i : ι) → E i), ‖f m‖ ≤ C * ∏ i : ι, ‖m i‖

full_name: ContinuousMultilinearMap.opNorm
code: /-- The operator norm of a continuous multilinear map is the inf of all its bounds. -/
def opNorm 
goal: ℝ

full_name: ContinuousMultilinearMap.hasOpNorm
code: instance hasOpNorm : Norm (ContinuousMultilinearMap 𝕜 E G) 
goal: Norm (ContinuousMultilinearMap 𝕜 E G)

full_name: ContinuousMultilinearMap.hasOpNorm'
code: /-- An alias of `ContinuousMultilinearMap.hasOpNorm` with non-dependent types to help typeclass
search. -/
instance hasOpNorm' : Norm (ContinuousMultilinearMap 𝕜 (fun _ : ι => G) G') 
goal: Norm (ContinuousMultilinearMap 𝕜 (fun x => G) G')

full_name: ContinuousMultilinearMap.norm_def
code: theorem norm_def : ‖f‖ = sInf { c | 0 ≤ (c : ℝ) ∧ ∀ m, ‖f m‖ ≤ c * ∏ i, ‖m i‖ } 
goal: ‖f‖ = sInf {c | 0 ≤ c ∧ ∀ (m : (i : ι) → E i), ‖f m‖ ≤ c * ∏ i : ι, ‖m i‖}

full_name: ContinuousMultilinearMap.bounds_nonempty
code: theorem bounds_nonempty {f : ContinuousMultilinearMap 𝕜 E G} :
    ∃ c, c ∈ { c | 0 ≤ c ∧ ∀ m, ‖f m‖ ≤ c * ∏ i, ‖m i‖ } 
goal: ∃ c, c ∈ {c | 0 ≤ c ∧ ∀ (m : (i : ι) → E i), ‖f m‖ ≤ c * ∏ i : ι, ‖m i‖}

full_name: ContinuousMultilinearMap.bounds_bddBelow
code: theorem bounds_bddBelow {f : ContinuousMultilinearMap 𝕜 E G} :
    BddBelow { c | 0 ≤ c ∧ ∀ m, ‖f m‖ ≤ c * ∏ i, ‖m i‖ } 
goal: BddBelow {c | 0 ≤ c ∧ ∀ (m : (i : ι) → E i), ‖f m‖ ≤ c * ∏ i : ι, ‖m i‖}

full_name: ContinuousMultilinearMap.isLeast_opNorm
code: theorem isLeast_opNorm : IsLeast {c : ℝ | 0 ≤ c ∧ ∀ m, ‖f m‖ ≤ c * ∏ i, ‖m i‖} ‖f‖ 
goal: IsLeast {c | 0 ≤ c ∧ ∀ (m : (i : ι) → E i), ‖f m‖ ≤ c * ∏ i : ι, ‖m i‖} ‖f‖

full_name: ContinuousMultilinearMap.opNorm_nonneg
code: theorem opNorm_nonneg : 0 ≤ ‖f‖ 
goal: 0 ≤ ‖f‖

full_name: ContinuousMultilinearMap.le_opNorm
code: /-- The fundamental property of the operator norm of a continuous multilinear map:
`‖f m‖` is bounded by `‖f‖` times the product of the `‖m i‖`. -/
theorem le_opNorm : ‖f m‖ ≤ ‖f‖ * ∏ i, ‖m i‖ 
goal: ‖f m‖ ≤ ‖f‖ * ∏ i : ι, ‖m i‖

full_name: ContinuousMultilinearMap.le_mul_prod_of_le_opNorm_of_le
code: theorem le_mul_prod_of_le_opNorm_of_le {C : ℝ} {b : ι → ℝ} (hC : ‖f‖ ≤ C) (hm : ∀ i, ‖m i‖ ≤ b i) :
    ‖f m‖ ≤ C * ∏ i, b i 
goal: ‖f m‖ ≤ C * ∏ i : ι, b i

full_name: ContinuousMultilinearMap.le_opNorm_mul_prod_of_le
code: theorem le_opNorm_mul_prod_of_le {b : ι → ℝ} (hm : ∀ i, ‖m i‖ ≤ b i) : ‖f m‖ ≤ ‖f‖ * ∏ i, b i 
goal: ‖f m‖ ≤ ‖f‖ * ∏ i : ι, b i

full_name: ContinuousMultilinearMap.le_opNorm_mul_pow_card_of_le
code: theorem le_opNorm_mul_pow_card_of_le {b : ℝ} (hm : ‖m‖ ≤ b) :
    ‖f m‖ ≤ ‖f‖ * b ^ Fintype.card ι 
goal: ‖f m‖ ≤ ‖f‖ * b ^ Fintype.card ι

full_name: ContinuousMultilinearMap.le_opNorm_mul_pow_of_le
code: theorem le_opNorm_mul_pow_of_le {n : ℕ} {Ei : Fin n → Type*} [∀ i, SeminormedAddCommGroup (Ei i)]
    [∀ i, NormedSpace 𝕜 (Ei i)] (f : ContinuousMultilinearMap 𝕜 Ei G) {m : ∀ i, Ei i} {b : ℝ}
    (hm : ‖m‖ ≤ b) : ‖f m‖ ≤ ‖f‖ * b ^ n 
goal: ‖f m‖ ≤ ‖f‖ * b ^ n

full_name: ContinuousMultilinearMap.le_of_opNorm_le
code: theorem le_of_opNorm_le {C : ℝ} (h : ‖f‖ ≤ C) : ‖f m‖ ≤ C * ∏ i, ‖m i‖ 
goal: ‖f m‖ ≤ C * ∏ i : ι, ‖m i‖

full_name: ContinuousMultilinearMap.ratio_le_opNorm
code: theorem ratio_le_opNorm : (‖f m‖ / ∏ i, ‖m i‖) ≤ ‖f‖ 
goal: ‖f m‖ / ∏ i : ι, ‖m i‖ ≤ ‖f‖

full_name: ContinuousMultilinearMap.unit_le_opNorm
code: /-- The image of the unit ball under a continuous multilinear map is bounded. -/
theorem unit_le_opNorm (h : ‖m‖ ≤ 1) : ‖f m‖ ≤ ‖f‖ 
goal: ‖f m‖ ≤ ‖f‖

full_name: ContinuousMultilinearMap.opNorm_le_bound
code: /-- If one controls the norm of every `f x`, then one controls the norm of `f`. -/
theorem opNorm_le_bound {M : ℝ} (hMp : 0 ≤ M) (hM : ∀ m, ‖f m‖ ≤ M * ∏ i, ‖m i‖) : ‖f‖ ≤ M 
goal: ‖f‖ ≤ M

full_name: ContinuousMultilinearMap.opNorm_le_iff
code: theorem opNorm_le_iff {C : ℝ} (hC : 0 ≤ C) : ‖f‖ ≤ C ↔ ∀ m, ‖f m‖ ≤ C * ∏ i, ‖m i‖ 
goal: ‖f‖ ≤ C ↔ ∀ (m : (i : ι) → E i), ‖f m‖ ≤ C * ∏ i : ι, ‖m i‖

full_name: ContinuousMultilinearMap.opNorm_add_le
code: /-- The operator norm satisfies the triangle inequality. -/
theorem opNorm_add_le : ‖f + g‖ ≤ ‖f‖ + ‖g‖ 
goal: ‖f + g‖ ≤ ‖f‖ + ‖g‖

full_name: ContinuousMultilinearMap.opNorm_zero
code: theorem opNorm_zero : ‖(0 : ContinuousMultilinearMap 𝕜 E G)‖ = 0 
goal: ‖0‖ = 0

full_name: ContinuousMultilinearMap.opNorm_smul_le
code: theorem opNorm_smul_le (c : 𝕜') : ‖c • f‖ ≤ ‖c‖ * ‖f‖ 
goal: ‖c • f‖ ≤ ‖c‖ * ‖f‖

full_name: ContinuousMultilinearMap.opNorm_neg
code: theorem opNorm_neg : ‖-f‖ = ‖f‖ 
goal: ‖-f‖ = ‖f‖

full_name: ContinuousMultilinearMap.seminorm
code: /-- Operator seminorm on the space of continuous multilinear maps, as `Seminorm`.

We use this seminorm
to define a `SeminormedAddCommGroup` structure on `ContinuousMultilinearMap 𝕜 E G`,
but we have to override the projection `UniformSpace`
so that it is definitionally equal to the one coming from the topologies on `E` and `G`. -/
protected def seminorm : Seminorm 𝕜 (ContinuousMultilinearMap 𝕜 E G) 
goal: Seminorm 𝕜 (ContinuousMultilinearMap 𝕜 E G)

full_name: _private.Mathlib.Analysis.NormedSpace.Multilinear.Basic.0.ContinuousMultilinearMap.uniformity_eq_seminorm
code: private lemma uniformity_eq_seminorm :
    𝓤 (ContinuousMultilinearMap 𝕜 E G) = ⨅ r > 0, 𝓟 {f | ‖f.1 - f.2‖ < r} 
goal: 𝓤 (ContinuousMultilinearMap 𝕜 E G) = ⨅ r, ⨅ (_ : r > 0), 𝓟 {f | ‖f.1 - f.2‖ < r}

full_name: ContinuousMultilinearMap.instPseudoMetricSpace
code: instance instPseudoMetricSpace : PseudoMetricSpace (ContinuousMultilinearMap 𝕜 E G) 
goal: PseudoMetricSpace (ContinuousMultilinearMap 𝕜 E G)

full_name: ContinuousMultilinearMap.seminormedAddCommGroup
code: /-- Continuous multilinear maps themselves form a seminormed space with respect to
    the operator norm. -/
instance seminormedAddCommGroup :
    SeminormedAddCommGroup (ContinuousMultilinearMap 𝕜 E G) 
goal: SeminormedAddCommGroup (ContinuousMultilinearMap 𝕜 E G)

full_name: ContinuousMultilinearMap.seminormedAddCommGroup'
code: /-- An alias of `ContinuousMultilinearMap.seminormedAddCommGroup` with non-dependent types to help
typeclass search. -/
instance seminormedAddCommGroup' :
    SeminormedAddCommGroup (ContinuousMultilinearMap 𝕜 (fun _ : ι => G) G') 
goal: SeminormedAddCommGroup (ContinuousMultilinearMap 𝕜 (fun x => G) G')

full_name: ContinuousMultilinearMap.normedSpace
code: instance normedSpace : NormedSpace 𝕜' (ContinuousMultilinearMap 𝕜 E G) 
goal: NormedSpace 𝕜' (ContinuousMultilinearMap 𝕜 E G)

full_name: ContinuousMultilinearMap.normedSpace'
code: /-- An alias of `ContinuousMultilinearMap.normedSpace` with non-dependent types to help typeclass
search. -/
instance normedSpace' : NormedSpace 𝕜' (ContinuousMultilinearMap 𝕜 (fun _ : ι => G') G) 
goal: NormedSpace 𝕜' (ContinuousMultilinearMap 𝕜 (fun x => G') G)

full_name: ContinuousMultilinearMap.le_opNNNorm
code: /-- The fundamental property of the operator norm of a continuous multilinear map:
`‖f m‖` is bounded by `‖f‖` times the product of the `‖m i‖`, `nnnorm` version. -/
theorem le_opNNNorm : ‖f m‖₊ ≤ ‖f‖₊ * ∏ i, ‖m i‖₊ 
goal: ‖f m‖₊ ≤ ‖f‖₊ * ∏ i : ι, ‖m i‖₊

full_name: ContinuousMultilinearMap.le_of_opNNNorm_le
code: theorem le_of_opNNNorm_le {C : ℝ≥0} (h : ‖f‖₊ ≤ C) : ‖f m‖₊ ≤ C * ∏ i, ‖m i‖₊ 
goal: ‖f m‖₊ ≤ C * ∏ i : ι, ‖m i‖₊

full_name: ContinuousMultilinearMap.opNNNorm_le_iff
code: theorem opNNNorm_le_iff {C : ℝ≥0} : ‖f‖₊ ≤ C ↔ ∀ m, ‖f m‖₊ ≤ C * ∏ i, ‖m i‖₊ 
goal: ‖f‖₊ ≤ C ↔ ∀ (m : (i : ι) → E i), ‖f m‖₊ ≤ C * ∏ i : ι, ‖m i‖₊

full_name: ContinuousMultilinearMap.isLeast_opNNNorm
code: theorem isLeast_opNNNorm : IsLeast {C : ℝ≥0 | ∀ m, ‖f m‖₊ ≤ C * ∏ i, ‖m i‖₊} ‖f‖₊ 
goal: IsLeast {C | ∀ (m : (i : ι) → E i), ‖f m‖₊ ≤ C * ∏ i : ι, ‖m i‖₊} ‖f‖₊

full_name: ContinuousMultilinearMap.opNNNorm_prod
code: theorem opNNNorm_prod (f : ContinuousMultilinearMap 𝕜 E G) (g : ContinuousMultilinearMap 𝕜 E G') :
    ‖f.prod g‖₊ = max ‖f‖₊ ‖g‖₊ 
goal: ‖f.prod g‖₊ = max ‖f‖₊ ‖g‖₊

full_name: ContinuousMultilinearMap.opNorm_prod
code: theorem opNorm_prod (f : ContinuousMultilinearMap 𝕜 E G) (g : ContinuousMultilinearMap 𝕜 E G') :
    ‖f.prod g‖ = max ‖f‖ ‖g‖ 
goal: ‖f.prod g‖ = max ‖f‖ ‖g‖

full_name: ContinuousMultilinearMap.opNNNorm_pi
code: theorem opNNNorm_pi
    [∀ i', SeminormedAddCommGroup (E' i')] [∀ i', NormedSpace 𝕜 (E' i')]
    (f : ∀ i', ContinuousMultilinearMap 𝕜 E (E' i')) : ‖pi f‖₊ = ‖f‖₊ 
goal: ‖ContinuousMultilinearMap.pi f‖₊ = ‖f‖₊

full_name: ContinuousMultilinearMap.opNorm_pi
code: theorem opNorm_pi {ι' : Type v'} [Fintype ι'] {E' : ι' → Type wE'}
    [∀ i', SeminormedAddCommGroup (E' i')] [∀ i', NormedSpace 𝕜 (E' i')]
    (f : ∀ i', ContinuousMultilinearMap 𝕜 E (E' i')) :
    ‖pi f‖ = ‖f‖ 
goal: ‖ContinuousMultilinearMap.pi f‖ = ‖f‖

full_name: ContinuousMultilinearMap.norm_ofSubsingleton
code: @[simp]
theorem norm_ofSubsingleton [Subsingleton ι] (i : ι) (f : G →L[𝕜] G') :
    ‖ofSubsingleton 𝕜 G G' i f‖ = ‖f‖ 
goal: ‖(ContinuousMultilinearMap.ofSubsingleton 𝕜 G G' i) f‖ = ‖f‖

full_name: ContinuousMultilinearMap.nnnorm_ofSubsingleton
code: @[simp]
theorem nnnorm_ofSubsingleton [Subsingleton ι] (i : ι) (f : G →L[𝕜] G') :
    ‖ofSubsingleton 𝕜 G G' i f‖₊ = ‖f‖₊ 
goal: ‖(ContinuousMultilinearMap.ofSubsingleton 𝕜 G G' i) f‖₊ = ‖f‖₊

full_name: ContinuousMultilinearMap.ofSubsingletonₗᵢ
code: /-- Linear isometry between continuous linear maps from `G` to `G'`
and continuous `1`-multilinear maps from `G` to `G'`. -/
@[simps apply symm_apply]
def ofSubsingletonₗᵢ [Subsingleton ι] (i : ι) :
    (G →L[𝕜] G') ≃ₗᵢ[𝕜] ContinuousMultilinearMap 𝕜 (fun _ : ι ↦ G) G' 
goal: (G →L[𝕜] G') ≃ₗᵢ[𝕜] ContinuousMultilinearMap 𝕜 (fun x => G) G'

full_name: ContinuousMultilinearMap.ofSubsingletonₗᵢ_symm_apply
code: /-- Linear isometry between continuous linear maps from `G` to `G'`
and continuous `1`-multilinear maps from `G` to `G'`. -/
@[simps apply symm_apply]
def ofSubsingletonₗᵢ [Subsingleton ι] (i : ι) :
    (G →L[𝕜] G') ≃ₗᵢ[𝕜] ContinuousMultilinearMap 𝕜 (fun _ : ι ↦ G) G' 
goal: ∀ (a : ContinuousMultilinearMap 𝕜 (fun x => G) G'),
  (ContinuousMultilinearMap.ofSubsingletonₗᵢ 𝕜 G i).symm a = (ContinuousMultilinearMap.ofSubsingleton 𝕜 G G' i).invFun a

full_name: ContinuousMultilinearMap.ofSubsingletonₗᵢ_apply
code: /-- Linear isometry between continuous linear maps from `G` to `G'`
and continuous `1`-multilinear maps from `G` to `G'`. -/
@[simps apply symm_apply]
def ofSubsingletonₗᵢ [Subsingleton ι] (i : ι) :
    (G →L[𝕜] G') ≃ₗᵢ[𝕜] ContinuousMultilinearMap 𝕜 (fun _ : ι ↦ G) G' 
goal: ∀ (a : G →L[𝕜] G'),
  (ContinuousMultilinearMap.ofSubsingletonₗᵢ 𝕜 G i) a = (ContinuousMultilinearMap.ofSubsingleton 𝕜 G G' i).toFun a

full_name: ContinuousMultilinearMap.norm_ofSubsingleton_id_le
code: theorem norm_ofSubsingleton_id_le [Subsingleton ι] (i : ι) :
    ‖ofSubsingleton 𝕜 G G i (.id _ _)‖ ≤ 1 
goal: ‖(ContinuousMultilinearMap.ofSubsingleton 𝕜 G G i) (ContinuousLinearMap.id 𝕜 G)‖ ≤ 1

full_name: ContinuousMultilinearMap.nnnorm_ofSubsingleton_id_le
code: theorem nnnorm_ofSubsingleton_id_le [Subsingleton ι] (i : ι) :
    ‖ofSubsingleton 𝕜 G G i (.id _ _)‖₊ ≤ 1 
goal: ‖(ContinuousMultilinearMap.ofSubsingleton 𝕜 G G i) (ContinuousLinearMap.id 𝕜 G)‖₊ ≤ 1

full_name: ContinuousMultilinearMap.norm_constOfIsEmpty
code: @[simp]
theorem norm_constOfIsEmpty [IsEmpty ι] (x : G) : ‖constOfIsEmpty 𝕜 E x‖ = ‖x‖ 
goal: ‖ContinuousMultilinearMap.constOfIsEmpty 𝕜 E x‖ = ‖x‖

full_name: ContinuousMultilinearMap.nnnorm_constOfIsEmpty
code: @[simp]
theorem nnnorm_constOfIsEmpty [IsEmpty ι] (x : G) : ‖constOfIsEmpty 𝕜 E x‖₊ = ‖x‖₊ 
goal: ‖ContinuousMultilinearMap.constOfIsEmpty 𝕜 E x‖₊ = ‖x‖₊

full_name: ContinuousMultilinearMap.prodL
code: /-- `ContinuousMultilinearMap.prod` as a `LinearIsometryEquiv`. -/
def prodL :
    ContinuousMultilinearMap 𝕜 E G × ContinuousMultilinearMap 𝕜 E G' ≃ₗᵢ[𝕜]
      ContinuousMultilinearMap 𝕜 E (G × G') 
goal: ContinuousMultilinearMap 𝕜 E G × ContinuousMultilinearMap 𝕜 E G' ≃ₗᵢ[𝕜] ContinuousMultilinearMap 𝕜 E (G × G')

full_name: ContinuousMultilinearMap.piₗᵢ
code: /-- `ContinuousMultilinearMap.pi` as a `LinearIsometryEquiv`. -/
def piₗᵢ {ι' : Type v'} [Fintype ι'] {E' : ι' → Type wE'} [∀ i', NormedAddCommGroup (E' i')]
    [∀ i', NormedSpace 𝕜 (E' i')] :
    @LinearIsometryEquiv 𝕜 𝕜 _ _ (RingHom.id 𝕜) _ _ _ (∀ i', ContinuousMultilinearMap 𝕜 E (E' i'))
      (ContinuousMultilinearMap 𝕜 E (∀ i, E' i)) _ _ (@Pi.module ι' _ 𝕜 _ _ fun _ => inferInstance)
      _ 
goal: ((i' : ι') → ContinuousMultilinearMap 𝕜 E (E' i')) ≃ₗᵢ[𝕜] ContinuousMultilinearMap 𝕜 E ((i : ι') → E' i)

full_name: ContinuousMultilinearMap.norm_restrictScalars
code: @[simp]
theorem norm_restrictScalars : ‖f.restrictScalars 𝕜'‖ = ‖f‖ 
goal: ‖ContinuousMultilinearMap.restrictScalars 𝕜' f‖ = ‖f‖

full_name: ContinuousMultilinearMap.restrictScalarsₗᵢ
code: /-- `ContinuousMultilinearMap.restrictScalars` as a `LinearIsometry`. -/
def restrictScalarsₗᵢ : ContinuousMultilinearMap 𝕜 E G →ₗᵢ[𝕜'] ContinuousMultilinearMap 𝕜' E G 
goal: ContinuousMultilinearMap 𝕜 E G →ₗᵢ[𝕜'] ContinuousMultilinearMap 𝕜' E G

full_name: ContinuousMultilinearMap.restrictScalarsLinear
code: /-- `ContinuousMultilinearMap.restrictScalars` as a `ContinuousLinearMap`. -/
def restrictScalarsLinear : ContinuousMultilinearMap 𝕜 E G →L[𝕜'] ContinuousMultilinearMap 𝕜' E G 
goal: ContinuousMultilinearMap 𝕜 E G →L[𝕜'] ContinuousMultilinearMap 𝕜' E G

full_name: ContinuousMultilinearMap.continuous_restrictScalars
code: theorem continuous_restrictScalars :
    Continuous
      (restrictScalars 𝕜' : ContinuousMultilinearMap 𝕜 E G → ContinuousMultilinearMap 𝕜' E G) 
goal: Continuous (ContinuousMultilinearMap.restrictScalars 𝕜')

full_name: ContinuousMultilinearMap.norm_image_sub_le'
code: /-- The difference `f m₁ - f m₂` is controlled in terms of `‖f‖` and `‖m₁ - m₂‖`, precise version.
For a less precise but more usable version, see `norm_image_sub_le`. The bound reads
`‖f m - f m'‖ ≤
  ‖f‖ * ‖m 1 - m' 1‖ * max ‖m 2‖ ‖m' 2‖ * max ‖m 3‖ ‖m' 3‖ * ... * max ‖m n‖ ‖m' n‖ + ...`,
where the other terms in the sum are the same products where `1` is replaced by any `i`. -/
theorem norm_image_sub_le' [DecidableEq ι] (m₁ m₂ : ∀ i, E i) :
    ‖f m₁ - f m₂‖ ≤ ‖f‖ * ∑ i, ∏ j, if j = i then ‖m₁ i - m₂ i‖ else max ‖m₁ j‖ ‖m₂ j‖ 
goal: ‖f m₁ - f m₂‖ ≤ ‖f‖ * ∑ i : ι, ∏ j : ι, if j = i then ‖m₁ i - m₂ i‖ else max ‖m₁ j‖ ‖m₂ j‖

full_name: ContinuousMultilinearMap.norm_image_sub_le
code: /-- The difference `f m₁ - f m₂` is controlled in terms of `‖f‖` and `‖m₁ - m₂‖`, less precise
version. For a more precise but less usable version, see `norm_image_sub_le'`.
The bound is `‖f m - f m'‖ ≤ ‖f‖ * card ι * ‖m - m'‖ * (max ‖m‖ ‖m'‖) ^ (card ι - 1)`. -/
theorem norm_image_sub_le (m₁ m₂ : ∀ i, E i) :
    ‖f m₁ - f m₂‖ ≤ ‖f‖ * Fintype.card ι * max ‖m₁‖ ‖m₂‖ ^ (Fintype.card ι - 1) * ‖m₁ - m₂‖ 
goal: ‖f m₁ - f m₂‖ ≤ ‖f‖ * ↑(Fintype.card ι) * max ‖m₁‖ ‖m₂‖ ^ (Fintype.card ι - 1) * ‖m₁ - m₂‖

full_name: MultilinearMap.mkContinuous_norm_le
code: /-- If a continuous multilinear map is constructed from a multilinear map via the constructor
`mkContinuous`, then its norm is bounded by the bound given to the constructor if it is
nonnegative. -/
theorem MultilinearMap.mkContinuous_norm_le (f : MultilinearMap 𝕜 E G) {C : ℝ} (hC : 0 ≤ C)
    (H : ∀ m, ‖f m‖ ≤ C * ∏ i, ‖m i‖) : ‖f.mkContinuous C H‖ ≤ C 
goal: ‖f.mkContinuous C H‖ ≤ C

full_name: MultilinearMap.mkContinuous_norm_le'
code: /-- If a continuous multilinear map is constructed from a multilinear map via the constructor
`mkContinuous`, then its norm is bounded by the bound given to the constructor if it is
nonnegative. -/
theorem MultilinearMap.mkContinuous_norm_le' (f : MultilinearMap 𝕜 E G) {C : ℝ}
    (H : ∀ m, ‖f m‖ ≤ C * ∏ i, ‖m i‖) : ‖f.mkContinuous C H‖ ≤ max C 0 
goal: ‖f.mkContinuous C H‖ ≤ max C 0

full_name: ContinuousMultilinearMap.restr
code: /-- Given a continuous multilinear map `f` on `n` variables (parameterized by `Fin n`) and a subset
`s` of `k` of these variables, one gets a new continuous multilinear map on `Fin k` by varying
these variables, and fixing the other ones equal to a given value `z`. It is denoted by
`f.restr s hk z`, where `hk` is a proof that the cardinality of `s` is `k`. The implicit
identification between `Fin k` and `s` that we use is the canonical (increasing) bijection. -/
def restr {k n : ℕ} (f : (G[×n]→L[𝕜] G' : _)) (s : Finset (Fin n)) (hk : s.card = k) (z : G) :
    G[×k]→L[𝕜] G' 
goal: ContinuousMultilinearMap 𝕜 (fun i => G) G'

full_name: ContinuousMultilinearMap.norm_restr
code: theorem norm_restr {k n : ℕ} (f : G[×n]→L[𝕜] G') (s : Finset (Fin n)) (hk : s.card = k) (z : G) :
    ‖f.restr s hk z‖ ≤ ‖f‖ * ‖z‖ ^ (n - k) 
goal: ‖f.restr s hk z‖ ≤ ‖f‖ * ‖z‖ ^ (n - k)

full_name: ContinuousMultilinearMap.norm_mkPiAlgebra_le
code: @[simp]
theorem norm_mkPiAlgebra_le [Nonempty ι] : ‖ContinuousMultilinearMap.mkPiAlgebra 𝕜 ι A‖ ≤ 1 
goal: ‖ContinuousMultilinearMap.mkPiAlgebra 𝕜 ι A‖ ≤ 1

full_name: ContinuousMultilinearMap.norm_mkPiAlgebra_of_empty
code: theorem norm_mkPiAlgebra_of_empty [IsEmpty ι] :
    ‖ContinuousMultilinearMap.mkPiAlgebra 𝕜 ι A‖ = ‖(1 : A)‖ 
goal: ‖ContinuousMultilinearMap.mkPiAlgebra 𝕜 ι A‖ = ‖1‖

full_name: ContinuousMultilinearMap.norm_mkPiAlgebra
code: @[simp]
theorem norm_mkPiAlgebra [NormOneClass A] : ‖ContinuousMultilinearMap.mkPiAlgebra 𝕜 ι A‖ = 1 
goal: ‖ContinuousMultilinearMap.mkPiAlgebra 𝕜 ι A‖ = 1

full_name: ContinuousMultilinearMap.norm_mkPiAlgebraFin_succ_le
code: theorem norm_mkPiAlgebraFin_succ_le : ‖ContinuousMultilinearMap.mkPiAlgebraFin 𝕜 n.succ A‖ ≤ 1 
goal: ‖ContinuousMultilinearMap.mkPiAlgebraFin 𝕜 n.succ A‖ ≤ 1

full_name: ContinuousMultilinearMap.norm_mkPiAlgebraFin_le_of_pos
code: theorem norm_mkPiAlgebraFin_le_of_pos (hn : 0 < n) :
    ‖ContinuousMultilinearMap.mkPiAlgebraFin 𝕜 n A‖ ≤ 1 
goal: ‖ContinuousMultilinearMap.mkPiAlgebraFin 𝕜 n A‖ ≤ 1

full_name: ContinuousMultilinearMap.norm_mkPiAlgebraFin_zero
code: theorem norm_mkPiAlgebraFin_zero : ‖ContinuousMultilinearMap.mkPiAlgebraFin 𝕜 0 A‖ = ‖(1 : A)‖ 
goal: ‖ContinuousMultilinearMap.mkPiAlgebraFin 𝕜 0 A‖ = ‖1‖

full_name: ContinuousMultilinearMap.norm_mkPiAlgebraFin
code: @[simp]
theorem norm_mkPiAlgebraFin [NormOneClass A] :
    ‖ContinuousMultilinearMap.mkPiAlgebraFin 𝕜 n A‖ = 1 
goal: ‖ContinuousMultilinearMap.mkPiAlgebraFin 𝕜 n A‖ = 1

full_name: ContinuousMultilinearMap.nnnorm_smulRight
code: @[simp]
theorem nnnorm_smulRight (f : ContinuousMultilinearMap 𝕜 E 𝕜) (z : G) :
    ‖f.smulRight z‖₊ = ‖f‖₊ * ‖z‖₊ 
goal: ‖f.smulRight z‖₊ = ‖f‖₊ * ‖z‖₊

full_name: ContinuousMultilinearMap.norm_smulRight
code: @[simp]
theorem norm_smulRight (f : ContinuousMultilinearMap 𝕜 E 𝕜) (z : G) :
    ‖f.smulRight z‖ = ‖f‖ * ‖z‖ 
goal: ‖f.smulRight z‖ = ‖f‖ * ‖z‖

full_name: ContinuousMultilinearMap.norm_mkPiRing
code: @[simp]
theorem norm_mkPiRing (z : G) : ‖ContinuousMultilinearMap.mkPiRing 𝕜 ι z‖ = ‖z‖ 
goal: ‖ContinuousMultilinearMap.mkPiRing 𝕜 ι z‖ = ‖z‖

full_name: ContinuousMultilinearMap.smulRightL
code: /-- Continuous bilinear map realizing `(f, z) ↦ f.smulRight z`. -/
def smulRightL : ContinuousMultilinearMap 𝕜 E 𝕜 →L[𝕜] G →L[𝕜] ContinuousMultilinearMap 𝕜 E G 
goal: ContinuousMultilinearMap 𝕜 E 𝕜 →L[𝕜] G →L[𝕜] ContinuousMultilinearMap 𝕜 E G

full_name: ContinuousMultilinearMap.smulRightL_apply
code: @[simp] lemma smulRightL_apply (f : ContinuousMultilinearMap 𝕜 E 𝕜) (z : G) :
  smulRightL 𝕜 E G f z = f.smulRight z 
goal: ((ContinuousMultilinearMap.smulRightL 𝕜 E G) f) z = f.smulRight z

full_name: ContinuousMultilinearMap.norm_smulRightL_le
code: lemma norm_smulRightL_le : ‖smulRightL 𝕜 E G‖ ≤ 1 
goal: ‖ContinuousMultilinearMap.smulRightL 𝕜 E G‖ ≤ 1

full_name: ContinuousMultilinearMap.piFieldEquiv
code: /-- Continuous multilinear maps on `𝕜^n` with values in `G` are in bijection with `G`, as such a
continuous multilinear map is completely determined by its value on the constant vector made of
ones. We register this bijection as a linear isometry in
`ContinuousMultilinearMap.piFieldEquiv`. -/
protected def piFieldEquiv : G ≃ₗᵢ[𝕜] ContinuousMultilinearMap 𝕜 (fun _ : ι => 𝕜) G 
goal: G ≃ₗᵢ[𝕜] ContinuousMultilinearMap 𝕜 (fun x => 𝕜) G

full_name: ContinuousLinearMap.norm_compContinuousMultilinearMap_le
code: theorem norm_compContinuousMultilinearMap_le (g : G →L[𝕜] G') (f : ContinuousMultilinearMap 𝕜 E G) :
    ‖g.compContinuousMultilinearMap f‖ ≤ ‖g‖ * ‖f‖ 
goal: ‖g.compContinuousMultilinearMap f‖ ≤ ‖g‖ * ‖f‖

full_name: ContinuousLinearMap.compContinuousMultilinearMapL
code: /-- `ContinuousLinearMap.compContinuousMultilinearMap` as a bundled continuous bilinear map. -/
def compContinuousMultilinearMapL :
    (G →L[𝕜] G') →L[𝕜] ContinuousMultilinearMap 𝕜 E G →L[𝕜] ContinuousMultilinearMap 𝕜 E G' 
goal: (G →L[𝕜] G') →L[𝕜] ContinuousMultilinearMap 𝕜 E G →L[𝕜] ContinuousMultilinearMap 𝕜 E G'

full_name: ContinuousLinearEquiv.compContinuousMultilinearMapL
code: /-- `ContinuousLinearMap.compContinuousMultilinearMap` as a bundled
continuous linear equiv. -/
nonrec
def _root_.ContinuousLinearEquiv.compContinuousMultilinearMapL (g : G ≃L[𝕜] G') :
    ContinuousMultilinearMap 𝕜 E G ≃L[𝕜] ContinuousMultilinearMap 𝕜 E G' 
goal: ContinuousMultilinearMap 𝕜 E G ≃L[𝕜] ContinuousMultilinearMap 𝕜 E G'

full_name: ContinuousLinearEquiv.compContinuousMultilinearMapL_symm
code: @[simp]
theorem _root_.ContinuousLinearEquiv.compContinuousMultilinearMapL_symm (g : G ≃L[𝕜] G') :
    (g.compContinuousMultilinearMapL E).symm = g.symm.compContinuousMultilinearMapL E 
goal: (ContinuousLinearEquiv.compContinuousMultilinearMapL E g).symm =
  ContinuousLinearEquiv.compContinuousMultilinearMapL E g.symm

full_name: ContinuousLinearEquiv.compContinuousMultilinearMapL_apply
code: @[simp]
theorem _root_.ContinuousLinearEquiv.compContinuousMultilinearMapL_apply (g : G ≃L[𝕜] G')
    (f : ContinuousMultilinearMap 𝕜 E G) :
    g.compContinuousMultilinearMapL E f = (g : G →L[𝕜] G').compContinuousMultilinearMap f 
goal: (ContinuousLinearEquiv.compContinuousMultilinearMapL E g) f = (↑g).compContinuousMultilinearMap f

full_name: ContinuousLinearMap.flipMultilinear
code: /-- Flip arguments in `f : G →L[𝕜] ContinuousMultilinearMap 𝕜 E G'` to get
`ContinuousMultilinearMap 𝕜 E (G →L[𝕜] G')` -/
@[simps! apply_apply]
def flipMultilinear (f : G →L[𝕜] ContinuousMultilinearMap 𝕜 E G') :
    ContinuousMultilinearMap 𝕜 E (G →L[𝕜] G') 
goal: ContinuousMultilinearMap 𝕜 E (G →L[𝕜] G')

full_name: ContinuousLinearMap.flipMultilinear_apply_apply
code: /-- Flip arguments in `f : G →L[𝕜] ContinuousMultilinearMap 𝕜 E G'` to get
`ContinuousMultilinearMap 𝕜 E (G →L[𝕜] G')` -/
@[simps! apply_apply]
def flipMultilinear (f : G →L[𝕜] ContinuousMultilinearMap 𝕜 E G') :
    ContinuousMultilinearMap 𝕜 E (G →L[𝕜] G') 
goal: (f.flipMultilinear m) x = (f x) m

full_name: LinearIsometry.norm_compContinuousMultilinearMap
code: theorem LinearIsometry.norm_compContinuousMultilinearMap (g : G →ₗᵢ[𝕜] G')
    (f : ContinuousMultilinearMap 𝕜 E G) :
    ‖g.toContinuousLinearMap.compContinuousMultilinearMap f‖ = ‖f‖ 
goal: ‖g.toContinuousLinearMap.compContinuousMultilinearMap f‖ = ‖f‖

full_name: MultilinearMap.mkContinuousLinear
code: /-- Given a map `f : G →ₗ[𝕜] MultilinearMap 𝕜 E G'` and an estimate
`H : ∀ x m, ‖f x m‖ ≤ C * ‖x‖ * ∏ i, ‖m i‖`, construct a continuous linear
map from `G` to `ContinuousMultilinearMap 𝕜 E G'`.

In order to lift, e.g., a map `f : (MultilinearMap 𝕜 E G) →ₗ[𝕜] MultilinearMap 𝕜 E' G'`
to a map `(ContinuousMultilinearMap 𝕜 E G) →L[𝕜] ContinuousMultilinearMap 𝕜 E' G'`,
one can apply this construction to `f.comp ContinuousMultilinearMap.toMultilinearMapLinear`
which is a linear map from `ContinuousMultilinearMap 𝕜 E G` to `MultilinearMap 𝕜 E' G'`. -/
def mkContinuousLinear (f : G →ₗ[𝕜] MultilinearMap 𝕜 E G') (C : ℝ)
    (H : ∀ x m, ‖f x m‖ ≤ C * ‖x‖ * ∏ i, ‖m i‖) : G →L[𝕜] ContinuousMultilinearMap 𝕜 E G' 
goal: G →L[𝕜] ContinuousMultilinearMap 𝕜 E G'

full_name: MultilinearMap.mkContinuousLinear_norm_le'
code: theorem mkContinuousLinear_norm_le' (f : G →ₗ[𝕜] MultilinearMap 𝕜 E G') (C : ℝ)
    (H : ∀ x m, ‖f x m‖ ≤ C * ‖x‖ * ∏ i, ‖m i‖) : ‖mkContinuousLinear f C H‖ ≤ max C 0 
goal: ‖MultilinearMap.mkContinuousLinear f C H‖ ≤ max C 0

full_name: MultilinearMap.mkContinuousLinear_norm_le
code: theorem mkContinuousLinear_norm_le (f : G →ₗ[𝕜] MultilinearMap 𝕜 E G') {C : ℝ} (hC : 0 ≤ C)
    (H : ∀ x m, ‖f x m‖ ≤ C * ‖x‖ * ∏ i, ‖m i‖) : ‖mkContinuousLinear f C H‖ ≤ C 
goal: ‖MultilinearMap.mkContinuousLinear f C H‖ ≤ C

full_name: MultilinearMap.mkContinuousMultilinear
code: /-- Given a map `f : MultilinearMap 𝕜 E (MultilinearMap 𝕜 E' G)` and an estimate
`H : ∀ m m', ‖f m m'‖ ≤ C * ∏ i, ‖m i‖ * ∏ i, ‖m' i‖`, upgrade all `MultilinearMap`s in the type to
`ContinuousMultilinearMap`s. -/
def mkContinuousMultilinear (f : MultilinearMap 𝕜 E (MultilinearMap 𝕜 E' G)) (C : ℝ)
    (H : ∀ m₁ m₂, ‖f m₁ m₂‖ ≤ (C * ∏ i, ‖m₁ i‖) * ∏ i, ‖m₂ i‖) :
    ContinuousMultilinearMap 𝕜 E (ContinuousMultilinearMap 𝕜 E' G) 
goal: ContinuousMultilinearMap 𝕜 E (ContinuousMultilinearMap 𝕜 E' G)

full_name: MultilinearMap.mkContinuousMultilinear_apply
code: @[simp]
theorem mkContinuousMultilinear_apply (f : MultilinearMap 𝕜 E (MultilinearMap 𝕜 E' G)) {C : ℝ}
    (H : ∀ m₁ m₂, ‖f m₁ m₂‖ ≤ (C * ∏ i, ‖m₁ i‖) * ∏ i, ‖m₂ i‖) (m : ∀ i, E i) :
    ⇑(mkContinuousMultilinear f C H m) = f m 
goal: ⇑((f.mkContinuousMultilinear C H) m) = ⇑(f m)

full_name: MultilinearMap.mkContinuousMultilinear_norm_le'
code: theorem mkContinuousMultilinear_norm_le' (f : MultilinearMap 𝕜 E (MultilinearMap 𝕜 E' G)) (C : ℝ)
    (H : ∀ m₁ m₂, ‖f m₁ m₂‖ ≤ (C * ∏ i, ‖m₁ i‖) * ∏ i, ‖m₂ i‖) :
    ‖mkContinuousMultilinear f C H‖ ≤ max C 0 
goal: ‖f.mkContinuousMultilinear C H‖ ≤ max C 0

full_name: MultilinearMap.mkContinuousMultilinear_norm_le
code: theorem mkContinuousMultilinear_norm_le (f : MultilinearMap 𝕜 E (MultilinearMap 𝕜 E' G)) {C : ℝ}
    (hC : 0 ≤ C) (H : ∀ m₁ m₂, ‖f m₁ m₂‖ ≤ (C * ∏ i, ‖m₁ i‖) * ∏ i, ‖m₂ i‖) :
    ‖mkContinuousMultilinear f C H‖ ≤ C 
goal: ‖f.mkContinuousMultilinear C H‖ ≤ C

full_name: ContinuousMultilinearMap.norm_compContinuousLinearMap_le
code: theorem norm_compContinuousLinearMap_le (g : ContinuousMultilinearMap 𝕜 E₁ G)
    (f : ∀ i, E i →L[𝕜] E₁ i) : ‖g.compContinuousLinearMap f‖ ≤ ‖g‖ * ∏ i, ‖f i‖ 
goal: ‖g.compContinuousLinearMap f‖ ≤ ‖g‖ * ∏ i : ι, ‖f i‖

full_name: ContinuousMultilinearMap.norm_compContinuous_linearIsometry_le
code: theorem norm_compContinuous_linearIsometry_le (g : ContinuousMultilinearMap 𝕜 E₁ G)
    (f : ∀ i, E i →ₗᵢ[𝕜] E₁ i) :
    ‖g.compContinuousLinearMap fun i => (f i).toContinuousLinearMap‖ ≤ ‖g‖ 
goal: ‖g.compContinuousLinearMap fun i => (f i).toContinuousLinearMap‖ ≤ ‖g‖

full_name: ContinuousMultilinearMap.norm_compContinuous_linearIsometryEquiv
code: theorem norm_compContinuous_linearIsometryEquiv (g : ContinuousMultilinearMap 𝕜 E₁ G)
    (f : ∀ i, E i ≃ₗᵢ[𝕜] E₁ i) :
    ‖g.compContinuousLinearMap fun i => (f i : E i →L[𝕜] E₁ i)‖ = ‖g‖ 
goal: ‖g.compContinuousLinearMap fun i =>
      ↑{ toLinearEquiv := (f i).toLinearEquiv, continuous_toFun := ⋯, continuous_invFun := ⋯ }‖ =
  ‖g‖

full_name: ContinuousMultilinearMap.compContinuousLinearMapL
code: /-- `ContinuousMultilinearMap.compContinuousLinearMap` as a bundled continuous linear map.
This implementation fixes `f : Π i, E i →L[𝕜] E₁ i`.

Actually, the map is multilinear in `f`,
see `ContinuousMultilinearMap.compContinuousLinearMapContinuousMultilinear`.

For a version fixing `g` and varying `f`, see `compContinuousLinearMapLRight`. -/
def compContinuousLinearMapL (f : ∀ i, E i →L[𝕜] E₁ i) :
    ContinuousMultilinearMap 𝕜 E₁ G →L[𝕜] ContinuousMultilinearMap 𝕜 E G 
goal: ContinuousMultilinearMap 𝕜 E₁ G →L[𝕜] ContinuousMultilinearMap 𝕜 E G

full_name: ContinuousMultilinearMap.compContinuousLinearMapL_apply
code: @[simp]
theorem compContinuousLinearMapL_apply (g : ContinuousMultilinearMap 𝕜 E₁ G)
    (f : ∀ i, E i →L[𝕜] E₁ i) : compContinuousLinearMapL f g = g.compContinuousLinearMap f 
goal: (ContinuousMultilinearMap.compContinuousLinearMapL f) g = g.compContinuousLinearMap f

full_name: ContinuousMultilinearMap.norm_compContinuousLinearMapL_le
code: theorem norm_compContinuousLinearMapL_le (f : ∀ i, E i →L[𝕜] E₁ i) :
    ‖compContinuousLinearMapL (G := G) f‖ ≤ ∏ i, ‖f i‖ 
goal: ‖ContinuousMultilinearMap.compContinuousLinearMapL f‖ ≤ ∏ i : ι, ‖f i‖

full_name: ContinuousMultilinearMap.compContinuousLinearMapLRight
code: /-- `ContinuousMultilinearMap.compContinuousLinearMap` as a bundled continuous linear map.
This implementation fixes `g : ContinuousMultilinearMap 𝕜 E₁ G`.

Actually, the map is linear in `g`,
see `ContinuousMultilinearMap.compContinuousLinearMapContinuousMultilinear`.

For a version fixing `f` and varying `g`, see `compContinuousLinearMapL`. -/
def compContinuousLinearMapLRight (g : ContinuousMultilinearMap 𝕜 E₁ G) :
    ContinuousMultilinearMap 𝕜 (fun i ↦ E i →L[𝕜] E₁ i) (ContinuousMultilinearMap 𝕜 E G) 
goal: ContinuousMultilinearMap 𝕜 (fun i => E i →L[𝕜] E₁ i) (ContinuousMultilinearMap 𝕜 E G)

full_name: ContinuousMultilinearMap.compContinuousLinearMapLRight_apply
code: @[simp]
theorem compContinuousLinearMapLRight_apply (g : ContinuousMultilinearMap 𝕜 E₁ G)
    (f : ∀ i, E i →L[𝕜] E₁ i) : compContinuousLinearMapLRight g f = g.compContinuousLinearMap f 
goal: g.compContinuousLinearMapLRight f = g.compContinuousLinearMap f

full_name: ContinuousMultilinearMap.norm_compContinuousLinearMapLRight_le
code: theorem norm_compContinuousLinearMapLRight_le (g : ContinuousMultilinearMap 𝕜 E₁ G) :
    ‖compContinuousLinearMapLRight (E := E) g‖ ≤ ‖g‖ 
goal: ‖g.compContinuousLinearMapLRight‖ ≤ ‖g‖

full_name: ContinuousMultilinearMap.compContinuousLinearMapMultilinear
code: /-- If `f` is a collection of continuous linear maps, then the construction
`ContinuousMultilinearMap.compContinuousLinearMap`
sending a continuous multilinear map `g` to `g (f₁ ·, ..., fₙ ·)`
is continuous-linear in `g` and multilinear in `f₁, ..., fₙ`. -/
noncomputable def compContinuousLinearMapMultilinear :
    MultilinearMap 𝕜 (fun i ↦ E i →L[𝕜] E₁ i)
      ((ContinuousMultilinearMap 𝕜 E₁ G) →L[𝕜] ContinuousMultilinearMap 𝕜 E G) 
goal: MultilinearMap 𝕜 (fun i => E i →L[𝕜] E₁ i) (ContinuousMultilinearMap 𝕜 E₁ G →L[𝕜] ContinuousMultilinearMap 𝕜 E G)

full_name: ContinuousMultilinearMap.compContinuousLinearMapContinuousMultilinear
code: /-- If `f` is a collection of continuous linear maps, then the construction
`ContinuousMultilinearMap.compContinuousLinearMap`
sending a continuous multilinear map `g` to `g (f₁ ·, ..., fₙ ·)` is continuous-linear in `g` and
continuous-multilinear in `f₁, ..., fₙ`. -/
noncomputable def compContinuousLinearMapContinuousMultilinear :
    ContinuousMultilinearMap 𝕜 (fun i ↦ E i →L[𝕜] E₁ i)
      ((ContinuousMultilinearMap 𝕜 E₁ G) →L[𝕜] ContinuousMultilinearMap 𝕜 E G) 
goal: ContinuousMultilinearMap 𝕜 (fun i => E i →L[𝕜] E₁ i)
  (ContinuousMultilinearMap 𝕜 E₁ G →L[𝕜] ContinuousMultilinearMap 𝕜 E G)

full_name: ContinuousMultilinearMap.compContinuousLinearMapEquivL
code: /-- `ContinuousMultilinearMap.compContinuousLinearMap` as a bundled continuous linear equiv,
given `f : Π i, E i ≃L[𝕜] E₁ i`. -/
def compContinuousLinearMapEquivL (f : ∀ i, E i ≃L[𝕜] E₁ i) :
    ContinuousMultilinearMap 𝕜 E₁ G ≃L[𝕜] ContinuousMultilinearMap 𝕜 E G 
goal: ContinuousMultilinearMap 𝕜 E₁ G ≃L[𝕜] ContinuousMultilinearMap 𝕜 E G

full_name: ContinuousMultilinearMap.compContinuousLinearMapEquivL_symm
code: @[simp]
theorem compContinuousLinearMapEquivL_symm (f : ∀ i, E i ≃L[𝕜] E₁ i) :
    (compContinuousLinearMapEquivL G f).symm =
      compContinuousLinearMapEquivL G fun i : ι => (f i).symm 
goal: (ContinuousMultilinearMap.compContinuousLinearMapEquivL G f).symm =
  ContinuousMultilinearMap.compContinuousLinearMapEquivL G fun i => (f i).symm

full_name: ContinuousMultilinearMap.compContinuousLinearMapEquivL_apply
code: @[simp]
theorem compContinuousLinearMapEquivL_apply (g : ContinuousMultilinearMap 𝕜 E₁ G)
    (f : ∀ i, E i ≃L[𝕜] E₁ i) :
    compContinuousLinearMapEquivL G f g =
      g.compContinuousLinearMap fun i => (f i : E i →L[𝕜] E₁ i) 
goal: (ContinuousMultilinearMap.compContinuousLinearMapEquivL G f) g = g.compContinuousLinearMap fun i => ↑(f i)

full_name: ContinuousMultilinearMap.iteratedFDerivComponent
code: /-- One of the components of the iterated derivative of a continuous multilinear map. Given a
bijection `e` between a type `α` (typically `Fin k`) and a subset `s` of `ι`, this component is a
continuous multilinear map of `k` vectors `v₁, ..., vₖ`, mapping them
to `f (x₁, (v_{e.symm 2})₂, x₃, ...)`, where at indices `i` in `s` one uses the `i`-th coordinate of
the vector `v_{e.symm i}` and otherwise one uses the `i`-th coordinate of a reference vector `x`.
This is continuous multilinear in the components of `x` outside of `s`, and in the `v_j`. -/
noncomputable def iteratedFDerivComponent {α : Type*} [Fintype α]
    (f : ContinuousMultilinearMap 𝕜 E₁ G) {s : Set ι} (e : α ≃ s) [DecidablePred (· ∈ s)] :
    ContinuousMultilinearMap 𝕜 (fun (i : {a : ι // a ∉ s}) ↦ E₁ i)
      (ContinuousMultilinearMap 𝕜 (fun (_ : α) ↦ (∀ i, E₁ i)) G) 
goal: ContinuousMultilinearMap 𝕜 (fun i => E₁ ↑i) (ContinuousMultilinearMap 𝕜 (fun x => (i : ι) → E₁ i) G)

full_name: ContinuousMultilinearMap.iteratedFDerivComponent_apply
code: @[simp] lemma iteratedFDerivComponent_apply {α : Type*} [Fintype α]
    (f : ContinuousMultilinearMap 𝕜 E₁ G) {s : Set ι} (e : α ≃ s) [DecidablePred (· ∈ s)]
    (v : ∀ i : {a : ι // a ∉ s}, E₁ i) (w : α → (∀ i, E₁ i)) :
    f.iteratedFDerivComponent e v w =
      f (fun j ↦ if h : j ∈ s then w (e.symm ⟨j, h⟩) j else v ⟨j, h⟩) 
goal: ((f.iteratedFDerivComponent e) v) w = f fun j => if h : j ∈ s then w (e.symm ⟨j, h⟩) j else v ⟨j, h⟩

full_name: ContinuousMultilinearMap.norm_iteratedFDerivComponent_le
code: lemma norm_iteratedFDerivComponent_le {α : Type*} [Fintype α]
    (f : ContinuousMultilinearMap 𝕜 E₁ G) {s : Set ι} (e : α ≃ s) [DecidablePred (· ∈ s)]
    (x : (i : ι) → E₁ i) :
    ‖f.iteratedFDerivComponent e (x ·)‖ ≤ ‖f‖ * ‖x‖ ^ (Fintype.card ι - Fintype.card α) 
goal: ‖(f.iteratedFDerivComponent e) fun x_1 => x ↑x_1‖ ≤ ‖f‖ * ‖x‖ ^ (Fintype.card ι - Fintype.card α)

full_name: ContinuousMultilinearMap.iteratedFDeriv
code: /-- The `k`-th iterated derivative of a continuous multilinear map `f` at the point `x`. It is a
continuous multilinear map of `k` vectors `v₁, ..., vₖ` (with the same type as `x`), mapping them
to `∑ f (x₁, (v_{i₁})₂, x₃, ...)`, where at each index `j` one uses either `xⱼ` or one
of the `(vᵢ)ⱼ`, and each `vᵢ` has to be used exactly once.
The sum is parameterized by the embeddings of `Fin k` in the index type `ι` (or, equivalently,
by the subsets `s` of `ι` of cardinality `k` and then the bijections between `Fin k` and `s`).

The fact that this is indeed the iterated Fréchet derivative is proved in
`ContinuousMultilinearMap.iteratedFDeriv_eq`.
-/
protected def iteratedFDeriv (f : ContinuousMultilinearMap 𝕜 E₁ G) (k : ℕ) (x : (i : ι) → E₁ i) :
    ContinuousMultilinearMap 𝕜 (fun (_ : Fin k) ↦ (∀ i, E₁ i)) G 
goal: ContinuousMultilinearMap 𝕜 (fun x => (i : ι) → E₁ i) G

full_name: ContinuousMultilinearMap.norm_iteratedFDeriv_le'
code: /-- Controlling the norm of `f.iteratedFDeriv` when `f` is continuous multilinear. For the same
bound on the iterated derivative of `f` in the calculus sense,
see `ContinuousMultilinearMap.norm_iteratedFDeriv_le`. -/
lemma norm_iteratedFDeriv_le' (f : ContinuousMultilinearMap 𝕜 E₁ G) (k : ℕ) (x : (i : ι) → E₁ i) :
    ‖f.iteratedFDeriv k x‖
      ≤ Nat.descFactorial (Fintype.card ι) k * ‖f‖ * ‖x‖ ^ (Fintype.card ι - k) 
goal: ‖f.iteratedFDeriv k x‖ ≤ ↑((Fintype.card ι).descFactorial k) * ‖f‖ * ‖x‖ ^ (Fintype.card ι - k)

full_name: ContinuousMultilinearMap.opNorm_zero_iff
code: /-- A continuous linear map is zero iff its norm vanishes. -/
theorem opNorm_zero_iff : ‖f‖ = 0 ↔ f = 0 
goal: ‖f‖ = 0 ↔ f = 0

full_name: ContinuousMultilinearMap.normedAddCommGroup
code: /-- Continuous multilinear maps themselves form a normed group with respect to
    the operator norm. -/
instance normedAddCommGroup : NormedAddCommGroup (ContinuousMultilinearMap 𝕜 E G) 
goal: NormedAddCommGroup (ContinuousMultilinearMap 𝕜 E G)

full_name: ContinuousMultilinearMap.normedAddCommGroup'
code: /-- An alias of `ContinuousMultilinearMap.normedAddCommGroup` with non-dependent types to help
typeclass search. -/
instance normedAddCommGroup' :
    NormedAddCommGroup (ContinuousMultilinearMap 𝕜 (fun _ : ι => G') G) 
goal: NormedAddCommGroup (ContinuousMultilinearMap 𝕜 (fun x => G') G)

full_name: ContinuousMultilinearMap.norm_ofSubsingleton_id
code: theorem norm_ofSubsingleton_id [Subsingleton ι] [Nontrivial G] (i : ι) :
    ‖ofSubsingleton 𝕜 G G i (.id _ _)‖ = 1 
goal: ‖(ContinuousMultilinearMap.ofSubsingleton 𝕜 G G i) (ContinuousLinearMap.id 𝕜 G)‖ = 1

full_name: ContinuousMultilinearMap.nnnorm_ofSubsingleton_id
code: theorem nnnorm_ofSubsingleton_id [Subsingleton ι] [Nontrivial G] (i : ι) :
    ‖ofSubsingleton 𝕜 G G i (.id _ _)‖₊ = 1 
goal: ‖(ContinuousMultilinearMap.ofSubsingleton 𝕜 G G i) (ContinuousLinearMap.id 𝕜 G)‖₊ = 1

full_name: MultilinearMap.bound_of_shell
code: /-- If a multilinear map in finitely many variables on normed spaces satisfies the inequality
`‖f m‖ ≤ C * ∏ i, ‖m i‖` on a shell `ε i / ‖c i‖ < ‖m i‖ < ε i` for some positive numbers `ε i`
and elements `c i : 𝕜`, `1 < ‖c i‖`, then it satisfies this inequality for all `m`. -/
theorem bound_of_shell {ε : ι → ℝ} {C : ℝ} (hε : ∀ i, 0 < ε i) {c : ι → 𝕜} (hc : ∀ i, 1 < ‖c i‖)
    (hf : ∀ m : ∀ i, E i, (∀ i, ε i / ‖c i‖ ≤ ‖m i‖) → (∀ i, ‖m i‖ < ε i) → ‖f m‖ ≤ C * ∏ i, ‖m i‖)
    (m : ∀ i, E i) : ‖f m‖ ≤ C * ∏ i, ‖m i‖ 
goal: ‖f m‖ ≤ C * ∏ i : ι, ‖m i‖