Context stringlengths 57 6.04k | file_name stringlengths 21 79 | start int64 14 1.49k | end int64 18 1.5k | theorem stringlengths 25 1.55k | proof stringlengths 5 7.36k | rank int64 0 2.4k |
|---|---|---|---|---|---|---|
import Mathlib.Analysis.NormedSpace.OperatorNorm.Basic
suppress_compilation
open Bornology
open Filter hiding map_smul
open scoped Classical NNReal Topology Uniformity
-- the `β` subscript variables are for special cases about linear (as opposed to semilinear) maps
variable {π πβ πβ E Eβ F Fβ G Gβ π : Type*}
section SemiNormed
open Metric ContinuousLinearMap
variable [SeminormedAddCommGroup E] [SeminormedAddCommGroup Eβ] [SeminormedAddCommGroup F]
[SeminormedAddCommGroup Fβ] [SeminormedAddCommGroup G] [SeminormedAddCommGroup Gβ]
variable [NontriviallyNormedField π] [NontriviallyNormedField πβ] [NontriviallyNormedField πβ]
[NormedSpace π E] [NormedSpace π Eβ] [NormedSpace πβ F] [NormedSpace π Fβ] [NormedSpace πβ G]
[NormedSpace π Gβ] {Οββ : π β+* πβ} {Οββ : πβ β+* πβ} {Οββ : π β+* πβ}
[RingHomCompTriple Οββ Οββ Οββ]
variable [FunLike π E F]
namespace ContinuousLinearMap
section OpNorm
open Set Real
section
variable [RingHomIsometric Οββ] [RingHomIsometric Οββ] (f g : E βSL[Οββ] F) (h : F βSL[Οββ] G)
(x : E)
| Mathlib/Analysis/NormedSpace/OperatorNorm/NNNorm.lean | 49 | 53 | theorem nnnorm_def (f : E βSL[Οββ] F) : βfββ = sInf { c | β x, βf xββ β€ c * βxββ } := by |
ext
rw [NNReal.coe_sInf, coe_nnnorm, norm_def, NNReal.coe_image]
simp_rw [β NNReal.coe_le_coe, NNReal.coe_mul, coe_nnnorm, mem_setOf_eq, NNReal.coe_mk,
exists_prop]
| 1,590 |
import Mathlib.Analysis.NormedSpace.OperatorNorm.Basic
suppress_compilation
open Bornology
open Filter hiding map_smul
open scoped Classical NNReal Topology Uniformity
-- the `β` subscript variables are for special cases about linear (as opposed to semilinear) maps
variable {π πβ πβ E Eβ F Fβ G Gβ π : Type*}
section SemiNormed
open Metric ContinuousLinearMap
variable [SeminormedAddCommGroup E] [SeminormedAddCommGroup Eβ] [SeminormedAddCommGroup F]
[SeminormedAddCommGroup Fβ] [SeminormedAddCommGroup G] [SeminormedAddCommGroup Gβ]
variable [NontriviallyNormedField π] [NontriviallyNormedField πβ] [NontriviallyNormedField πβ]
[NormedSpace π E] [NormedSpace π Eβ] [NormedSpace πβ F] [NormedSpace π Fβ] [NormedSpace πβ G]
[NormedSpace π Gβ] {Οββ : π β+* πβ} {Οββ : πβ β+* πβ} {Οββ : π β+* πβ}
[RingHomCompTriple Οββ Οββ Οββ]
variable [FunLike π E F]
namespace ContinuousLinearMap
section OpNorm
open Set Real
section
variable [RingHomIsometric Οββ] [RingHomIsometric Οββ] (f g : E βSL[Οββ] F) (h : F βSL[Οββ] G)
(x : E)
theorem nnnorm_def (f : E βSL[Οββ] F) : βfββ = sInf { c | β x, βf xββ β€ c * βxββ } := by
ext
rw [NNReal.coe_sInf, coe_nnnorm, norm_def, NNReal.coe_image]
simp_rw [β NNReal.coe_le_coe, NNReal.coe_mul, coe_nnnorm, mem_setOf_eq, NNReal.coe_mk,
exists_prop]
#align continuous_linear_map.nnnorm_def ContinuousLinearMap.nnnorm_def
theorem opNNNorm_le_bound (f : E βSL[Οββ] F) (M : ββ₯0) (hM : β x, βf xββ β€ M * βxββ) : βfββ β€ M :=
opNorm_le_bound f (zero_le M) hM
#align continuous_linear_map.op_nnnorm_le_bound ContinuousLinearMap.opNNNorm_le_bound
@[deprecated (since := "2024-02-02")] alias op_nnnorm_le_bound := opNNNorm_le_bound
theorem opNNNorm_le_bound' (f : E βSL[Οββ] F) (M : ββ₯0) (hM : β x, βxββ β 0 β βf xββ β€ M * βxββ) :
βfββ β€ M :=
opNorm_le_bound' f (zero_le M) fun x hx => hM x <| by rwa [β NNReal.coe_ne_zero]
#align continuous_linear_map.op_nnnorm_le_bound' ContinuousLinearMap.opNNNorm_le_bound'
@[deprecated (since := "2024-02-02")] alias op_nnnorm_le_bound' := opNNNorm_le_bound'
theorem opNNNorm_le_of_unit_nnnorm [NormedSpace β E] [NormedSpace β F] {f : E βL[β] F} {C : ββ₯0}
(hf : β x, βxββ = 1 β βf xββ β€ C) : βfββ β€ C :=
opNorm_le_of_unit_norm C.coe_nonneg fun x hx => hf x <| by rwa [β NNReal.coe_eq_one]
#align continuous_linear_map.op_nnnorm_le_of_unit_nnnorm ContinuousLinearMap.opNNNorm_le_of_unit_nnnorm
@[deprecated (since := "2024-02-02")]
alias op_nnnorm_le_of_unit_nnnorm := opNNNorm_le_of_unit_nnnorm
theorem opNNNorm_le_of_lipschitz {f : E βSL[Οββ] F} {K : ββ₯0} (hf : LipschitzWith K f) :
βfββ β€ K :=
opNorm_le_of_lipschitz hf
#align continuous_linear_map.op_nnnorm_le_of_lipschitz ContinuousLinearMap.opNNNorm_le_of_lipschitz
@[deprecated (since := "2024-02-02")] alias op_nnnorm_le_of_lipschitz := opNNNorm_le_of_lipschitz
theorem opNNNorm_eq_of_bounds {Ο : E βSL[Οββ] F} (M : ββ₯0) (h_above : β x, βΟ xββ β€ M * βxββ)
(h_below : β N, (β x, βΟ xββ β€ N * βxββ) β M β€ N) : βΟββ = M :=
Subtype.ext <| opNorm_eq_of_bounds (zero_le M) h_above <| Subtype.forall'.mpr h_below
#align continuous_linear_map.op_nnnorm_eq_of_bounds ContinuousLinearMap.opNNNorm_eq_of_bounds
@[deprecated (since := "2024-02-02")] alias op_nnnorm_eq_of_bounds := opNNNorm_eq_of_bounds
theorem opNNNorm_le_iff {f : E βSL[Οββ] F} {C : ββ₯0} : βfββ β€ C β β x, βf xββ β€ C * βxββ :=
opNorm_le_iff C.2
@[deprecated (since := "2024-02-02")] alias op_nnnorm_le_iff := opNNNorm_le_iff
| Mathlib/Analysis/NormedSpace/OperatorNorm/NNNorm.lean | 100 | 101 | theorem isLeast_opNNNorm : IsLeast {C : ββ₯0 | β x, βf xββ β€ C * βxββ} βfββ := by |
simpa only [β opNNNorm_le_iff] using isLeast_Ici
| 1,590 |
import Mathlib.Analysis.NormedSpace.OperatorNorm.Bilinear
import Mathlib.Analysis.NormedSpace.OperatorNorm.NNNorm
suppress_compilation
open Bornology Metric Set Real
open Filter hiding map_smul
open scoped Classical NNReal Topology Uniformity
-- the `β` subscript variables are for special cases about linear (as opposed to semilinear) maps
variable {π πβ πβ E Eβ F Fβ G Gβ π : Type*}
variable [NormedAddCommGroup E] [NormedAddCommGroup F] [NormedAddCommGroup G]
[NormedAddCommGroup Fβ]
variable [NontriviallyNormedField π] [NontriviallyNormedField πβ] [NontriviallyNormedField πβ]
[NormedSpace π E] [NormedSpace πβ F] [NormedSpace πβ G] [NormedSpace π Fβ] (c : π)
{Οββ : π β+* πβ} {Οββ : πβ β+* πβ} (f g : E βSL[Οββ] F) (x y z : E)
namespace ContinuousLinearMap
section Completeness
variable {E' : Type*} [SeminormedAddCommGroup E'] [NormedSpace π E'] [RingHomIsometric Οββ]
@[simps! (config := .asFn) apply]
def ofMemClosureImageCoeBounded (f : E' β F) {s : Set (E' βSL[Οββ] F)} (hs : IsBounded s)
(hf : f β closure (((β) : (E' βSL[Οββ] F) β E' β F) '' s)) : E' βSL[Οββ] F := by
-- `f` is a linear map due to `linearMapOfMemClosureRangeCoe`
refine (linearMapOfMemClosureRangeCoe f ?_).mkContinuousOfExistsBound ?_
Β· refine closure_mono (image_subset_iff.2 fun g _ => ?_) hf
exact β¨g, rflβ©
Β· -- We need to show that `f` has bounded norm. Choose `C` such that `βgβ β€ C` for all `g β s`.
rcases isBounded_iff_forall_norm_le.1 hs with β¨C, hCβ©
-- Then `βg xβ β€ C * βxβ` for all `g β s`, `x : E`, hence `βf xβ β€ C * βxβ` for all `x`.
have : β x, IsClosed { g : E' β F | βg xβ β€ C * βxβ } := fun x =>
isClosed_Iic.preimage (@continuous_apply E' (fun _ => F) _ x).norm
refine β¨C, fun x => (this x).closure_subset_iff.2 (image_subset_iff.2 fun g hg => ?_) hfβ©
exact g.le_of_opNorm_le (hC _ hg) _
#align continuous_linear_map.of_mem_closure_image_coe_bounded ContinuousLinearMap.ofMemClosureImageCoeBounded
@[simps! (config := .asFn) apply]
def ofTendstoOfBoundedRange {Ξ± : Type*} {l : Filter Ξ±} [l.NeBot] (f : E' β F)
(g : Ξ± β E' βSL[Οββ] F) (hf : Tendsto (fun a x => g a x) l (π f))
(hg : IsBounded (Set.range g)) : E' βSL[Οββ] F :=
ofMemClosureImageCoeBounded f hg <| mem_closure_of_tendsto hf <|
eventually_of_forall fun _ => mem_image_of_mem _ <| Set.mem_range_self _
#align continuous_linear_map.of_tendsto_of_bounded_range ContinuousLinearMap.ofTendstoOfBoundedRange
| Mathlib/Analysis/NormedSpace/OperatorNorm/Completeness.lean | 70 | 86 | theorem tendsto_of_tendsto_pointwise_of_cauchySeq {f : β β E' βSL[Οββ] F} {g : E' βSL[Οββ] F}
(hg : Tendsto (fun n x => f n x) atTop (π g)) (hf : CauchySeq f) : Tendsto f atTop (π g) := by |
/- Since `f` is a Cauchy sequence, there exists `b β 0` such that `βf n - f mβ β€ b N` for any
`m, n β₯ N`. -/
rcases cauchySeq_iff_le_tendsto_0.1 hf with β¨b, hbβ, hfb, hb_limβ©
-- Since `b β 0`, it suffices to show that `βf n x - g xβ β€ b n * βxβ` for all `n` and `x`.
suffices β n x, βf n x - g xβ β€ b n * βxβ from
tendsto_iff_norm_sub_tendsto_zero.2
(squeeze_zero (fun n => norm_nonneg _) (fun n => opNorm_le_bound _ (hbβ n) (this n)) hb_lim)
intro n x
-- Note that `f m x β g x`, hence `βf n x - f m xβ β βf n x - g xβ` as `m β β`
have : Tendsto (fun m => βf n x - f m xβ) atTop (π βf n x - g xβ) :=
(tendsto_const_nhds.sub <| tendsto_pi_nhds.1 hg _).norm
-- Thus it suffices to verify `βf n x - f m xβ β€ b n * βxβ` for `m β₯ n`.
refine le_of_tendsto this (eventually_atTop.2 β¨n, fun m hm => ?_β©)
-- This inequality follows from `βf n - f mβ β€ b n`.
exact (f n - f m).le_of_opNorm_le (hfb _ _ _ le_rfl hm) _
| 1,591 |
import Mathlib.Analysis.NormedSpace.OperatorNorm.Bilinear
import Mathlib.Analysis.NormedSpace.OperatorNorm.NNNorm
suppress_compilation
open Bornology Metric Set Real
open Filter hiding map_smul
open scoped Classical NNReal Topology Uniformity
-- the `β` subscript variables are for special cases about linear (as opposed to semilinear) maps
variable {π πβ πβ E Eβ F Fβ G Gβ π : Type*}
variable [NormedAddCommGroup E] [NormedAddCommGroup F] [NormedAddCommGroup G]
[NormedAddCommGroup Fβ]
variable [NontriviallyNormedField π] [NontriviallyNormedField πβ] [NontriviallyNormedField πβ]
[NormedSpace π E] [NormedSpace πβ F] [NormedSpace πβ G] [NormedSpace π Fβ] (c : π)
{Οββ : π β+* πβ} {Οββ : πβ β+* πβ} (f g : E βSL[Οββ] F) (x y z : E)
namespace ContinuousLinearMap
section UniformlyExtend
variable [CompleteSpace F] (e : E βL[π] Fβ) (h_dense : DenseRange e)
section
variable (h_e : UniformInducing e)
def extend : Fβ βSL[Οββ] F :=
-- extension of `f` is continuous
have cont := (uniformContinuous_uniformly_extend h_e h_dense f.uniformContinuous).continuous
-- extension of `f` agrees with `f` on the domain of the embedding `e`
have eq := uniformly_extend_of_ind h_e h_dense f.uniformContinuous
{ toFun := (h_e.denseInducing h_dense).extend f
map_add' := by
refine h_dense.induction_onβ ?_ ?_
Β· exact isClosed_eq (cont.comp continuous_add)
((cont.comp continuous_fst).add (cont.comp continuous_snd))
Β· intro x y
simp only [eq, β e.map_add]
exact f.map_add _ _
map_smul' := fun k => by
refine fun b => h_dense.induction_on b ?_ ?_
Β· exact isClosed_eq (cont.comp (continuous_const_smul _))
((continuous_const_smul _).comp cont)
Β· intro x
rw [β map_smul]
simp only [eq]
exact ContinuousLinearMap.map_smulββ _ _ _
cont }
#align continuous_linear_map.extend ContinuousLinearMap.extend
-- Porting note: previously `(h_e.denseInducing h_dense)` was inferred.
@[simp]
theorem extend_eq (x : E) : extend f e h_dense h_e (e x) = f x :=
DenseInducing.extend_eq (h_e.denseInducing h_dense) f.cont _
#align continuous_linear_map.extend_eq ContinuousLinearMap.extend_eq
theorem extend_unique (g : Fβ βSL[Οββ] F) (H : g.comp e = f) : extend f e h_dense h_e = g :=
ContinuousLinearMap.coeFn_injective <|
uniformly_extend_unique h_e h_dense (ContinuousLinearMap.ext_iff.1 H) g.continuous
#align continuous_linear_map.extend_unique ContinuousLinearMap.extend_unique
@[simp]
theorem extend_zero : extend (0 : E βSL[Οββ] F) e h_dense h_e = 0 :=
extend_unique _ _ _ _ _ (zero_comp _)
#align continuous_linear_map.extend_zero ContinuousLinearMap.extend_zero
end
section
variable {N : ββ₯0} (h_e : β x, βxβ β€ N * βe xβ) [RingHomIsometric Οββ]
| Mathlib/Analysis/NormedSpace/OperatorNorm/Completeness.lean | 246 | 263 | theorem opNorm_extend_le :
βf.extend e h_dense (uniformEmbedding_of_bound _ h_e).toUniformInducingβ β€ N * βfβ := by |
-- Add `opNorm_le_of_dense`?
refine opNorm_le_bound _ ?_ (isClosed_property h_dense (isClosed_le ?_ ?_) fun x β¦ ?_)
Β· cases le_total 0 N with
| inl hN => exact mul_nonneg hN (norm_nonneg _)
| inr hN =>
have : Unique E := β¨β¨0β©, fun x β¦ norm_le_zero_iff.mp <|
(h_e x).trans (mul_nonpos_of_nonpos_of_nonneg hN (norm_nonneg _))β©
obtain rfl : f = 0 := Subsingleton.elim ..
simp
Β· exact (cont _).norm
Β· exact continuous_const.mul continuous_norm
Β· rw [extend_eq]
calc
βf xβ β€ βfβ * βxβ := le_opNorm _ _
_ β€ βfβ * (N * βe xβ) := mul_le_mul_of_nonneg_left (h_e x) (norm_nonneg _)
_ β€ N * βfβ * βe xβ := by rw [mul_comm βN βfβ, mul_assoc]
| 1,591 |
import Mathlib.Analysis.NormedSpace.Basic
import Mathlib.Analysis.NormedSpace.LinearIsometry
#align_import analysis.normed_space.conformal_linear_map from "leanprover-community/mathlib"@"d1bd9c5df2867c1cb463bc6364446d57bdd9f7f1"
noncomputable section
open Function LinearIsometry ContinuousLinearMap
def IsConformalMap {R : Type*} {X Y : Type*} [NormedField R] [SeminormedAddCommGroup X]
[SeminormedAddCommGroup Y] [NormedSpace R X] [NormedSpace R Y] (f' : X βL[R] Y) :=
β c β (0 : R), β li : X ββα΅’[R] Y, f' = c β’ li.toContinuousLinearMap
#align is_conformal_map IsConformalMap
variable {R M N G M' : Type*} [NormedField R] [SeminormedAddCommGroup M] [SeminormedAddCommGroup N]
[SeminormedAddCommGroup G] [NormedSpace R M] [NormedSpace R N] [NormedSpace R G]
[NormedAddCommGroup M'] [NormedSpace R M'] {f : M βL[R] N} {g : N βL[R] G} {c : R}
theorem isConformalMap_id : IsConformalMap (id R M) :=
β¨1, one_ne_zero, id, by simpβ©
#align is_conformal_map_id isConformalMap_id
| Mathlib/Analysis/NormedSpace/ConformalLinearMap.lean | 62 | 65 | theorem IsConformalMap.smul (hf : IsConformalMap f) {c : R} (hc : c β 0) :
IsConformalMap (c β’ f) := by |
rcases hf with β¨c', hc', li, rflβ©
exact β¨c * c', mul_ne_zero hc hc', li, smul_smul _ _ _β©
| 1,592 |
import Mathlib.Analysis.NormedSpace.Basic
import Mathlib.Analysis.NormedSpace.LinearIsometry
#align_import analysis.normed_space.conformal_linear_map from "leanprover-community/mathlib"@"d1bd9c5df2867c1cb463bc6364446d57bdd9f7f1"
noncomputable section
open Function LinearIsometry ContinuousLinearMap
def IsConformalMap {R : Type*} {X Y : Type*} [NormedField R] [SeminormedAddCommGroup X]
[SeminormedAddCommGroup Y] [NormedSpace R X] [NormedSpace R Y] (f' : X βL[R] Y) :=
β c β (0 : R), β li : X ββα΅’[R] Y, f' = c β’ li.toContinuousLinearMap
#align is_conformal_map IsConformalMap
variable {R M N G M' : Type*} [NormedField R] [SeminormedAddCommGroup M] [SeminormedAddCommGroup N]
[SeminormedAddCommGroup G] [NormedSpace R M] [NormedSpace R N] [NormedSpace R G]
[NormedAddCommGroup M'] [NormedSpace R M'] {f : M βL[R] N} {g : N βL[R] G} {c : R}
theorem isConformalMap_id : IsConformalMap (id R M) :=
β¨1, one_ne_zero, id, by simpβ©
#align is_conformal_map_id isConformalMap_id
theorem IsConformalMap.smul (hf : IsConformalMap f) {c : R} (hc : c β 0) :
IsConformalMap (c β’ f) := by
rcases hf with β¨c', hc', li, rflβ©
exact β¨c * c', mul_ne_zero hc hc', li, smul_smul _ _ _β©
#align is_conformal_map.smul IsConformalMap.smul
theorem isConformalMap_const_smul (hc : c β 0) : IsConformalMap (c β’ id R M) :=
isConformalMap_id.smul hc
#align is_conformal_map_const_smul isConformalMap_const_smul
protected theorem LinearIsometry.isConformalMap (f' : M ββα΅’[R] N) :
IsConformalMap f'.toContinuousLinearMap :=
β¨1, one_ne_zero, f', (one_smul _ _).symmβ©
#align linear_isometry.is_conformal_map LinearIsometry.isConformalMap
@[nontriviality]
theorem isConformalMap_of_subsingleton [Subsingleton M] (f' : M βL[R] N) : IsConformalMap f' :=
β¨1, one_ne_zero, β¨0, fun x => by simp [Subsingleton.elim x 0]β©, Subsingleton.elim _ _β©
#align is_conformal_map_of_subsingleton isConformalMap_of_subsingleton
namespace IsConformalMap
| Mathlib/Analysis/NormedSpace/ConformalLinearMap.lean | 84 | 89 | theorem comp (hg : IsConformalMap g) (hf : IsConformalMap f) : IsConformalMap (g.comp f) := by |
rcases hf with β¨cf, hcf, lif, rflβ©
rcases hg with β¨cg, hcg, lig, rflβ©
refine β¨cg * cf, mul_ne_zero hcg hcf, lig.comp lif, ?_β©
rw [smul_comp, comp_smul, mul_smul]
rfl
| 1,592 |
import Mathlib.Analysis.NormedSpace.Basic
import Mathlib.Analysis.NormedSpace.LinearIsometry
#align_import analysis.normed_space.conformal_linear_map from "leanprover-community/mathlib"@"d1bd9c5df2867c1cb463bc6364446d57bdd9f7f1"
noncomputable section
open Function LinearIsometry ContinuousLinearMap
def IsConformalMap {R : Type*} {X Y : Type*} [NormedField R] [SeminormedAddCommGroup X]
[SeminormedAddCommGroup Y] [NormedSpace R X] [NormedSpace R Y] (f' : X βL[R] Y) :=
β c β (0 : R), β li : X ββα΅’[R] Y, f' = c β’ li.toContinuousLinearMap
#align is_conformal_map IsConformalMap
variable {R M N G M' : Type*} [NormedField R] [SeminormedAddCommGroup M] [SeminormedAddCommGroup N]
[SeminormedAddCommGroup G] [NormedSpace R M] [NormedSpace R N] [NormedSpace R G]
[NormedAddCommGroup M'] [NormedSpace R M'] {f : M βL[R] N} {g : N βL[R] G} {c : R}
theorem isConformalMap_id : IsConformalMap (id R M) :=
β¨1, one_ne_zero, id, by simpβ©
#align is_conformal_map_id isConformalMap_id
theorem IsConformalMap.smul (hf : IsConformalMap f) {c : R} (hc : c β 0) :
IsConformalMap (c β’ f) := by
rcases hf with β¨c', hc', li, rflβ©
exact β¨c * c', mul_ne_zero hc hc', li, smul_smul _ _ _β©
#align is_conformal_map.smul IsConformalMap.smul
theorem isConformalMap_const_smul (hc : c β 0) : IsConformalMap (c β’ id R M) :=
isConformalMap_id.smul hc
#align is_conformal_map_const_smul isConformalMap_const_smul
protected theorem LinearIsometry.isConformalMap (f' : M ββα΅’[R] N) :
IsConformalMap f'.toContinuousLinearMap :=
β¨1, one_ne_zero, f', (one_smul _ _).symmβ©
#align linear_isometry.is_conformal_map LinearIsometry.isConformalMap
@[nontriviality]
theorem isConformalMap_of_subsingleton [Subsingleton M] (f' : M βL[R] N) : IsConformalMap f' :=
β¨1, one_ne_zero, β¨0, fun x => by simp [Subsingleton.elim x 0]β©, Subsingleton.elim _ _β©
#align is_conformal_map_of_subsingleton isConformalMap_of_subsingleton
namespace IsConformalMap
theorem comp (hg : IsConformalMap g) (hf : IsConformalMap f) : IsConformalMap (g.comp f) := by
rcases hf with β¨cf, hcf, lif, rflβ©
rcases hg with β¨cg, hcg, lig, rflβ©
refine β¨cg * cf, mul_ne_zero hcg hcf, lig.comp lif, ?_β©
rw [smul_comp, comp_smul, mul_smul]
rfl
#align is_conformal_map.comp IsConformalMap.comp
protected theorem injective {f : M' βL[R] N} (h : IsConformalMap f) : Function.Injective f := by
rcases h with β¨c, hc, li, rflβ©
exact (smul_right_injective _ hc).comp li.injective
#align is_conformal_map.injective IsConformalMap.injective
| Mathlib/Analysis/NormedSpace/ConformalLinearMap.lean | 97 | 100 | theorem ne_zero [Nontrivial M'] {f' : M' βL[R] N} (hf' : IsConformalMap f') : f' β 0 := by |
rintro rfl
rcases exists_ne (0 : M') with β¨a, haβ©
exact ha (hf'.injective rfl)
| 1,592 |
import Mathlib.Analysis.NormedSpace.LinearIsometry
import Mathlib.Analysis.NormedSpace.ContinuousLinearMap
import Mathlib.Analysis.NormedSpace.Basic
variable {π E : Type*}
namespace LinearMap
variable (π)
section Seminormed
variable [NormedDivisionRing π] [SeminormedAddCommGroup E] [Module π E] [BoundedSMul π E]
| Mathlib/Analysis/NormedSpace/Span.lean | 36 | 39 | theorem toSpanSingleton_homothety (x : E) (c : π) :
βLinearMap.toSpanSingleton π E x cβ = βxβ * βcβ := by |
rw [mul_comm]
exact norm_smul _ _
| 1,593 |
import Mathlib.Analysis.NormedSpace.OperatorNorm.Bilinear
import Mathlib.Analysis.NormedSpace.OperatorNorm.NNNorm
import Mathlib.Analysis.NormedSpace.Span
suppress_compilation
open Bornology
open Filter hiding map_smul
open scoped Classical NNReal Topology Uniformity
-- the `β` subscript variables are for special cases about linear (as opposed to semilinear) maps
variable {π πβ πβ E Eβ F Fβ G Gβ π : Type*}
section Normed
variable [NormedAddCommGroup E] [NormedAddCommGroup F] [NormedAddCommGroup G]
[NormedAddCommGroup Fβ]
open Metric ContinuousLinearMap
section
variable [NontriviallyNormedField π] [NontriviallyNormedField πβ] [NontriviallyNormedField πβ]
[NormedSpace π E] [NormedSpace πβ F] [NormedSpace πβ G] [NormedSpace π Fβ] (c : π)
{Οββ : π β+* πβ} {Οββ : πβ β+* πβ} (f g : E βSL[Οββ] F) (x y z : E)
namespace LinearMap
| Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean | 42 | 46 | theorem bound_of_shell [RingHomIsometric Οββ] (f : E βββ[Οββ] F) {Ξ΅ C : β} (Ξ΅_pos : 0 < Ξ΅) {c : π}
(hc : 1 < βcβ) (hf : β x, Ξ΅ / βcβ β€ βxβ β βxβ < Ξ΅ β βf xβ β€ C * βxβ) (x : E) :
βf xβ β€ C * βxβ := by |
by_cases hx : x = 0; Β· simp [hx]
exact SemilinearMapClass.bound_of_shell_semi_normed f Ξ΅_pos hc hf (norm_ne_zero_iff.2 hx)
| 1,594 |
import Mathlib.Analysis.NormedSpace.OperatorNorm.Bilinear
import Mathlib.Analysis.NormedSpace.OperatorNorm.NNNorm
import Mathlib.Analysis.NormedSpace.Span
suppress_compilation
open Bornology
open Filter hiding map_smul
open scoped Classical NNReal Topology Uniformity
-- the `β` subscript variables are for special cases about linear (as opposed to semilinear) maps
variable {π πβ πβ E Eβ F Fβ G Gβ π : Type*}
section Normed
variable [NormedAddCommGroup E] [NormedAddCommGroup F] [NormedAddCommGroup G]
[NormedAddCommGroup Fβ]
open Metric ContinuousLinearMap
section
variable [NontriviallyNormedField π] [NontriviallyNormedField πβ] [NontriviallyNormedField πβ]
[NormedSpace π E] [NormedSpace πβ F] [NormedSpace πβ G] [NormedSpace π Fβ] (c : π)
{Οββ : π β+* πβ} {Οββ : πβ β+* πβ} (f g : E βSL[Οββ] F) (x y z : E)
namespace LinearMap
theorem bound_of_shell [RingHomIsometric Οββ] (f : E βββ[Οββ] F) {Ξ΅ C : β} (Ξ΅_pos : 0 < Ξ΅) {c : π}
(hc : 1 < βcβ) (hf : β x, Ξ΅ / βcβ β€ βxβ β βxβ < Ξ΅ β βf xβ β€ C * βxβ) (x : E) :
βf xβ β€ C * βxβ := by
by_cases hx : x = 0; Β· simp [hx]
exact SemilinearMapClass.bound_of_shell_semi_normed f Ξ΅_pos hc hf (norm_ne_zero_iff.2 hx)
#align linear_map.bound_of_shell LinearMap.bound_of_shell
| Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean | 52 | 64 | theorem bound_of_ball_bound {r : β} (r_pos : 0 < r) (c : β) (f : E ββ[π] Fβ)
(h : β z β Metric.ball (0 : E) r, βf zβ β€ c) : β C, β z : E, βf zβ β€ C * βzβ := by |
cases' @NontriviallyNormedField.non_trivial π _ with k hk
use c * (βkβ / r)
intro z
refine bound_of_shell _ r_pos hk (fun x hko hxo => ?_) _
calc
βf xβ β€ c := h _ (mem_ball_zero_iff.mpr hxo)
_ β€ c * (βxβ * βkβ / r) := le_mul_of_one_le_right ?_ ?_
_ = _ := by ring
Β· exact le_trans (norm_nonneg _) (h 0 (by simp [r_pos]))
Β· rw [div_le_iff (zero_lt_one.trans hk)] at hko
exact (one_le_div r_pos).mpr hko
| 1,594 |
import Mathlib.Analysis.NormedSpace.OperatorNorm.Bilinear
import Mathlib.Analysis.NormedSpace.OperatorNorm.NNNorm
import Mathlib.Analysis.NormedSpace.Span
suppress_compilation
open Bornology
open Filter hiding map_smul
open scoped Classical NNReal Topology Uniformity
-- the `β` subscript variables are for special cases about linear (as opposed to semilinear) maps
variable {π πβ πβ E Eβ F Fβ G Gβ π : Type*}
section Normed
variable [NormedAddCommGroup E] [NormedAddCommGroup F] [NormedAddCommGroup G]
[NormedAddCommGroup Fβ]
open Metric ContinuousLinearMap
section
variable [NontriviallyNormedField π] [NontriviallyNormedField πβ] [NontriviallyNormedField πβ]
[NormedSpace π E] [NormedSpace πβ F] [NormedSpace πβ G] [NormedSpace π Fβ] (c : π)
{Οββ : π β+* πβ} {Οββ : πβ β+* πβ} (f g : E βSL[Οββ] F) (x y z : E)
namespace LinearMap
theorem bound_of_shell [RingHomIsometric Οββ] (f : E βββ[Οββ] F) {Ξ΅ C : β} (Ξ΅_pos : 0 < Ξ΅) {c : π}
(hc : 1 < βcβ) (hf : β x, Ξ΅ / βcβ β€ βxβ β βxβ < Ξ΅ β βf xβ β€ C * βxβ) (x : E) :
βf xβ β€ C * βxβ := by
by_cases hx : x = 0; Β· simp [hx]
exact SemilinearMapClass.bound_of_shell_semi_normed f Ξ΅_pos hc hf (norm_ne_zero_iff.2 hx)
#align linear_map.bound_of_shell LinearMap.bound_of_shell
theorem bound_of_ball_bound {r : β} (r_pos : 0 < r) (c : β) (f : E ββ[π] Fβ)
(h : β z β Metric.ball (0 : E) r, βf zβ β€ c) : β C, β z : E, βf zβ β€ C * βzβ := by
cases' @NontriviallyNormedField.non_trivial π _ with k hk
use c * (βkβ / r)
intro z
refine bound_of_shell _ r_pos hk (fun x hko hxo => ?_) _
calc
βf xβ β€ c := h _ (mem_ball_zero_iff.mpr hxo)
_ β€ c * (βxβ * βkβ / r) := le_mul_of_one_le_right ?_ ?_
_ = _ := by ring
Β· exact le_trans (norm_nonneg _) (h 0 (by simp [r_pos]))
Β· rw [div_le_iff (zero_lt_one.trans hk)] at hko
exact (one_le_div r_pos).mpr hko
#align linear_map.bound_of_ball_bound LinearMap.bound_of_ball_bound
| Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean | 67 | 87 | theorem antilipschitz_of_comap_nhds_le [h : RingHomIsometric Οββ] (f : E βββ[Οββ] F)
(hf : (π 0).comap f β€ π 0) : β K, AntilipschitzWith K f := by |
rcases ((nhds_basis_ball.comap _).le_basis_iff nhds_basis_ball).1 hf 1 one_pos with β¨Ξ΅, Ξ΅0, hΞ΅β©
simp only [Set.subset_def, Set.mem_preimage, mem_ball_zero_iff] at hΞ΅
lift Ξ΅ to ββ₯0 using Ξ΅0.le
rcases NormedField.exists_one_lt_norm π with β¨c, hcβ©
refine β¨Ξ΅β»ΒΉ * βcββ, AddMonoidHomClass.antilipschitz_of_bound f fun x => ?_β©
by_cases hx : f x = 0
Β· rw [β hx] at hf
obtain rfl : x = 0 := Specializes.eq (specializes_iff_pure.2 <|
((Filter.tendsto_pure_pure _ _).mono_right (pure_le_nhds _)).le_comap.trans hf)
exact norm_zero.trans_le (mul_nonneg (NNReal.coe_nonneg _) (norm_nonneg _))
have hcβ : c β 0 := norm_pos_iff.1 (one_pos.trans hc)
rw [β h.1] at hc
rcases rescale_to_shell_zpow hc Ξ΅0 hx with β¨n, -, hlt, -, hleβ©
simp only [β map_zpowβ, h.1, β map_smulββ] at hlt hle
calc
βxβ = βc ^ nββ»ΒΉ * βc ^ n β’ xβ := by
rwa [β norm_inv, β norm_smul, inv_smul_smulβ (zpow_ne_zero _ _)]
_ β€ βc ^ nββ»ΒΉ * 1 := (mul_le_mul_of_nonneg_left (hΞ΅ _ hlt).le (inv_nonneg.2 (norm_nonneg _)))
_ β€ Ξ΅β»ΒΉ * βcβ * βf xβ := by rwa [mul_one]
| 1,594 |
import Mathlib.Analysis.NormedSpace.OperatorNorm.Bilinear
import Mathlib.Analysis.NormedSpace.OperatorNorm.NNNorm
import Mathlib.Analysis.NormedSpace.Span
suppress_compilation
open Bornology
open Filter hiding map_smul
open scoped Classical NNReal Topology Uniformity
-- the `β` subscript variables are for special cases about linear (as opposed to semilinear) maps
variable {π πβ πβ E Eβ F Fβ G Gβ π : Type*}
section Normed
variable [NormedAddCommGroup E] [NormedAddCommGroup F] [NormedAddCommGroup G]
[NormedAddCommGroup Fβ]
open Metric ContinuousLinearMap
section
variable [NontriviallyNormedField π] [NontriviallyNormedField πβ] [NontriviallyNormedField πβ]
[NormedSpace π E] [NormedSpace πβ F] [NormedSpace πβ G] [NormedSpace π Fβ] (c : π)
{Οββ : π β+* πβ} {Οββ : πβ β+* πβ} (f g : E βSL[Οββ] F) (x y z : E)
namespace ContinuousLinearMap
section OpNorm
open Set Real
| Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean | 99 | 107 | theorem opNorm_zero_iff [RingHomIsometric Οββ] : βfβ = 0 β f = 0 :=
Iff.intro
(fun hn => ContinuousLinearMap.ext fun x => norm_le_zero_iff.1
(calc
_ β€ βfβ * βxβ := le_opNorm _ _
_ = _ := by | rw [hn, zero_mul]))
(by
rintro rfl
exact opNorm_zero)
| 1,594 |
import Mathlib.Analysis.NormedSpace.OperatorNorm.Bilinear
import Mathlib.Analysis.NormedSpace.OperatorNorm.NNNorm
import Mathlib.Analysis.NormedSpace.Span
suppress_compilation
open Bornology
open Filter hiding map_smul
open scoped Classical NNReal Topology Uniformity
-- the `β` subscript variables are for special cases about linear (as opposed to semilinear) maps
variable {π πβ πβ E Eβ F Fβ G Gβ π : Type*}
section Normed
variable [NormedAddCommGroup E] [NormedAddCommGroup F] [NormedAddCommGroup G]
[NormedAddCommGroup Fβ]
open Metric ContinuousLinearMap
section
variable [NontriviallyNormedField π] [NontriviallyNormedField πβ] [NontriviallyNormedField πβ]
[NormedSpace π E] [NormedSpace πβ F] [NormedSpace πβ G] [NormedSpace π Fβ] (c : π)
{Οββ : π β+* πβ} {Οββ : πβ β+* πβ} (f g : E βSL[Οββ] F) (x y z : E)
namespace ContinuousLinearMap
section OpNorm
open Set Real
theorem opNorm_zero_iff [RingHomIsometric Οββ] : βfβ = 0 β f = 0 :=
Iff.intro
(fun hn => ContinuousLinearMap.ext fun x => norm_le_zero_iff.1
(calc
_ β€ βfβ * βxβ := le_opNorm _ _
_ = _ := by rw [hn, zero_mul]))
(by
rintro rfl
exact opNorm_zero)
#align continuous_linear_map.op_norm_zero_iff ContinuousLinearMap.opNorm_zero_iff
@[deprecated (since := "2024-02-02")] alias op_norm_zero_iff := opNorm_zero_iff
@[simp]
| Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean | 114 | 117 | theorem norm_id [Nontrivial E] : βid π Eβ = 1 := by |
refine norm_id_of_nontrivial_seminorm ?_
obtain β¨x, hxβ© := exists_ne (0 : E)
exact β¨x, ne_of_gt (norm_pos_iff.2 hx)β©
| 1,594 |
import Mathlib.Analysis.NormedSpace.OperatorNorm.Bilinear
import Mathlib.Analysis.NormedSpace.OperatorNorm.NNNorm
import Mathlib.Analysis.NormedSpace.Span
suppress_compilation
open Bornology
open Filter hiding map_smul
open scoped Classical NNReal Topology Uniformity
-- the `β` subscript variables are for special cases about linear (as opposed to semilinear) maps
variable {π πβ πβ E Eβ F Fβ G Gβ π : Type*}
section Normed
variable [NormedAddCommGroup E] [NormedAddCommGroup F] [NormedAddCommGroup G]
[NormedAddCommGroup Fβ]
open Metric ContinuousLinearMap
section
variable [NontriviallyNormedField π] [NontriviallyNormedField πβ] [NontriviallyNormedField πβ]
[NormedSpace π E] [NormedSpace πβ F] [NormedSpace πβ G] [NormedSpace π Fβ] (c : π)
{Οββ : π β+* πβ} {Οββ : πβ β+* πβ} (f g : E βSL[Οββ] F) (x y z : E)
namespace ContinuousLinearMap
section OpNorm
open Set Real
theorem opNorm_zero_iff [RingHomIsometric Οββ] : βfβ = 0 β f = 0 :=
Iff.intro
(fun hn => ContinuousLinearMap.ext fun x => norm_le_zero_iff.1
(calc
_ β€ βfβ * βxβ := le_opNorm _ _
_ = _ := by rw [hn, zero_mul]))
(by
rintro rfl
exact opNorm_zero)
#align continuous_linear_map.op_norm_zero_iff ContinuousLinearMap.opNorm_zero_iff
@[deprecated (since := "2024-02-02")] alias op_norm_zero_iff := opNorm_zero_iff
@[simp]
theorem norm_id [Nontrivial E] : βid π Eβ = 1 := by
refine norm_id_of_nontrivial_seminorm ?_
obtain β¨x, hxβ© := exists_ne (0 : E)
exact β¨x, ne_of_gt (norm_pos_iff.2 hx)β©
#align continuous_linear_map.norm_id ContinuousLinearMap.norm_id
@[simp]
lemma nnnorm_id [Nontrivial E] : βid π Eββ = 1 := NNReal.eq norm_id
instance normOneClass [Nontrivial E] : NormOneClass (E βL[π] E) :=
β¨norm_idβ©
#align continuous_linear_map.norm_one_class ContinuousLinearMap.normOneClass
instance toNormedAddCommGroup [RingHomIsometric Οββ] : NormedAddCommGroup (E βSL[Οββ] F) :=
NormedAddCommGroup.ofSeparation fun f => (opNorm_zero_iff f).mp
#align continuous_linear_map.to_normed_add_comm_group ContinuousLinearMap.toNormedAddCommGroup
instance toNormedRing : NormedRing (E βL[π] E) :=
{ ContinuousLinearMap.toNormedAddCommGroup, ContinuousLinearMap.toSemiNormedRing with }
#align continuous_linear_map.to_normed_ring ContinuousLinearMap.toNormedRing
variable {f}
| Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean | 140 | 146 | theorem homothety_norm [RingHomIsometric Οββ] [Nontrivial E] (f : E βSL[Οββ] F) {a : β}
(hf : β x, βf xβ = a * βxβ) : βfβ = a := by |
obtain β¨x, hxβ© : β x : E, x β 0 := exists_ne 0
rw [β norm_pos_iff] at hx
have ha : 0 β€ a := by simpa only [hf, hx, mul_nonneg_iff_of_pos_right] using norm_nonneg (f x)
apply le_antisymm (f.opNorm_le_bound ha fun y => le_of_eq (hf y))
simpa only [hf, hx, mul_le_mul_right] using f.le_opNorm x
| 1,594 |
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
suppress_compilation
set_option linter.uppercaseLean3 false
open Metric
open scoped Classical NNReal Topology Uniformity
variable {π E : Type*} [NontriviallyNormedField π]
section SemiNormed
variable [SeminormedAddCommGroup E] [NormedSpace π E]
namespace ContinuousLinearMap
section MultiplicationLinear
section SMulLinear
variable (π) (π' : Type*) [NormedField π']
variable [NormedAlgebra π π'] [NormedSpace π' E] [IsScalarTower π π' E]
def lsmul : π' βL[π] E βL[π] E :=
((Algebra.lsmul π π E).toLinearMap : π' ββ[π] E ββ[π] E).mkContinuousβ 1 fun c x => by
simpa only [one_mul] using norm_smul_le c x
#align continuous_linear_map.lsmul ContinuousLinearMap.lsmul
@[simp]
theorem lsmul_apply (c : π') (x : E) : lsmul π π' c x = c β’ x :=
rfl
#align continuous_linear_map.lsmul_apply ContinuousLinearMap.lsmul_apply
variable {π'}
| Mathlib/Analysis/NormedSpace/OperatorNorm/Mul.lean | 226 | 231 | theorem norm_toSpanSingleton (x : E) : βtoSpanSingleton π xβ = βxβ := by |
refine opNorm_eq_of_bounds (norm_nonneg _) (fun x => ?_) fun N _ h => ?_
Β· rw [toSpanSingleton_apply, norm_smul, mul_comm]
Β· specialize h 1
rw [toSpanSingleton_apply, norm_smul, mul_comm] at h
exact (mul_le_mul_right (by simp)).mp h
| 1,595 |
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
suppress_compilation
set_option linter.uppercaseLean3 false
open Metric
open scoped Classical NNReal Topology Uniformity
variable {π E : Type*} [NontriviallyNormedField π]
section SemiNormed
variable [SeminormedAddCommGroup E] [NormedSpace π E]
namespace ContinuousLinearMap
section MultiplicationLinear
section SMulLinear
variable (π) (π' : Type*) [NormedField π']
variable [NormedAlgebra π π'] [NormedSpace π' E] [IsScalarTower π π' E]
def lsmul : π' βL[π] E βL[π] E :=
((Algebra.lsmul π π E).toLinearMap : π' ββ[π] E ββ[π] E).mkContinuousβ 1 fun c x => by
simpa only [one_mul] using norm_smul_le c x
#align continuous_linear_map.lsmul ContinuousLinearMap.lsmul
@[simp]
theorem lsmul_apply (c : π') (x : E) : lsmul π π' c x = c β’ x :=
rfl
#align continuous_linear_map.lsmul_apply ContinuousLinearMap.lsmul_apply
variable {π'}
theorem norm_toSpanSingleton (x : E) : βtoSpanSingleton π xβ = βxβ := by
refine opNorm_eq_of_bounds (norm_nonneg _) (fun x => ?_) fun N _ h => ?_
Β· rw [toSpanSingleton_apply, norm_smul, mul_comm]
Β· specialize h 1
rw [toSpanSingleton_apply, norm_smul, mul_comm] at h
exact (mul_le_mul_right (by simp)).mp h
#align continuous_linear_map.norm_to_span_singleton ContinuousLinearMap.norm_toSpanSingleton
variable {π}
theorem opNorm_lsmul_apply_le (x : π') : β(lsmul π π' x : E βL[π] E)β β€ βxβ :=
ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg x) fun y => norm_smul_le x y
#align continuous_linear_map.op_norm_lsmul_apply_le ContinuousLinearMap.opNorm_lsmul_apply_le
@[deprecated (since := "2024-02-02")] alias op_norm_lsmul_apply_le := opNorm_lsmul_apply_le
| Mathlib/Analysis/NormedSpace/OperatorNorm/Mul.lean | 243 | 246 | theorem opNorm_lsmul_le : β(lsmul π π' : π' βL[π] E βL[π] E)β β€ 1 := by |
refine ContinuousLinearMap.opNorm_le_bound _ zero_le_one fun x => ?_
simp_rw [one_mul]
exact opNorm_lsmul_apply_le _
| 1,595 |
import Mathlib.Analysis.BoxIntegral.Partition.Split
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
#align_import analysis.box_integral.partition.additive from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
noncomputable section
open scoped Classical
open Function Set
namespace BoxIntegral
variable {ΞΉ M : Type*} {n : β}
structure BoxAdditiveMap (ΞΉ M : Type*) [AddCommMonoid M] (I : WithTop (Box ΞΉ)) where
toFun : Box ΞΉ β M
sum_partition_boxes' : β J : Box ΞΉ, βJ β€ I β β Ο : Prepartition J, Ο.IsPartition β
β Ji β Ο.boxes, toFun Ji = toFun J
#align box_integral.box_additive_map BoxIntegral.BoxAdditiveMap
scoped notation:25 ΞΉ " βα΅α΅ " M => BoxIntegral.BoxAdditiveMap ΞΉ M β€
@[inherit_doc] scoped notation:25 ΞΉ " βα΅α΅[" I "] " M => BoxIntegral.BoxAdditiveMap ΞΉ M I
namespace BoxAdditiveMap
open Box Prepartition Finset
variable {N : Type*} [AddCommMonoid M] [AddCommMonoid N] {Iβ : WithTop (Box ΞΉ)} {I J : Box ΞΉ}
{i : ΞΉ}
instance : FunLike (ΞΉ βα΅α΅[Iβ] M) (Box ΞΉ) M where
coe := toFun
coe_injective' f g h := by cases f; cases g; congr
initialize_simps_projections BoxIntegral.BoxAdditiveMap (toFun β apply)
#noalign box_integral.box_additive_map.to_fun_eq_coe
@[simp]
theorem coe_mk (f h) : β(mk f h : ΞΉ βα΅α΅[Iβ] M) = f := rfl
#align box_integral.box_additive_map.coe_mk BoxIntegral.BoxAdditiveMap.coe_mk
theorem coe_injective : Injective fun (f : ΞΉ βα΅α΅[Iβ] M) x => f x :=
DFunLike.coe_injective
#align box_integral.box_additive_map.coe_injective BoxIntegral.BoxAdditiveMap.coe_injective
-- Porting note (#10618): was @[simp], now can be proved by `simp`
theorem coe_inj {f g : ΞΉ βα΅α΅[Iβ] M} : (f : Box ΞΉ β M) = g β f = g := DFunLike.coe_fn_eq
#align box_integral.box_additive_map.coe_inj BoxIntegral.BoxAdditiveMap.coe_inj
theorem sum_partition_boxes (f : ΞΉ βα΅α΅[Iβ] M) (hI : βI β€ Iβ) {Ο : Prepartition I}
(h : Ο.IsPartition) : β J β Ο.boxes, f J = f I :=
f.sum_partition_boxes' I hI Ο h
#align box_integral.box_additive_map.sum_partition_boxes BoxIntegral.BoxAdditiveMap.sum_partition_boxes
@[simps (config := .asFn)]
instance : Zero (ΞΉ βα΅α΅[Iβ] M) :=
β¨β¨0, fun _ _ _ _ => sum_const_zeroβ©β©
instance : Inhabited (ΞΉ βα΅α΅[Iβ] M) :=
β¨0β©
instance : Add (ΞΉ βα΅α΅[Iβ] M) :=
β¨fun f g =>
β¨f + g, fun I hI Ο hΟ => by
simp only [Pi.add_apply, sum_add_distrib, sum_partition_boxes _ hI hΟ]β©β©
instance {R} [Monoid R] [DistribMulAction R M] : SMul R (ΞΉ βα΅α΅[Iβ] M) :=
β¨fun r f =>
β¨r β’ (f : Box ΞΉ β M), fun I hI Ο hΟ => by
simp only [Pi.smul_apply, β smul_sum, sum_partition_boxes _ hI hΟ]β©β©
instance : AddCommMonoid (ΞΉ βα΅α΅[Iβ] M) :=
Function.Injective.addCommMonoid _ coe_injective rfl (fun _ _ => rfl) fun _ _ => rfl
@[simp]
| Mathlib/Analysis/BoxIntegral/Partition/Additive.lean | 113 | 115 | theorem map_split_add (f : ΞΉ βα΅α΅[Iβ] M) (hI : βI β€ Iβ) (i : ΞΉ) (x : β) :
(I.splitLower i x).elim' 0 f + (I.splitUpper i x).elim' 0 f = f I := by |
rw [β f.sum_partition_boxes hI (isPartitionSplit I i x), sum_split_boxes]
| 1,596 |
import Mathlib.Algebra.Algebra.Unitization
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
suppress_compilation
variable (π A : Type*) [NontriviallyNormedField π] [NonUnitalNormedRing A]
variable [NormedSpace π A] [IsScalarTower π A A] [SMulCommClass π A A]
open ContinuousLinearMap
namespace Unitization
def splitMul : Unitization π A ββ[π] π Γ (A βL[π] A) :=
(lift 0).prod (lift <| NonUnitalAlgHom.Lmul π A)
variable {π A}
@[simp]
theorem splitMul_apply (x : Unitization π A) :
splitMul π A x = (x.fst, algebraMap π (A βL[π] A) x.fst + mul π A x.snd) :=
show (x.fst + 0, _) = (x.fst, _) by rw [add_zero]; rfl
| Mathlib/Analysis/NormedSpace/Unitization.lean | 89 | 101 | theorem splitMul_injective_of_clm_mul_injective
(h : Function.Injective (mul π A)) :
Function.Injective (splitMul π A) := by |
rw [injective_iff_map_eq_zero]
intro x hx
induction x
rw [map_add] at hx
simp only [splitMul_apply, fst_inl, snd_inl, map_zero, add_zero, fst_inr, snd_inr,
zero_add, Prod.mk_add_mk, Prod.mk_eq_zero] at hx
obtain β¨rfl, hxβ© := hx
simp only [map_zero, zero_add, inl_zero] at hx β’
rw [β map_zero (mul π A)] at hx
rw [h hx, inr_zero]
| 1,597 |
import Mathlib.Algebra.Algebra.Unitization
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
suppress_compilation
variable (π A : Type*) [NontriviallyNormedField π] [NonUnitalNormedRing A]
variable [NormedSpace π A] [IsScalarTower π A A] [SMulCommClass π A A]
open ContinuousLinearMap
namespace Unitization
def splitMul : Unitization π A ββ[π] π Γ (A βL[π] A) :=
(lift 0).prod (lift <| NonUnitalAlgHom.Lmul π A)
variable {π A}
@[simp]
theorem splitMul_apply (x : Unitization π A) :
splitMul π A x = (x.fst, algebraMap π (A βL[π] A) x.fst + mul π A x.snd) :=
show (x.fst + 0, _) = (x.fst, _) by rw [add_zero]; rfl
theorem splitMul_injective_of_clm_mul_injective
(h : Function.Injective (mul π A)) :
Function.Injective (splitMul π A) := by
rw [injective_iff_map_eq_zero]
intro x hx
induction x
rw [map_add] at hx
simp only [splitMul_apply, fst_inl, snd_inl, map_zero, add_zero, fst_inr, snd_inr,
zero_add, Prod.mk_add_mk, Prod.mk_eq_zero] at hx
obtain β¨rfl, hxβ© := hx
simp only [map_zero, zero_add, inl_zero] at hx β’
rw [β map_zero (mul π A)] at hx
rw [h hx, inr_zero]
variable [RegularNormedAlgebra π A]
variable (π A)
theorem splitMul_injective : Function.Injective (splitMul π A) :=
splitMul_injective_of_clm_mul_injective (isometry_mul π A).injective
variable {π A}
section Aux
noncomputable abbrev normedRingAux : NormedRing (Unitization π A) :=
NormedRing.induced (Unitization π A) (π Γ (A βL[π] A)) (splitMul π A) (splitMul_injective π A)
attribute [local instance] Unitization.normedRingAux
noncomputable abbrev normedAlgebraAux : NormedAlgebra π (Unitization π A) :=
NormedAlgebra.induced π (Unitization π A) (π Γ (A βL[π] A)) (splitMul π A)
attribute [local instance] Unitization.normedAlgebraAux
theorem norm_def (x : Unitization π A) : βxβ = βsplitMul π A xβ :=
rfl
theorem nnnorm_def (x : Unitization π A) : βxββ = βsplitMul π A xββ :=
rfl
| Mathlib/Analysis/NormedSpace/Unitization.lean | 139 | 141 | theorem norm_eq_sup (x : Unitization π A) :
βxβ = βx.fstβ β βalgebraMap π (A βL[π] A) x.fst + mul π A x.sndβ := by |
rw [norm_def, splitMul_apply, Prod.norm_def, sup_eq_max]
| 1,597 |
import Mathlib.Algebra.Algebra.Unitization
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
suppress_compilation
variable (π A : Type*) [NontriviallyNormedField π] [NonUnitalNormedRing A]
variable [NormedSpace π A] [IsScalarTower π A A] [SMulCommClass π A A]
open ContinuousLinearMap
namespace Unitization
def splitMul : Unitization π A ββ[π] π Γ (A βL[π] A) :=
(lift 0).prod (lift <| NonUnitalAlgHom.Lmul π A)
variable {π A}
@[simp]
theorem splitMul_apply (x : Unitization π A) :
splitMul π A x = (x.fst, algebraMap π (A βL[π] A) x.fst + mul π A x.snd) :=
show (x.fst + 0, _) = (x.fst, _) by rw [add_zero]; rfl
theorem splitMul_injective_of_clm_mul_injective
(h : Function.Injective (mul π A)) :
Function.Injective (splitMul π A) := by
rw [injective_iff_map_eq_zero]
intro x hx
induction x
rw [map_add] at hx
simp only [splitMul_apply, fst_inl, snd_inl, map_zero, add_zero, fst_inr, snd_inr,
zero_add, Prod.mk_add_mk, Prod.mk_eq_zero] at hx
obtain β¨rfl, hxβ© := hx
simp only [map_zero, zero_add, inl_zero] at hx β’
rw [β map_zero (mul π A)] at hx
rw [h hx, inr_zero]
variable [RegularNormedAlgebra π A]
variable (π A)
theorem splitMul_injective : Function.Injective (splitMul π A) :=
splitMul_injective_of_clm_mul_injective (isometry_mul π A).injective
variable {π A}
section Aux
noncomputable abbrev normedRingAux : NormedRing (Unitization π A) :=
NormedRing.induced (Unitization π A) (π Γ (A βL[π] A)) (splitMul π A) (splitMul_injective π A)
attribute [local instance] Unitization.normedRingAux
noncomputable abbrev normedAlgebraAux : NormedAlgebra π (Unitization π A) :=
NormedAlgebra.induced π (Unitization π A) (π Γ (A βL[π] A)) (splitMul π A)
attribute [local instance] Unitization.normedAlgebraAux
theorem norm_def (x : Unitization π A) : βxβ = βsplitMul π A xβ :=
rfl
theorem nnnorm_def (x : Unitization π A) : βxββ = βsplitMul π A xββ :=
rfl
theorem norm_eq_sup (x : Unitization π A) :
βxβ = βx.fstβ β βalgebraMap π (A βL[π] A) x.fst + mul π A x.sndβ := by
rw [norm_def, splitMul_apply, Prod.norm_def, sup_eq_max]
theorem nnnorm_eq_sup (x : Unitization π A) :
βxββ = βx.fstββ β βalgebraMap π (A βL[π] A) x.fst + mul π A x.sndββ :=
NNReal.eq <| norm_eq_sup x
| Mathlib/Analysis/NormedSpace/Unitization.lean | 149 | 165 | theorem lipschitzWith_addEquiv :
LipschitzWith 2 (Unitization.addEquiv π A) := by |
rw [β Real.toNNReal_ofNat]
refine AddMonoidHomClass.lipschitz_of_bound (Unitization.addEquiv π A) 2 fun x => ?_
rw [norm_eq_sup, Prod.norm_def]
refine max_le ?_ ?_
Β· rw [sup_eq_max, mul_max_of_nonneg _ _ (zero_le_two : (0 : β) β€ 2)]
exact le_max_of_le_left ((le_add_of_nonneg_left (norm_nonneg _)).trans_eq (two_mul _).symm)
Β· nontriviality A
rw [two_mul]
calc
βx.sndβ = βmul π A x.sndβ :=
.symm <| (isometry_mul π A).norm_map_of_map_zero (map_zero _) _
_ β€ βalgebraMap π _ x.fst + mul π A x.sndβ + βx.fstβ := by
simpa only [add_comm _ (mul π A x.snd), norm_algebraMap'] using
norm_le_add_norm_add (mul π A x.snd) (algebraMap π _ x.fst)
_ β€ _ := add_le_add le_sup_right le_sup_left
| 1,597 |
import Mathlib.Algebra.Algebra.Unitization
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
suppress_compilation
variable (π A : Type*) [NontriviallyNormedField π] [NonUnitalNormedRing A]
variable [NormedSpace π A] [IsScalarTower π A A] [SMulCommClass π A A]
open ContinuousLinearMap
namespace Unitization
def splitMul : Unitization π A ββ[π] π Γ (A βL[π] A) :=
(lift 0).prod (lift <| NonUnitalAlgHom.Lmul π A)
variable {π A}
@[simp]
theorem splitMul_apply (x : Unitization π A) :
splitMul π A x = (x.fst, algebraMap π (A βL[π] A) x.fst + mul π A x.snd) :=
show (x.fst + 0, _) = (x.fst, _) by rw [add_zero]; rfl
theorem splitMul_injective_of_clm_mul_injective
(h : Function.Injective (mul π A)) :
Function.Injective (splitMul π A) := by
rw [injective_iff_map_eq_zero]
intro x hx
induction x
rw [map_add] at hx
simp only [splitMul_apply, fst_inl, snd_inl, map_zero, add_zero, fst_inr, snd_inr,
zero_add, Prod.mk_add_mk, Prod.mk_eq_zero] at hx
obtain β¨rfl, hxβ© := hx
simp only [map_zero, zero_add, inl_zero] at hx β’
rw [β map_zero (mul π A)] at hx
rw [h hx, inr_zero]
variable [RegularNormedAlgebra π A]
variable (π A)
theorem splitMul_injective : Function.Injective (splitMul π A) :=
splitMul_injective_of_clm_mul_injective (isometry_mul π A).injective
variable {π A}
section Aux
noncomputable abbrev normedRingAux : NormedRing (Unitization π A) :=
NormedRing.induced (Unitization π A) (π Γ (A βL[π] A)) (splitMul π A) (splitMul_injective π A)
attribute [local instance] Unitization.normedRingAux
noncomputable abbrev normedAlgebraAux : NormedAlgebra π (Unitization π A) :=
NormedAlgebra.induced π (Unitization π A) (π Γ (A βL[π] A)) (splitMul π A)
attribute [local instance] Unitization.normedAlgebraAux
theorem norm_def (x : Unitization π A) : βxβ = βsplitMul π A xβ :=
rfl
theorem nnnorm_def (x : Unitization π A) : βxββ = βsplitMul π A xββ :=
rfl
theorem norm_eq_sup (x : Unitization π A) :
βxβ = βx.fstβ β βalgebraMap π (A βL[π] A) x.fst + mul π A x.sndβ := by
rw [norm_def, splitMul_apply, Prod.norm_def, sup_eq_max]
theorem nnnorm_eq_sup (x : Unitization π A) :
βxββ = βx.fstββ β βalgebraMap π (A βL[π] A) x.fst + mul π A x.sndββ :=
NNReal.eq <| norm_eq_sup x
theorem lipschitzWith_addEquiv :
LipschitzWith 2 (Unitization.addEquiv π A) := by
rw [β Real.toNNReal_ofNat]
refine AddMonoidHomClass.lipschitz_of_bound (Unitization.addEquiv π A) 2 fun x => ?_
rw [norm_eq_sup, Prod.norm_def]
refine max_le ?_ ?_
Β· rw [sup_eq_max, mul_max_of_nonneg _ _ (zero_le_two : (0 : β) β€ 2)]
exact le_max_of_le_left ((le_add_of_nonneg_left (norm_nonneg _)).trans_eq (two_mul _).symm)
Β· nontriviality A
rw [two_mul]
calc
βx.sndβ = βmul π A x.sndβ :=
.symm <| (isometry_mul π A).norm_map_of_map_zero (map_zero _) _
_ β€ βalgebraMap π _ x.fst + mul π A x.sndβ + βx.fstβ := by
simpa only [add_comm _ (mul π A x.snd), norm_algebraMap'] using
norm_le_add_norm_add (mul π A x.snd) (algebraMap π _ x.fst)
_ β€ _ := add_le_add le_sup_right le_sup_left
| Mathlib/Analysis/NormedSpace/Unitization.lean | 167 | 180 | theorem antilipschitzWith_addEquiv :
AntilipschitzWith 2 (addEquiv π A) := by |
refine AddMonoidHomClass.antilipschitz_of_bound (addEquiv π A) fun x => ?_
rw [norm_eq_sup, Prod.norm_def, NNReal.coe_two]
refine max_le ?_ ?_
Β· rw [mul_max_of_nonneg _ _ (zero_le_two : (0 : β) β€ 2)]
exact le_max_of_le_left ((le_add_of_nonneg_left (norm_nonneg _)).trans_eq (two_mul _).symm)
Β· nontriviality A
calc
βalgebraMap π _ x.fst + mul π A x.sndβ β€ βalgebraMap π _ x.fstβ + βmul π A x.sndβ :=
norm_add_le _ _
_ = βx.fstβ + βx.sndβ := by
rw [norm_algebraMap', (AddMonoidHomClass.isometry_iff_norm (mul π A)).mp (isometry_mul π A)]
_ β€ _ := (add_le_add (le_max_left _ _) (le_max_right _ _)).trans_eq (two_mul _).symm
| 1,597 |
import Mathlib.Algebra.Algebra.Unitization
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
suppress_compilation
variable (π A : Type*) [NontriviallyNormedField π] [NonUnitalNormedRing A]
variable [NormedSpace π A] [IsScalarTower π A A] [SMulCommClass π A A]
open ContinuousLinearMap
namespace Unitization
def splitMul : Unitization π A ββ[π] π Γ (A βL[π] A) :=
(lift 0).prod (lift <| NonUnitalAlgHom.Lmul π A)
variable {π A}
@[simp]
theorem splitMul_apply (x : Unitization π A) :
splitMul π A x = (x.fst, algebraMap π (A βL[π] A) x.fst + mul π A x.snd) :=
show (x.fst + 0, _) = (x.fst, _) by rw [add_zero]; rfl
theorem splitMul_injective_of_clm_mul_injective
(h : Function.Injective (mul π A)) :
Function.Injective (splitMul π A) := by
rw [injective_iff_map_eq_zero]
intro x hx
induction x
rw [map_add] at hx
simp only [splitMul_apply, fst_inl, snd_inl, map_zero, add_zero, fst_inr, snd_inr,
zero_add, Prod.mk_add_mk, Prod.mk_eq_zero] at hx
obtain β¨rfl, hxβ© := hx
simp only [map_zero, zero_add, inl_zero] at hx β’
rw [β map_zero (mul π A)] at hx
rw [h hx, inr_zero]
variable [RegularNormedAlgebra π A]
variable (π A)
theorem splitMul_injective : Function.Injective (splitMul π A) :=
splitMul_injective_of_clm_mul_injective (isometry_mul π A).injective
variable {π A}
section Aux
noncomputable abbrev normedRingAux : NormedRing (Unitization π A) :=
NormedRing.induced (Unitization π A) (π Γ (A βL[π] A)) (splitMul π A) (splitMul_injective π A)
attribute [local instance] Unitization.normedRingAux
noncomputable abbrev normedAlgebraAux : NormedAlgebra π (Unitization π A) :=
NormedAlgebra.induced π (Unitization π A) (π Γ (A βL[π] A)) (splitMul π A)
attribute [local instance] Unitization.normedAlgebraAux
theorem norm_def (x : Unitization π A) : βxβ = βsplitMul π A xβ :=
rfl
theorem nnnorm_def (x : Unitization π A) : βxββ = βsplitMul π A xββ :=
rfl
theorem norm_eq_sup (x : Unitization π A) :
βxβ = βx.fstβ β βalgebraMap π (A βL[π] A) x.fst + mul π A x.sndβ := by
rw [norm_def, splitMul_apply, Prod.norm_def, sup_eq_max]
theorem nnnorm_eq_sup (x : Unitization π A) :
βxββ = βx.fstββ β βalgebraMap π (A βL[π] A) x.fst + mul π A x.sndββ :=
NNReal.eq <| norm_eq_sup x
theorem lipschitzWith_addEquiv :
LipschitzWith 2 (Unitization.addEquiv π A) := by
rw [β Real.toNNReal_ofNat]
refine AddMonoidHomClass.lipschitz_of_bound (Unitization.addEquiv π A) 2 fun x => ?_
rw [norm_eq_sup, Prod.norm_def]
refine max_le ?_ ?_
Β· rw [sup_eq_max, mul_max_of_nonneg _ _ (zero_le_two : (0 : β) β€ 2)]
exact le_max_of_le_left ((le_add_of_nonneg_left (norm_nonneg _)).trans_eq (two_mul _).symm)
Β· nontriviality A
rw [two_mul]
calc
βx.sndβ = βmul π A x.sndβ :=
.symm <| (isometry_mul π A).norm_map_of_map_zero (map_zero _) _
_ β€ βalgebraMap π _ x.fst + mul π A x.sndβ + βx.fstβ := by
simpa only [add_comm _ (mul π A x.snd), norm_algebraMap'] using
norm_le_add_norm_add (mul π A x.snd) (algebraMap π _ x.fst)
_ β€ _ := add_le_add le_sup_right le_sup_left
theorem antilipschitzWith_addEquiv :
AntilipschitzWith 2 (addEquiv π A) := by
refine AddMonoidHomClass.antilipschitz_of_bound (addEquiv π A) fun x => ?_
rw [norm_eq_sup, Prod.norm_def, NNReal.coe_two]
refine max_le ?_ ?_
Β· rw [mul_max_of_nonneg _ _ (zero_le_two : (0 : β) β€ 2)]
exact le_max_of_le_left ((le_add_of_nonneg_left (norm_nonneg _)).trans_eq (two_mul _).symm)
Β· nontriviality A
calc
βalgebraMap π _ x.fst + mul π A x.sndβ β€ βalgebraMap π _ x.fstβ + βmul π A x.sndβ :=
norm_add_le _ _
_ = βx.fstβ + βx.sndβ := by
rw [norm_algebraMap', (AddMonoidHomClass.isometry_iff_norm (mul π A)).mp (isometry_mul π A)]
_ β€ _ := (add_le_add (le_max_left _ _) (le_max_right _ _)).trans_eq (two_mul _).symm
open Bornology Filter
open scoped Uniformity Topology
| Mathlib/Analysis/NormedSpace/Unitization.lean | 185 | 190 | theorem uniformity_eq_aux :
π€[instUniformSpaceProd.comap <| addEquiv π A] = π€ (Unitization π A) := by |
have key : UniformInducing (addEquiv π A) :=
antilipschitzWith_addEquiv.uniformInducing lipschitzWith_addEquiv.uniformContinuous
rw [β key.comap_uniformity]
rfl
| 1,597 |
import Mathlib.Analysis.NormedSpace.Multilinear.Basic
import Mathlib.Analysis.NormedSpace.Units
import Mathlib.Analysis.NormedSpace.OperatorNorm.Completeness
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
#align_import analysis.normed_space.bounded_linear_maps from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
open Topology
open Filter (Tendsto)
open Metric ContinuousLinearMap
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] {G : Type*}
[NormedAddCommGroup G] [NormedSpace π G]
structure IsBoundedLinearMap (π : Type*) [NormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] (f : E β F) extends
IsLinearMap π f : Prop where
bound : β M, 0 < M β§ β x : E, βf xβ β€ M * βxβ
#align is_bounded_linear_map IsBoundedLinearMap
theorem IsLinearMap.with_bound {f : E β F} (hf : IsLinearMap π f) (M : β)
(h : β x : E, βf xβ β€ M * βxβ) : IsBoundedLinearMap π f :=
β¨hf,
by_cases
(fun (this : M β€ 0) =>
β¨1, zero_lt_one, fun x =>
(h x).trans <| mul_le_mul_of_nonneg_right (this.trans zero_le_one) (norm_nonneg x)β©)
fun (this : Β¬M β€ 0) => β¨M, lt_of_not_ge this, hβ©β©
#align is_linear_map.with_bound IsLinearMap.with_bound
theorem ContinuousLinearMap.isBoundedLinearMap (f : E βL[π] F) : IsBoundedLinearMap π f :=
{ f.toLinearMap.isLinear with bound := f.bound }
#align continuous_linear_map.is_bounded_linear_map ContinuousLinearMap.isBoundedLinearMap
namespace IsBoundedLinearMap
def toLinearMap (f : E β F) (h : IsBoundedLinearMap π f) : E ββ[π] F :=
IsLinearMap.mk' _ h.toIsLinearMap
#align is_bounded_linear_map.to_linear_map IsBoundedLinearMap.toLinearMap
def toContinuousLinearMap {f : E β F} (hf : IsBoundedLinearMap π f) : E βL[π] F :=
{ toLinearMap f hf with
cont :=
let β¨C, _, hCβ© := hf.bound
AddMonoidHomClass.continuous_of_bound (toLinearMap f hf) C hC }
#align is_bounded_linear_map.to_continuous_linear_map IsBoundedLinearMap.toContinuousLinearMap
theorem zero : IsBoundedLinearMap π fun _ : E => (0 : F) :=
(0 : E ββ[π] F).isLinear.with_bound 0 <| by simp [le_refl]
#align is_bounded_linear_map.zero IsBoundedLinearMap.zero
theorem id : IsBoundedLinearMap π fun x : E => x :=
LinearMap.id.isLinear.with_bound 1 <| by simp [le_refl]
#align is_bounded_linear_map.id IsBoundedLinearMap.id
| Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean | 115 | 118 | theorem fst : IsBoundedLinearMap π fun x : E Γ F => x.1 := by |
refine (LinearMap.fst π E F).isLinear.with_bound 1 fun x => ?_
rw [one_mul]
exact le_max_left _ _
| 1,598 |
import Mathlib.Analysis.NormedSpace.Multilinear.Basic
import Mathlib.Analysis.NormedSpace.Units
import Mathlib.Analysis.NormedSpace.OperatorNorm.Completeness
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
#align_import analysis.normed_space.bounded_linear_maps from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
open Topology
open Filter (Tendsto)
open Metric ContinuousLinearMap
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] {G : Type*}
[NormedAddCommGroup G] [NormedSpace π G]
structure IsBoundedLinearMap (π : Type*) [NormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] (f : E β F) extends
IsLinearMap π f : Prop where
bound : β M, 0 < M β§ β x : E, βf xβ β€ M * βxβ
#align is_bounded_linear_map IsBoundedLinearMap
theorem IsLinearMap.with_bound {f : E β F} (hf : IsLinearMap π f) (M : β)
(h : β x : E, βf xβ β€ M * βxβ) : IsBoundedLinearMap π f :=
β¨hf,
by_cases
(fun (this : M β€ 0) =>
β¨1, zero_lt_one, fun x =>
(h x).trans <| mul_le_mul_of_nonneg_right (this.trans zero_le_one) (norm_nonneg x)β©)
fun (this : Β¬M β€ 0) => β¨M, lt_of_not_ge this, hβ©β©
#align is_linear_map.with_bound IsLinearMap.with_bound
theorem ContinuousLinearMap.isBoundedLinearMap (f : E βL[π] F) : IsBoundedLinearMap π f :=
{ f.toLinearMap.isLinear with bound := f.bound }
#align continuous_linear_map.is_bounded_linear_map ContinuousLinearMap.isBoundedLinearMap
namespace IsBoundedLinearMap
def toLinearMap (f : E β F) (h : IsBoundedLinearMap π f) : E ββ[π] F :=
IsLinearMap.mk' _ h.toIsLinearMap
#align is_bounded_linear_map.to_linear_map IsBoundedLinearMap.toLinearMap
def toContinuousLinearMap {f : E β F} (hf : IsBoundedLinearMap π f) : E βL[π] F :=
{ toLinearMap f hf with
cont :=
let β¨C, _, hCβ© := hf.bound
AddMonoidHomClass.continuous_of_bound (toLinearMap f hf) C hC }
#align is_bounded_linear_map.to_continuous_linear_map IsBoundedLinearMap.toContinuousLinearMap
theorem zero : IsBoundedLinearMap π fun _ : E => (0 : F) :=
(0 : E ββ[π] F).isLinear.with_bound 0 <| by simp [le_refl]
#align is_bounded_linear_map.zero IsBoundedLinearMap.zero
theorem id : IsBoundedLinearMap π fun x : E => x :=
LinearMap.id.isLinear.with_bound 1 <| by simp [le_refl]
#align is_bounded_linear_map.id IsBoundedLinearMap.id
theorem fst : IsBoundedLinearMap π fun x : E Γ F => x.1 := by
refine (LinearMap.fst π E F).isLinear.with_bound 1 fun x => ?_
rw [one_mul]
exact le_max_left _ _
#align is_bounded_linear_map.fst IsBoundedLinearMap.fst
| Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean | 121 | 124 | theorem snd : IsBoundedLinearMap π fun x : E Γ F => x.2 := by |
refine (LinearMap.snd π E F).isLinear.with_bound 1 fun x => ?_
rw [one_mul]
exact le_max_right _ _
| 1,598 |
import Mathlib.Analysis.NormedSpace.Multilinear.Basic
import Mathlib.Analysis.NormedSpace.Units
import Mathlib.Analysis.NormedSpace.OperatorNorm.Completeness
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
#align_import analysis.normed_space.bounded_linear_maps from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
open Topology
open Filter (Tendsto)
open Metric ContinuousLinearMap
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] {G : Type*}
[NormedAddCommGroup G] [NormedSpace π G]
structure IsBoundedLinearMap (π : Type*) [NormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] (f : E β F) extends
IsLinearMap π f : Prop where
bound : β M, 0 < M β§ β x : E, βf xβ β€ M * βxβ
#align is_bounded_linear_map IsBoundedLinearMap
theorem IsLinearMap.with_bound {f : E β F} (hf : IsLinearMap π f) (M : β)
(h : β x : E, βf xβ β€ M * βxβ) : IsBoundedLinearMap π f :=
β¨hf,
by_cases
(fun (this : M β€ 0) =>
β¨1, zero_lt_one, fun x =>
(h x).trans <| mul_le_mul_of_nonneg_right (this.trans zero_le_one) (norm_nonneg x)β©)
fun (this : Β¬M β€ 0) => β¨M, lt_of_not_ge this, hβ©β©
#align is_linear_map.with_bound IsLinearMap.with_bound
theorem ContinuousLinearMap.isBoundedLinearMap (f : E βL[π] F) : IsBoundedLinearMap π f :=
{ f.toLinearMap.isLinear with bound := f.bound }
#align continuous_linear_map.is_bounded_linear_map ContinuousLinearMap.isBoundedLinearMap
namespace IsBoundedLinearMap
def toLinearMap (f : E β F) (h : IsBoundedLinearMap π f) : E ββ[π] F :=
IsLinearMap.mk' _ h.toIsLinearMap
#align is_bounded_linear_map.to_linear_map IsBoundedLinearMap.toLinearMap
def toContinuousLinearMap {f : E β F} (hf : IsBoundedLinearMap π f) : E βL[π] F :=
{ toLinearMap f hf with
cont :=
let β¨C, _, hCβ© := hf.bound
AddMonoidHomClass.continuous_of_bound (toLinearMap f hf) C hC }
#align is_bounded_linear_map.to_continuous_linear_map IsBoundedLinearMap.toContinuousLinearMap
theorem zero : IsBoundedLinearMap π fun _ : E => (0 : F) :=
(0 : E ββ[π] F).isLinear.with_bound 0 <| by simp [le_refl]
#align is_bounded_linear_map.zero IsBoundedLinearMap.zero
theorem id : IsBoundedLinearMap π fun x : E => x :=
LinearMap.id.isLinear.with_bound 1 <| by simp [le_refl]
#align is_bounded_linear_map.id IsBoundedLinearMap.id
theorem fst : IsBoundedLinearMap π fun x : E Γ F => x.1 := by
refine (LinearMap.fst π E F).isLinear.with_bound 1 fun x => ?_
rw [one_mul]
exact le_max_left _ _
#align is_bounded_linear_map.fst IsBoundedLinearMap.fst
theorem snd : IsBoundedLinearMap π fun x : E Γ F => x.2 := by
refine (LinearMap.snd π E F).isLinear.with_bound 1 fun x => ?_
rw [one_mul]
exact le_max_right _ _
#align is_bounded_linear_map.snd IsBoundedLinearMap.snd
variable {f g : E β F}
theorem smul (c : π) (hf : IsBoundedLinearMap π f) : IsBoundedLinearMap π (c β’ f) :=
let β¨hlf, M, _, hMβ© := hf
(c β’ hlf.mk' f).isLinear.with_bound (βcβ * M) fun x =>
calc
βc β’ f xβ = βcβ * βf xβ := norm_smul c (f x)
_ β€ βcβ * (M * βxβ) := mul_le_mul_of_nonneg_left (hM _) (norm_nonneg _)
_ = βcβ * M * βxβ := (mul_assoc _ _ _).symm
#align is_bounded_linear_map.smul IsBoundedLinearMap.smul
| Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean | 139 | 141 | theorem neg (hf : IsBoundedLinearMap π f) : IsBoundedLinearMap π fun e => -f e := by |
rw [show (fun e => -f e) = fun e => (-1 : π) β’ f e by funext; simp]
exact smul (-1) hf
| 1,598 |
import Mathlib.Analysis.NormedSpace.Multilinear.Basic
import Mathlib.Analysis.NormedSpace.Units
import Mathlib.Analysis.NormedSpace.OperatorNorm.Completeness
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
#align_import analysis.normed_space.bounded_linear_maps from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
open Topology
open Filter (Tendsto)
open Metric ContinuousLinearMap
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] {G : Type*}
[NormedAddCommGroup G] [NormedSpace π G]
structure IsBoundedLinearMap (π : Type*) [NormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] (f : E β F) extends
IsLinearMap π f : Prop where
bound : β M, 0 < M β§ β x : E, βf xβ β€ M * βxβ
#align is_bounded_linear_map IsBoundedLinearMap
theorem IsLinearMap.with_bound {f : E β F} (hf : IsLinearMap π f) (M : β)
(h : β x : E, βf xβ β€ M * βxβ) : IsBoundedLinearMap π f :=
β¨hf,
by_cases
(fun (this : M β€ 0) =>
β¨1, zero_lt_one, fun x =>
(h x).trans <| mul_le_mul_of_nonneg_right (this.trans zero_le_one) (norm_nonneg x)β©)
fun (this : Β¬M β€ 0) => β¨M, lt_of_not_ge this, hβ©β©
#align is_linear_map.with_bound IsLinearMap.with_bound
theorem ContinuousLinearMap.isBoundedLinearMap (f : E βL[π] F) : IsBoundedLinearMap π f :=
{ f.toLinearMap.isLinear with bound := f.bound }
#align continuous_linear_map.is_bounded_linear_map ContinuousLinearMap.isBoundedLinearMap
namespace IsBoundedLinearMap
def toLinearMap (f : E β F) (h : IsBoundedLinearMap π f) : E ββ[π] F :=
IsLinearMap.mk' _ h.toIsLinearMap
#align is_bounded_linear_map.to_linear_map IsBoundedLinearMap.toLinearMap
def toContinuousLinearMap {f : E β F} (hf : IsBoundedLinearMap π f) : E βL[π] F :=
{ toLinearMap f hf with
cont :=
let β¨C, _, hCβ© := hf.bound
AddMonoidHomClass.continuous_of_bound (toLinearMap f hf) C hC }
#align is_bounded_linear_map.to_continuous_linear_map IsBoundedLinearMap.toContinuousLinearMap
theorem zero : IsBoundedLinearMap π fun _ : E => (0 : F) :=
(0 : E ββ[π] F).isLinear.with_bound 0 <| by simp [le_refl]
#align is_bounded_linear_map.zero IsBoundedLinearMap.zero
theorem id : IsBoundedLinearMap π fun x : E => x :=
LinearMap.id.isLinear.with_bound 1 <| by simp [le_refl]
#align is_bounded_linear_map.id IsBoundedLinearMap.id
theorem fst : IsBoundedLinearMap π fun x : E Γ F => x.1 := by
refine (LinearMap.fst π E F).isLinear.with_bound 1 fun x => ?_
rw [one_mul]
exact le_max_left _ _
#align is_bounded_linear_map.fst IsBoundedLinearMap.fst
theorem snd : IsBoundedLinearMap π fun x : E Γ F => x.2 := by
refine (LinearMap.snd π E F).isLinear.with_bound 1 fun x => ?_
rw [one_mul]
exact le_max_right _ _
#align is_bounded_linear_map.snd IsBoundedLinearMap.snd
variable {f g : E β F}
theorem smul (c : π) (hf : IsBoundedLinearMap π f) : IsBoundedLinearMap π (c β’ f) :=
let β¨hlf, M, _, hMβ© := hf
(c β’ hlf.mk' f).isLinear.with_bound (βcβ * M) fun x =>
calc
βc β’ f xβ = βcβ * βf xβ := norm_smul c (f x)
_ β€ βcβ * (M * βxβ) := mul_le_mul_of_nonneg_left (hM _) (norm_nonneg _)
_ = βcβ * M * βxβ := (mul_assoc _ _ _).symm
#align is_bounded_linear_map.smul IsBoundedLinearMap.smul
theorem neg (hf : IsBoundedLinearMap π f) : IsBoundedLinearMap π fun e => -f e := by
rw [show (fun e => -f e) = fun e => (-1 : π) β’ f e by funext; simp]
exact smul (-1) hf
#align is_bounded_linear_map.neg IsBoundedLinearMap.neg
| Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean | 144 | 151 | theorem add (hf : IsBoundedLinearMap π f) (hg : IsBoundedLinearMap π g) :
IsBoundedLinearMap π fun e => f e + g e :=
let β¨hlf, Mf, _, hMfβ© := hf
let β¨hlg, Mg, _, hMgβ© := hg
(hlf.mk' _ + hlg.mk' _).isLinear.with_bound (Mf + Mg) fun x =>
calc
βf x + g xβ β€ Mf * βxβ + Mg * βxβ := norm_add_le_of_le (hMf x) (hMg x)
_ β€ (Mf + Mg) * βxβ := by | rw [add_mul]
| 1,598 |
import Mathlib.Analysis.NormedSpace.Multilinear.Basic
import Mathlib.Analysis.NormedSpace.Units
import Mathlib.Analysis.NormedSpace.OperatorNorm.Completeness
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
#align_import analysis.normed_space.bounded_linear_maps from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
open Topology
open Filter (Tendsto)
open Metric ContinuousLinearMap
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] {G : Type*}
[NormedAddCommGroup G] [NormedSpace π G]
structure IsBoundedLinearMap (π : Type*) [NormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] (f : E β F) extends
IsLinearMap π f : Prop where
bound : β M, 0 < M β§ β x : E, βf xβ β€ M * βxβ
#align is_bounded_linear_map IsBoundedLinearMap
theorem IsLinearMap.with_bound {f : E β F} (hf : IsLinearMap π f) (M : β)
(h : β x : E, βf xβ β€ M * βxβ) : IsBoundedLinearMap π f :=
β¨hf,
by_cases
(fun (this : M β€ 0) =>
β¨1, zero_lt_one, fun x =>
(h x).trans <| mul_le_mul_of_nonneg_right (this.trans zero_le_one) (norm_nonneg x)β©)
fun (this : Β¬M β€ 0) => β¨M, lt_of_not_ge this, hβ©β©
#align is_linear_map.with_bound IsLinearMap.with_bound
theorem ContinuousLinearMap.isBoundedLinearMap (f : E βL[π] F) : IsBoundedLinearMap π f :=
{ f.toLinearMap.isLinear with bound := f.bound }
#align continuous_linear_map.is_bounded_linear_map ContinuousLinearMap.isBoundedLinearMap
namespace IsBoundedLinearMap
def toLinearMap (f : E β F) (h : IsBoundedLinearMap π f) : E ββ[π] F :=
IsLinearMap.mk' _ h.toIsLinearMap
#align is_bounded_linear_map.to_linear_map IsBoundedLinearMap.toLinearMap
def toContinuousLinearMap {f : E β F} (hf : IsBoundedLinearMap π f) : E βL[π] F :=
{ toLinearMap f hf with
cont :=
let β¨C, _, hCβ© := hf.bound
AddMonoidHomClass.continuous_of_bound (toLinearMap f hf) C hC }
#align is_bounded_linear_map.to_continuous_linear_map IsBoundedLinearMap.toContinuousLinearMap
theorem zero : IsBoundedLinearMap π fun _ : E => (0 : F) :=
(0 : E ββ[π] F).isLinear.with_bound 0 <| by simp [le_refl]
#align is_bounded_linear_map.zero IsBoundedLinearMap.zero
theorem id : IsBoundedLinearMap π fun x : E => x :=
LinearMap.id.isLinear.with_bound 1 <| by simp [le_refl]
#align is_bounded_linear_map.id IsBoundedLinearMap.id
theorem fst : IsBoundedLinearMap π fun x : E Γ F => x.1 := by
refine (LinearMap.fst π E F).isLinear.with_bound 1 fun x => ?_
rw [one_mul]
exact le_max_left _ _
#align is_bounded_linear_map.fst IsBoundedLinearMap.fst
theorem snd : IsBoundedLinearMap π fun x : E Γ F => x.2 := by
refine (LinearMap.snd π E F).isLinear.with_bound 1 fun x => ?_
rw [one_mul]
exact le_max_right _ _
#align is_bounded_linear_map.snd IsBoundedLinearMap.snd
variable {f g : E β F}
theorem smul (c : π) (hf : IsBoundedLinearMap π f) : IsBoundedLinearMap π (c β’ f) :=
let β¨hlf, M, _, hMβ© := hf
(c β’ hlf.mk' f).isLinear.with_bound (βcβ * M) fun x =>
calc
βc β’ f xβ = βcβ * βf xβ := norm_smul c (f x)
_ β€ βcβ * (M * βxβ) := mul_le_mul_of_nonneg_left (hM _) (norm_nonneg _)
_ = βcβ * M * βxβ := (mul_assoc _ _ _).symm
#align is_bounded_linear_map.smul IsBoundedLinearMap.smul
theorem neg (hf : IsBoundedLinearMap π f) : IsBoundedLinearMap π fun e => -f e := by
rw [show (fun e => -f e) = fun e => (-1 : π) β’ f e by funext; simp]
exact smul (-1) hf
#align is_bounded_linear_map.neg IsBoundedLinearMap.neg
theorem add (hf : IsBoundedLinearMap π f) (hg : IsBoundedLinearMap π g) :
IsBoundedLinearMap π fun e => f e + g e :=
let β¨hlf, Mf, _, hMfβ© := hf
let β¨hlg, Mg, _, hMgβ© := hg
(hlf.mk' _ + hlg.mk' _).isLinear.with_bound (Mf + Mg) fun x =>
calc
βf x + g xβ β€ Mf * βxβ + Mg * βxβ := norm_add_le_of_le (hMf x) (hMg x)
_ β€ (Mf + Mg) * βxβ := by rw [add_mul]
#align is_bounded_linear_map.add IsBoundedLinearMap.add
| Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean | 155 | 156 | theorem sub (hf : IsBoundedLinearMap π f) (hg : IsBoundedLinearMap π g) :
IsBoundedLinearMap π fun e => f e - g e := by | simpa [sub_eq_add_neg] using add hf (neg hg)
| 1,598 |
import Mathlib.Analysis.NormedSpace.Multilinear.Basic
import Mathlib.Analysis.NormedSpace.Units
import Mathlib.Analysis.NormedSpace.OperatorNorm.Completeness
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
#align_import analysis.normed_space.bounded_linear_maps from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
open Topology
open Filter (Tendsto)
open Metric ContinuousLinearMap
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] {G : Type*}
[NormedAddCommGroup G] [NormedSpace π G]
structure IsBoundedLinearMap (π : Type*) [NormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] (f : E β F) extends
IsLinearMap π f : Prop where
bound : β M, 0 < M β§ β x : E, βf xβ β€ M * βxβ
#align is_bounded_linear_map IsBoundedLinearMap
theorem IsLinearMap.with_bound {f : E β F} (hf : IsLinearMap π f) (M : β)
(h : β x : E, βf xβ β€ M * βxβ) : IsBoundedLinearMap π f :=
β¨hf,
by_cases
(fun (this : M β€ 0) =>
β¨1, zero_lt_one, fun x =>
(h x).trans <| mul_le_mul_of_nonneg_right (this.trans zero_le_one) (norm_nonneg x)β©)
fun (this : Β¬M β€ 0) => β¨M, lt_of_not_ge this, hβ©β©
#align is_linear_map.with_bound IsLinearMap.with_bound
theorem ContinuousLinearMap.isBoundedLinearMap (f : E βL[π] F) : IsBoundedLinearMap π f :=
{ f.toLinearMap.isLinear with bound := f.bound }
#align continuous_linear_map.is_bounded_linear_map ContinuousLinearMap.isBoundedLinearMap
section
variable {ΞΉ : Type*} [Fintype ΞΉ]
| Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean | 217 | 231 | theorem isBoundedLinearMap_prod_multilinear {E : ΞΉ β Type*} [β i, NormedAddCommGroup (E i)]
[β i, NormedSpace π (E i)] :
IsBoundedLinearMap π fun p : ContinuousMultilinearMap π E F Γ ContinuousMultilinearMap π E G =>
p.1.prod p.2 where
map_add pβ pβ := by | ext : 1; rfl
map_smul c p := by ext : 1; rfl
bound := by
refine β¨1, zero_lt_one, fun p β¦ ?_β©
rw [one_mul]
apply ContinuousMultilinearMap.opNorm_le_bound _ (norm_nonneg _) _
intro m
rw [ContinuousMultilinearMap.prod_apply, norm_prod_le_iff]
constructor
Β· exact (p.1.le_opNorm m).trans (mul_le_mul_of_nonneg_right (norm_fst_le p) <| by positivity)
Β· exact (p.2.le_opNorm m).trans (mul_le_mul_of_nonneg_right (norm_snd_le p) <| by positivity)
| 1,598 |
import Mathlib.Analysis.NormedSpace.Multilinear.Basic
import Mathlib.Analysis.NormedSpace.Units
import Mathlib.Analysis.NormedSpace.OperatorNorm.Completeness
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
#align_import analysis.normed_space.bounded_linear_maps from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
open Topology
open Filter (Tendsto)
open Metric ContinuousLinearMap
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] {G : Type*}
[NormedAddCommGroup G] [NormedSpace π G]
structure IsBoundedLinearMap (π : Type*) [NormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] (f : E β F) extends
IsLinearMap π f : Prop where
bound : β M, 0 < M β§ β x : E, βf xβ β€ M * βxβ
#align is_bounded_linear_map IsBoundedLinearMap
theorem IsLinearMap.with_bound {f : E β F} (hf : IsLinearMap π f) (M : β)
(h : β x : E, βf xβ β€ M * βxβ) : IsBoundedLinearMap π f :=
β¨hf,
by_cases
(fun (this : M β€ 0) =>
β¨1, zero_lt_one, fun x =>
(h x).trans <| mul_le_mul_of_nonneg_right (this.trans zero_le_one) (norm_nonneg x)β©)
fun (this : Β¬M β€ 0) => β¨M, lt_of_not_ge this, hβ©β©
#align is_linear_map.with_bound IsLinearMap.with_bound
theorem ContinuousLinearMap.isBoundedLinearMap (f : E βL[π] F) : IsBoundedLinearMap π f :=
{ f.toLinearMap.isLinear with bound := f.bound }
#align continuous_linear_map.is_bounded_linear_map ContinuousLinearMap.isBoundedLinearMap
section
variable {ΞΉ : Type*} [Fintype ΞΉ]
theorem isBoundedLinearMap_prod_multilinear {E : ΞΉ β Type*} [β i, NormedAddCommGroup (E i)]
[β i, NormedSpace π (E i)] :
IsBoundedLinearMap π fun p : ContinuousMultilinearMap π E F Γ ContinuousMultilinearMap π E G =>
p.1.prod p.2 where
map_add pβ pβ := by ext : 1; rfl
map_smul c p := by ext : 1; rfl
bound := by
refine β¨1, zero_lt_one, fun p β¦ ?_β©
rw [one_mul]
apply ContinuousMultilinearMap.opNorm_le_bound _ (norm_nonneg _) _
intro m
rw [ContinuousMultilinearMap.prod_apply, norm_prod_le_iff]
constructor
Β· exact (p.1.le_opNorm m).trans (mul_le_mul_of_nonneg_right (norm_fst_le p) <| by positivity)
Β· exact (p.2.le_opNorm m).trans (mul_le_mul_of_nonneg_right (norm_snd_le p) <| by positivity)
#align is_bounded_linear_map_prod_multilinear isBoundedLinearMap_prod_multilinear
| Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean | 236 | 254 | theorem isBoundedLinearMap_continuousMultilinearMap_comp_linear (g : G βL[π] E) :
IsBoundedLinearMap π fun f : ContinuousMultilinearMap π (fun _ : ΞΉ => E) F =>
f.compContinuousLinearMap fun _ => g := by |
refine
IsLinearMap.with_bound
β¨fun fβ fβ => by ext; rfl,
fun c f => by ext; rflβ©
(βgβ ^ Fintype.card ΞΉ) fun f => ?_
apply ContinuousMultilinearMap.opNorm_le_bound _ _ _
Β· apply_rules [mul_nonneg, pow_nonneg, norm_nonneg]
intro m
calc
βf (g β m)β β€ βfβ * β i, βg (m i)β := f.le_opNorm _
_ β€ βfβ * β i, βgβ * βm iβ := by
apply mul_le_mul_of_nonneg_left _ (norm_nonneg _)
exact Finset.prod_le_prod (fun i _ => norm_nonneg _) fun i _ => g.le_opNorm _
_ = βgβ ^ Fintype.card ΞΉ * βfβ * β i, βm iβ := by
simp only [Finset.prod_mul_distrib, Finset.prod_const, Finset.card_univ]
ring
| 1,598 |
import Mathlib.Analysis.NormedSpace.Multilinear.Basic
import Mathlib.Analysis.NormedSpace.Units
import Mathlib.Analysis.NormedSpace.OperatorNorm.Completeness
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
#align_import analysis.normed_space.bounded_linear_maps from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
open Topology
open Filter (Tendsto)
open Metric ContinuousLinearMap
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] {G : Type*}
[NormedAddCommGroup G] [NormedSpace π G]
structure IsBoundedLinearMap (π : Type*) [NormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] (f : E β F) extends
IsLinearMap π f : Prop where
bound : β M, 0 < M β§ β x : E, βf xβ β€ M * βxβ
#align is_bounded_linear_map IsBoundedLinearMap
theorem IsLinearMap.with_bound {f : E β F} (hf : IsLinearMap π f) (M : β)
(h : β x : E, βf xβ β€ M * βxβ) : IsBoundedLinearMap π f :=
β¨hf,
by_cases
(fun (this : M β€ 0) =>
β¨1, zero_lt_one, fun x =>
(h x).trans <| mul_le_mul_of_nonneg_right (this.trans zero_le_one) (norm_nonneg x)β©)
fun (this : Β¬M β€ 0) => β¨M, lt_of_not_ge this, hβ©β©
#align is_linear_map.with_bound IsLinearMap.with_bound
theorem ContinuousLinearMap.isBoundedLinearMap (f : E βL[π] F) : IsBoundedLinearMap π f :=
{ f.toLinearMap.isLinear with bound := f.bound }
#align continuous_linear_map.is_bounded_linear_map ContinuousLinearMap.isBoundedLinearMap
section
variable {ΞΉ : Type*} [Fintype ΞΉ]
theorem isBoundedLinearMap_prod_multilinear {E : ΞΉ β Type*} [β i, NormedAddCommGroup (E i)]
[β i, NormedSpace π (E i)] :
IsBoundedLinearMap π fun p : ContinuousMultilinearMap π E F Γ ContinuousMultilinearMap π E G =>
p.1.prod p.2 where
map_add pβ pβ := by ext : 1; rfl
map_smul c p := by ext : 1; rfl
bound := by
refine β¨1, zero_lt_one, fun p β¦ ?_β©
rw [one_mul]
apply ContinuousMultilinearMap.opNorm_le_bound _ (norm_nonneg _) _
intro m
rw [ContinuousMultilinearMap.prod_apply, norm_prod_le_iff]
constructor
Β· exact (p.1.le_opNorm m).trans (mul_le_mul_of_nonneg_right (norm_fst_le p) <| by positivity)
Β· exact (p.2.le_opNorm m).trans (mul_le_mul_of_nonneg_right (norm_snd_le p) <| by positivity)
#align is_bounded_linear_map_prod_multilinear isBoundedLinearMap_prod_multilinear
theorem isBoundedLinearMap_continuousMultilinearMap_comp_linear (g : G βL[π] E) :
IsBoundedLinearMap π fun f : ContinuousMultilinearMap π (fun _ : ΞΉ => E) F =>
f.compContinuousLinearMap fun _ => g := by
refine
IsLinearMap.with_bound
β¨fun fβ fβ => by ext; rfl,
fun c f => by ext; rflβ©
(βgβ ^ Fintype.card ΞΉ) fun f => ?_
apply ContinuousMultilinearMap.opNorm_le_bound _ _ _
Β· apply_rules [mul_nonneg, pow_nonneg, norm_nonneg]
intro m
calc
βf (g β m)β β€ βfβ * β i, βg (m i)β := f.le_opNorm _
_ β€ βfβ * β i, βgβ * βm iβ := by
apply mul_le_mul_of_nonneg_left _ (norm_nonneg _)
exact Finset.prod_le_prod (fun i _ => norm_nonneg _) fun i _ => g.le_opNorm _
_ = βgβ ^ Fintype.card ΞΉ * βfβ * β i, βm iβ := by
simp only [Finset.prod_mul_distrib, Finset.prod_const, Finset.card_univ]
ring
#align is_bounded_linear_map_continuous_multilinear_map_comp_linear isBoundedLinearMap_continuousMultilinearMap_comp_linear
end
section BilinearMap
namespace ContinuousLinearMap
variable {R : Type*}
variable {πβ π' : Type*} [NontriviallyNormedField π'] [NontriviallyNormedField πβ]
variable {M : Type*} [TopologicalSpace M]
variable {Οββ : π β+* πβ}
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace πβ G'] [NormedSpace π' G']
variable [SMulCommClass πβ π' G']
section Semiring
variable [Semiring R] [AddCommMonoid M] [Module R M] {Οββ : R β+* π'}
| Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean | 285 | 286 | theorem map_addβ (f : M βSL[Οββ] F βSL[Οββ] G') (x x' : M) (y : F) :
f (x + x') y = f x y + f x' y := by | rw [f.map_add, add_apply]
| 1,598 |
import Mathlib.Analysis.NormedSpace.Multilinear.Basic
import Mathlib.Analysis.NormedSpace.Units
import Mathlib.Analysis.NormedSpace.OperatorNorm.Completeness
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
#align_import analysis.normed_space.bounded_linear_maps from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
open Topology
open Filter (Tendsto)
open Metric ContinuousLinearMap
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] {G : Type*}
[NormedAddCommGroup G] [NormedSpace π G]
structure IsBoundedLinearMap (π : Type*) [NormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] (f : E β F) extends
IsLinearMap π f : Prop where
bound : β M, 0 < M β§ β x : E, βf xβ β€ M * βxβ
#align is_bounded_linear_map IsBoundedLinearMap
theorem IsLinearMap.with_bound {f : E β F} (hf : IsLinearMap π f) (M : β)
(h : β x : E, βf xβ β€ M * βxβ) : IsBoundedLinearMap π f :=
β¨hf,
by_cases
(fun (this : M β€ 0) =>
β¨1, zero_lt_one, fun x =>
(h x).trans <| mul_le_mul_of_nonneg_right (this.trans zero_le_one) (norm_nonneg x)β©)
fun (this : Β¬M β€ 0) => β¨M, lt_of_not_ge this, hβ©β©
#align is_linear_map.with_bound IsLinearMap.with_bound
theorem ContinuousLinearMap.isBoundedLinearMap (f : E βL[π] F) : IsBoundedLinearMap π f :=
{ f.toLinearMap.isLinear with bound := f.bound }
#align continuous_linear_map.is_bounded_linear_map ContinuousLinearMap.isBoundedLinearMap
section
variable {ΞΉ : Type*} [Fintype ΞΉ]
theorem isBoundedLinearMap_prod_multilinear {E : ΞΉ β Type*} [β i, NormedAddCommGroup (E i)]
[β i, NormedSpace π (E i)] :
IsBoundedLinearMap π fun p : ContinuousMultilinearMap π E F Γ ContinuousMultilinearMap π E G =>
p.1.prod p.2 where
map_add pβ pβ := by ext : 1; rfl
map_smul c p := by ext : 1; rfl
bound := by
refine β¨1, zero_lt_one, fun p β¦ ?_β©
rw [one_mul]
apply ContinuousMultilinearMap.opNorm_le_bound _ (norm_nonneg _) _
intro m
rw [ContinuousMultilinearMap.prod_apply, norm_prod_le_iff]
constructor
Β· exact (p.1.le_opNorm m).trans (mul_le_mul_of_nonneg_right (norm_fst_le p) <| by positivity)
Β· exact (p.2.le_opNorm m).trans (mul_le_mul_of_nonneg_right (norm_snd_le p) <| by positivity)
#align is_bounded_linear_map_prod_multilinear isBoundedLinearMap_prod_multilinear
theorem isBoundedLinearMap_continuousMultilinearMap_comp_linear (g : G βL[π] E) :
IsBoundedLinearMap π fun f : ContinuousMultilinearMap π (fun _ : ΞΉ => E) F =>
f.compContinuousLinearMap fun _ => g := by
refine
IsLinearMap.with_bound
β¨fun fβ fβ => by ext; rfl,
fun c f => by ext; rflβ©
(βgβ ^ Fintype.card ΞΉ) fun f => ?_
apply ContinuousMultilinearMap.opNorm_le_bound _ _ _
Β· apply_rules [mul_nonneg, pow_nonneg, norm_nonneg]
intro m
calc
βf (g β m)β β€ βfβ * β i, βg (m i)β := f.le_opNorm _
_ β€ βfβ * β i, βgβ * βm iβ := by
apply mul_le_mul_of_nonneg_left _ (norm_nonneg _)
exact Finset.prod_le_prod (fun i _ => norm_nonneg _) fun i _ => g.le_opNorm _
_ = βgβ ^ Fintype.card ΞΉ * βfβ * β i, βm iβ := by
simp only [Finset.prod_mul_distrib, Finset.prod_const, Finset.card_univ]
ring
#align is_bounded_linear_map_continuous_multilinear_map_comp_linear isBoundedLinearMap_continuousMultilinearMap_comp_linear
end
section BilinearMap
namespace ContinuousLinearMap
variable {R : Type*}
variable {πβ π' : Type*} [NontriviallyNormedField π'] [NontriviallyNormedField πβ]
variable {M : Type*} [TopologicalSpace M]
variable {Οββ : π β+* πβ}
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace πβ G'] [NormedSpace π' G']
variable [SMulCommClass πβ π' G']
section Semiring
variable [Semiring R] [AddCommMonoid M] [Module R M] {Οββ : R β+* π'}
theorem map_addβ (f : M βSL[Οββ] F βSL[Οββ] G') (x x' : M) (y : F) :
f (x + x') y = f x y + f x' y := by rw [f.map_add, add_apply]
#align continuous_linear_map.map_addβ ContinuousLinearMap.map_addβ
| Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean | 289 | 290 | theorem map_zeroβ (f : M βSL[Οββ] F βSL[Οββ] G') (y : F) : f 0 y = 0 := by |
rw [f.map_zero, zero_apply]
| 1,598 |
import Mathlib.Analysis.NormedSpace.Multilinear.Basic
import Mathlib.Analysis.NormedSpace.Units
import Mathlib.Analysis.NormedSpace.OperatorNorm.Completeness
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
#align_import analysis.normed_space.bounded_linear_maps from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
open Topology
open Filter (Tendsto)
open Metric ContinuousLinearMap
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] {G : Type*}
[NormedAddCommGroup G] [NormedSpace π G]
structure IsBoundedLinearMap (π : Type*) [NormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] (f : E β F) extends
IsLinearMap π f : Prop where
bound : β M, 0 < M β§ β x : E, βf xβ β€ M * βxβ
#align is_bounded_linear_map IsBoundedLinearMap
theorem IsLinearMap.with_bound {f : E β F} (hf : IsLinearMap π f) (M : β)
(h : β x : E, βf xβ β€ M * βxβ) : IsBoundedLinearMap π f :=
β¨hf,
by_cases
(fun (this : M β€ 0) =>
β¨1, zero_lt_one, fun x =>
(h x).trans <| mul_le_mul_of_nonneg_right (this.trans zero_le_one) (norm_nonneg x)β©)
fun (this : Β¬M β€ 0) => β¨M, lt_of_not_ge this, hβ©β©
#align is_linear_map.with_bound IsLinearMap.with_bound
theorem ContinuousLinearMap.isBoundedLinearMap (f : E βL[π] F) : IsBoundedLinearMap π f :=
{ f.toLinearMap.isLinear with bound := f.bound }
#align continuous_linear_map.is_bounded_linear_map ContinuousLinearMap.isBoundedLinearMap
section
variable {ΞΉ : Type*} [Fintype ΞΉ]
theorem isBoundedLinearMap_prod_multilinear {E : ΞΉ β Type*} [β i, NormedAddCommGroup (E i)]
[β i, NormedSpace π (E i)] :
IsBoundedLinearMap π fun p : ContinuousMultilinearMap π E F Γ ContinuousMultilinearMap π E G =>
p.1.prod p.2 where
map_add pβ pβ := by ext : 1; rfl
map_smul c p := by ext : 1; rfl
bound := by
refine β¨1, zero_lt_one, fun p β¦ ?_β©
rw [one_mul]
apply ContinuousMultilinearMap.opNorm_le_bound _ (norm_nonneg _) _
intro m
rw [ContinuousMultilinearMap.prod_apply, norm_prod_le_iff]
constructor
Β· exact (p.1.le_opNorm m).trans (mul_le_mul_of_nonneg_right (norm_fst_le p) <| by positivity)
Β· exact (p.2.le_opNorm m).trans (mul_le_mul_of_nonneg_right (norm_snd_le p) <| by positivity)
#align is_bounded_linear_map_prod_multilinear isBoundedLinearMap_prod_multilinear
theorem isBoundedLinearMap_continuousMultilinearMap_comp_linear (g : G βL[π] E) :
IsBoundedLinearMap π fun f : ContinuousMultilinearMap π (fun _ : ΞΉ => E) F =>
f.compContinuousLinearMap fun _ => g := by
refine
IsLinearMap.with_bound
β¨fun fβ fβ => by ext; rfl,
fun c f => by ext; rflβ©
(βgβ ^ Fintype.card ΞΉ) fun f => ?_
apply ContinuousMultilinearMap.opNorm_le_bound _ _ _
Β· apply_rules [mul_nonneg, pow_nonneg, norm_nonneg]
intro m
calc
βf (g β m)β β€ βfβ * β i, βg (m i)β := f.le_opNorm _
_ β€ βfβ * β i, βgβ * βm iβ := by
apply mul_le_mul_of_nonneg_left _ (norm_nonneg _)
exact Finset.prod_le_prod (fun i _ => norm_nonneg _) fun i _ => g.le_opNorm _
_ = βgβ ^ Fintype.card ΞΉ * βfβ * β i, βm iβ := by
simp only [Finset.prod_mul_distrib, Finset.prod_const, Finset.card_univ]
ring
#align is_bounded_linear_map_continuous_multilinear_map_comp_linear isBoundedLinearMap_continuousMultilinearMap_comp_linear
end
section BilinearMap
namespace ContinuousLinearMap
variable {R : Type*}
variable {πβ π' : Type*} [NontriviallyNormedField π'] [NontriviallyNormedField πβ]
variable {M : Type*} [TopologicalSpace M]
variable {Οββ : π β+* πβ}
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace πβ G'] [NormedSpace π' G']
variable [SMulCommClass πβ π' G']
section Semiring
variable [Semiring R] [AddCommMonoid M] [Module R M] {Οββ : R β+* π'}
theorem map_addβ (f : M βSL[Οββ] F βSL[Οββ] G') (x x' : M) (y : F) :
f (x + x') y = f x y + f x' y := by rw [f.map_add, add_apply]
#align continuous_linear_map.map_addβ ContinuousLinearMap.map_addβ
theorem map_zeroβ (f : M βSL[Οββ] F βSL[Οββ] G') (y : F) : f 0 y = 0 := by
rw [f.map_zero, zero_apply]
#align continuous_linear_map.map_zeroβ ContinuousLinearMap.map_zeroβ
| Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean | 293 | 294 | theorem map_smulβββ (f : M βSL[Οββ] F βSL[Οββ] G') (c : R) (x : M) (y : F) :
f (c β’ x) y = Οββ c β’ f x y := by | rw [f.map_smulββ, smul_apply]
| 1,598 |
import Mathlib.Analysis.NormedSpace.Multilinear.Basic
import Mathlib.Analysis.NormedSpace.Units
import Mathlib.Analysis.NormedSpace.OperatorNorm.Completeness
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
#align_import analysis.normed_space.bounded_linear_maps from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
open Topology
open Filter (Tendsto)
open Metric ContinuousLinearMap
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] {G : Type*}
[NormedAddCommGroup G] [NormedSpace π G]
structure IsBoundedLinearMap (π : Type*) [NormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] (f : E β F) extends
IsLinearMap π f : Prop where
bound : β M, 0 < M β§ β x : E, βf xβ β€ M * βxβ
#align is_bounded_linear_map IsBoundedLinearMap
theorem IsLinearMap.with_bound {f : E β F} (hf : IsLinearMap π f) (M : β)
(h : β x : E, βf xβ β€ M * βxβ) : IsBoundedLinearMap π f :=
β¨hf,
by_cases
(fun (this : M β€ 0) =>
β¨1, zero_lt_one, fun x =>
(h x).trans <| mul_le_mul_of_nonneg_right (this.trans zero_le_one) (norm_nonneg x)β©)
fun (this : Β¬M β€ 0) => β¨M, lt_of_not_ge this, hβ©β©
#align is_linear_map.with_bound IsLinearMap.with_bound
theorem ContinuousLinearMap.isBoundedLinearMap (f : E βL[π] F) : IsBoundedLinearMap π f :=
{ f.toLinearMap.isLinear with bound := f.bound }
#align continuous_linear_map.is_bounded_linear_map ContinuousLinearMap.isBoundedLinearMap
section
variable {ΞΉ : Type*} [Fintype ΞΉ]
theorem isBoundedLinearMap_prod_multilinear {E : ΞΉ β Type*} [β i, NormedAddCommGroup (E i)]
[β i, NormedSpace π (E i)] :
IsBoundedLinearMap π fun p : ContinuousMultilinearMap π E F Γ ContinuousMultilinearMap π E G =>
p.1.prod p.2 where
map_add pβ pβ := by ext : 1; rfl
map_smul c p := by ext : 1; rfl
bound := by
refine β¨1, zero_lt_one, fun p β¦ ?_β©
rw [one_mul]
apply ContinuousMultilinearMap.opNorm_le_bound _ (norm_nonneg _) _
intro m
rw [ContinuousMultilinearMap.prod_apply, norm_prod_le_iff]
constructor
Β· exact (p.1.le_opNorm m).trans (mul_le_mul_of_nonneg_right (norm_fst_le p) <| by positivity)
Β· exact (p.2.le_opNorm m).trans (mul_le_mul_of_nonneg_right (norm_snd_le p) <| by positivity)
#align is_bounded_linear_map_prod_multilinear isBoundedLinearMap_prod_multilinear
theorem isBoundedLinearMap_continuousMultilinearMap_comp_linear (g : G βL[π] E) :
IsBoundedLinearMap π fun f : ContinuousMultilinearMap π (fun _ : ΞΉ => E) F =>
f.compContinuousLinearMap fun _ => g := by
refine
IsLinearMap.with_bound
β¨fun fβ fβ => by ext; rfl,
fun c f => by ext; rflβ©
(βgβ ^ Fintype.card ΞΉ) fun f => ?_
apply ContinuousMultilinearMap.opNorm_le_bound _ _ _
Β· apply_rules [mul_nonneg, pow_nonneg, norm_nonneg]
intro m
calc
βf (g β m)β β€ βfβ * β i, βg (m i)β := f.le_opNorm _
_ β€ βfβ * β i, βgβ * βm iβ := by
apply mul_le_mul_of_nonneg_left _ (norm_nonneg _)
exact Finset.prod_le_prod (fun i _ => norm_nonneg _) fun i _ => g.le_opNorm _
_ = βgβ ^ Fintype.card ΞΉ * βfβ * β i, βm iβ := by
simp only [Finset.prod_mul_distrib, Finset.prod_const, Finset.card_univ]
ring
#align is_bounded_linear_map_continuous_multilinear_map_comp_linear isBoundedLinearMap_continuousMultilinearMap_comp_linear
end
section BilinearMap
namespace ContinuousLinearMap
variable {R : Type*}
variable {πβ π' : Type*} [NontriviallyNormedField π'] [NontriviallyNormedField πβ]
variable {M : Type*} [TopologicalSpace M]
variable {Οββ : π β+* πβ}
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace πβ G'] [NormedSpace π' G']
variable [SMulCommClass πβ π' G']
section Ring
variable [Ring R] [AddCommGroup M] [Module R M] {Οββ : R β+* π'}
| Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean | 303 | 304 | theorem map_subβ (f : M βSL[Οββ] F βSL[Οββ] G') (x x' : M) (y : F) :
f (x - x') y = f x y - f x' y := by | rw [f.map_sub, sub_apply]
| 1,598 |
import Mathlib.Analysis.NormedSpace.Multilinear.Basic
import Mathlib.Analysis.NormedSpace.Units
import Mathlib.Analysis.NormedSpace.OperatorNorm.Completeness
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
#align_import analysis.normed_space.bounded_linear_maps from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
open Topology
open Filter (Tendsto)
open Metric ContinuousLinearMap
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] {G : Type*}
[NormedAddCommGroup G] [NormedSpace π G]
structure IsBoundedLinearMap (π : Type*) [NormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] (f : E β F) extends
IsLinearMap π f : Prop where
bound : β M, 0 < M β§ β x : E, βf xβ β€ M * βxβ
#align is_bounded_linear_map IsBoundedLinearMap
theorem IsLinearMap.with_bound {f : E β F} (hf : IsLinearMap π f) (M : β)
(h : β x : E, βf xβ β€ M * βxβ) : IsBoundedLinearMap π f :=
β¨hf,
by_cases
(fun (this : M β€ 0) =>
β¨1, zero_lt_one, fun x =>
(h x).trans <| mul_le_mul_of_nonneg_right (this.trans zero_le_one) (norm_nonneg x)β©)
fun (this : Β¬M β€ 0) => β¨M, lt_of_not_ge this, hβ©β©
#align is_linear_map.with_bound IsLinearMap.with_bound
theorem ContinuousLinearMap.isBoundedLinearMap (f : E βL[π] F) : IsBoundedLinearMap π f :=
{ f.toLinearMap.isLinear with bound := f.bound }
#align continuous_linear_map.is_bounded_linear_map ContinuousLinearMap.isBoundedLinearMap
section
variable {ΞΉ : Type*} [Fintype ΞΉ]
theorem isBoundedLinearMap_prod_multilinear {E : ΞΉ β Type*} [β i, NormedAddCommGroup (E i)]
[β i, NormedSpace π (E i)] :
IsBoundedLinearMap π fun p : ContinuousMultilinearMap π E F Γ ContinuousMultilinearMap π E G =>
p.1.prod p.2 where
map_add pβ pβ := by ext : 1; rfl
map_smul c p := by ext : 1; rfl
bound := by
refine β¨1, zero_lt_one, fun p β¦ ?_β©
rw [one_mul]
apply ContinuousMultilinearMap.opNorm_le_bound _ (norm_nonneg _) _
intro m
rw [ContinuousMultilinearMap.prod_apply, norm_prod_le_iff]
constructor
Β· exact (p.1.le_opNorm m).trans (mul_le_mul_of_nonneg_right (norm_fst_le p) <| by positivity)
Β· exact (p.2.le_opNorm m).trans (mul_le_mul_of_nonneg_right (norm_snd_le p) <| by positivity)
#align is_bounded_linear_map_prod_multilinear isBoundedLinearMap_prod_multilinear
theorem isBoundedLinearMap_continuousMultilinearMap_comp_linear (g : G βL[π] E) :
IsBoundedLinearMap π fun f : ContinuousMultilinearMap π (fun _ : ΞΉ => E) F =>
f.compContinuousLinearMap fun _ => g := by
refine
IsLinearMap.with_bound
β¨fun fβ fβ => by ext; rfl,
fun c f => by ext; rflβ©
(βgβ ^ Fintype.card ΞΉ) fun f => ?_
apply ContinuousMultilinearMap.opNorm_le_bound _ _ _
Β· apply_rules [mul_nonneg, pow_nonneg, norm_nonneg]
intro m
calc
βf (g β m)β β€ βfβ * β i, βg (m i)β := f.le_opNorm _
_ β€ βfβ * β i, βgβ * βm iβ := by
apply mul_le_mul_of_nonneg_left _ (norm_nonneg _)
exact Finset.prod_le_prod (fun i _ => norm_nonneg _) fun i _ => g.le_opNorm _
_ = βgβ ^ Fintype.card ΞΉ * βfβ * β i, βm iβ := by
simp only [Finset.prod_mul_distrib, Finset.prod_const, Finset.card_univ]
ring
#align is_bounded_linear_map_continuous_multilinear_map_comp_linear isBoundedLinearMap_continuousMultilinearMap_comp_linear
end
section BilinearMap
namespace ContinuousLinearMap
variable {R : Type*}
variable {πβ π' : Type*} [NontriviallyNormedField π'] [NontriviallyNormedField πβ]
variable {M : Type*} [TopologicalSpace M]
variable {Οββ : π β+* πβ}
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace πβ G'] [NormedSpace π' G']
variable [SMulCommClass πβ π' G']
section Ring
variable [Ring R] [AddCommGroup M] [Module R M] {Οββ : R β+* π'}
theorem map_subβ (f : M βSL[Οββ] F βSL[Οββ] G') (x x' : M) (y : F) :
f (x - x') y = f x y - f x' y := by rw [f.map_sub, sub_apply]
#align continuous_linear_map.map_subβ ContinuousLinearMap.map_subβ
| Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean | 307 | 308 | theorem map_negβ (f : M βSL[Οββ] F βSL[Οββ] G') (x : M) (y : F) : f (-x) y = -f x y := by |
rw [f.map_neg, neg_apply]
| 1,598 |
import Mathlib.Analysis.NormedSpace.Multilinear.Basic
import Mathlib.Analysis.NormedSpace.Units
import Mathlib.Analysis.NormedSpace.OperatorNorm.Completeness
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
#align_import analysis.normed_space.bounded_linear_maps from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
open Topology
open Filter (Tendsto)
open Metric ContinuousLinearMap
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] {G : Type*}
[NormedAddCommGroup G] [NormedSpace π G]
structure IsBoundedLinearMap (π : Type*) [NormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F] (f : E β F) extends
IsLinearMap π f : Prop where
bound : β M, 0 < M β§ β x : E, βf xβ β€ M * βxβ
#align is_bounded_linear_map IsBoundedLinearMap
theorem IsLinearMap.with_bound {f : E β F} (hf : IsLinearMap π f) (M : β)
(h : β x : E, βf xβ β€ M * βxβ) : IsBoundedLinearMap π f :=
β¨hf,
by_cases
(fun (this : M β€ 0) =>
β¨1, zero_lt_one, fun x =>
(h x).trans <| mul_le_mul_of_nonneg_right (this.trans zero_le_one) (norm_nonneg x)β©)
fun (this : Β¬M β€ 0) => β¨M, lt_of_not_ge this, hβ©β©
#align is_linear_map.with_bound IsLinearMap.with_bound
theorem ContinuousLinearMap.isBoundedLinearMap (f : E βL[π] F) : IsBoundedLinearMap π f :=
{ f.toLinearMap.isLinear with bound := f.bound }
#align continuous_linear_map.is_bounded_linear_map ContinuousLinearMap.isBoundedLinearMap
section
variable {ΞΉ : Type*} [Fintype ΞΉ]
theorem isBoundedLinearMap_prod_multilinear {E : ΞΉ β Type*} [β i, NormedAddCommGroup (E i)]
[β i, NormedSpace π (E i)] :
IsBoundedLinearMap π fun p : ContinuousMultilinearMap π E F Γ ContinuousMultilinearMap π E G =>
p.1.prod p.2 where
map_add pβ pβ := by ext : 1; rfl
map_smul c p := by ext : 1; rfl
bound := by
refine β¨1, zero_lt_one, fun p β¦ ?_β©
rw [one_mul]
apply ContinuousMultilinearMap.opNorm_le_bound _ (norm_nonneg _) _
intro m
rw [ContinuousMultilinearMap.prod_apply, norm_prod_le_iff]
constructor
Β· exact (p.1.le_opNorm m).trans (mul_le_mul_of_nonneg_right (norm_fst_le p) <| by positivity)
Β· exact (p.2.le_opNorm m).trans (mul_le_mul_of_nonneg_right (norm_snd_le p) <| by positivity)
#align is_bounded_linear_map_prod_multilinear isBoundedLinearMap_prod_multilinear
theorem isBoundedLinearMap_continuousMultilinearMap_comp_linear (g : G βL[π] E) :
IsBoundedLinearMap π fun f : ContinuousMultilinearMap π (fun _ : ΞΉ => E) F =>
f.compContinuousLinearMap fun _ => g := by
refine
IsLinearMap.with_bound
β¨fun fβ fβ => by ext; rfl,
fun c f => by ext; rflβ©
(βgβ ^ Fintype.card ΞΉ) fun f => ?_
apply ContinuousMultilinearMap.opNorm_le_bound _ _ _
Β· apply_rules [mul_nonneg, pow_nonneg, norm_nonneg]
intro m
calc
βf (g β m)β β€ βfβ * β i, βg (m i)β := f.le_opNorm _
_ β€ βfβ * β i, βgβ * βm iβ := by
apply mul_le_mul_of_nonneg_left _ (norm_nonneg _)
exact Finset.prod_le_prod (fun i _ => norm_nonneg _) fun i _ => g.le_opNorm _
_ = βgβ ^ Fintype.card ΞΉ * βfβ * β i, βm iβ := by
simp only [Finset.prod_mul_distrib, Finset.prod_const, Finset.card_univ]
ring
#align is_bounded_linear_map_continuous_multilinear_map_comp_linear isBoundedLinearMap_continuousMultilinearMap_comp_linear
end
section BilinearMap
namespace ContinuousLinearMap
variable {R : Type*}
variable {πβ π' : Type*} [NontriviallyNormedField π'] [NontriviallyNormedField πβ]
variable {M : Type*} [TopologicalSpace M]
variable {Οββ : π β+* πβ}
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace πβ G'] [NormedSpace π' G']
variable [SMulCommClass πβ π' G']
| Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean | 313 | 314 | theorem map_smulβ (f : E βL[π] F βL[π] G) (c : π) (x : E) (y : F) : f (c β’ x) y = c β’ f x y := by |
rw [f.map_smul, smul_apply]
| 1,598 |
import Mathlib.Analysis.Calculus.FDeriv.Basic
import Mathlib.Analysis.NormedSpace.BoundedLinearMaps
#align_import analysis.calculus.fderiv.linear from "leanprover-community/mathlib"@"e3fb84046afd187b710170887195d50bada934ee"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Filter Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
section ContinuousLinearMap
@[fun_prop]
protected theorem ContinuousLinearMap.hasStrictFDerivAt {x : E} : HasStrictFDerivAt e e x :=
(isLittleO_zero _ _).congr_left fun x => by simp only [e.map_sub, sub_self]
#align continuous_linear_map.has_strict_fderiv_at ContinuousLinearMap.hasStrictFDerivAt
protected theorem ContinuousLinearMap.hasFDerivAtFilter : HasFDerivAtFilter e e x L :=
.of_isLittleO <| (isLittleO_zero _ _).congr_left fun x => by simp only [e.map_sub, sub_self]
#align continuous_linear_map.has_fderiv_at_filter ContinuousLinearMap.hasFDerivAtFilter
@[fun_prop]
protected theorem ContinuousLinearMap.hasFDerivWithinAt : HasFDerivWithinAt e e s x :=
e.hasFDerivAtFilter
#align continuous_linear_map.has_fderiv_within_at ContinuousLinearMap.hasFDerivWithinAt
@[fun_prop]
protected theorem ContinuousLinearMap.hasFDerivAt : HasFDerivAt e e x :=
e.hasFDerivAtFilter
#align continuous_linear_map.has_fderiv_at ContinuousLinearMap.hasFDerivAt
@[simp, fun_prop]
protected theorem ContinuousLinearMap.differentiableAt : DifferentiableAt π e x :=
e.hasFDerivAt.differentiableAt
#align continuous_linear_map.differentiable_at ContinuousLinearMap.differentiableAt
@[fun_prop]
protected theorem ContinuousLinearMap.differentiableWithinAt : DifferentiableWithinAt π e s x :=
e.differentiableAt.differentiableWithinAt
#align continuous_linear_map.differentiable_within_at ContinuousLinearMap.differentiableWithinAt
@[simp]
protected theorem ContinuousLinearMap.fderiv : fderiv π e x = e :=
e.hasFDerivAt.fderiv
#align continuous_linear_map.fderiv ContinuousLinearMap.fderiv
protected theorem ContinuousLinearMap.fderivWithin (hxs : UniqueDiffWithinAt π s x) :
fderivWithin π e s x = e := by
rw [DifferentiableAt.fderivWithin e.differentiableAt hxs]
exact e.fderiv
#align continuous_linear_map.fderiv_within ContinuousLinearMap.fderivWithin
@[simp, fun_prop]
protected theorem ContinuousLinearMap.differentiable : Differentiable π e := fun _ =>
e.differentiableAt
#align continuous_linear_map.differentiable ContinuousLinearMap.differentiable
@[fun_prop]
protected theorem ContinuousLinearMap.differentiableOn : DifferentiableOn π e s :=
e.differentiable.differentiableOn
#align continuous_linear_map.differentiable_on ContinuousLinearMap.differentiableOn
theorem IsBoundedLinearMap.hasFDerivAtFilter (h : IsBoundedLinearMap π f) :
HasFDerivAtFilter f h.toContinuousLinearMap x L :=
h.toContinuousLinearMap.hasFDerivAtFilter
#align is_bounded_linear_map.has_fderiv_at_filter IsBoundedLinearMap.hasFDerivAtFilter
@[fun_prop]
theorem IsBoundedLinearMap.hasFDerivWithinAt (h : IsBoundedLinearMap π f) :
HasFDerivWithinAt f h.toContinuousLinearMap s x :=
h.hasFDerivAtFilter
#align is_bounded_linear_map.has_fderiv_within_at IsBoundedLinearMap.hasFDerivWithinAt
@[fun_prop]
theorem IsBoundedLinearMap.hasFDerivAt (h : IsBoundedLinearMap π f) :
HasFDerivAt f h.toContinuousLinearMap x :=
h.hasFDerivAtFilter
#align is_bounded_linear_map.has_fderiv_at IsBoundedLinearMap.hasFDerivAt
@[fun_prop]
theorem IsBoundedLinearMap.differentiableAt (h : IsBoundedLinearMap π f) : DifferentiableAt π f x :=
h.hasFDerivAt.differentiableAt
#align is_bounded_linear_map.differentiable_at IsBoundedLinearMap.differentiableAt
@[fun_prop]
theorem IsBoundedLinearMap.differentiableWithinAt (h : IsBoundedLinearMap π f) :
DifferentiableWithinAt π f s x :=
h.differentiableAt.differentiableWithinAt
#align is_bounded_linear_map.differentiable_within_at IsBoundedLinearMap.differentiableWithinAt
theorem IsBoundedLinearMap.fderiv (h : IsBoundedLinearMap π f) :
fderiv π f x = h.toContinuousLinearMap :=
HasFDerivAt.fderiv h.hasFDerivAt
#align is_bounded_linear_map.fderiv IsBoundedLinearMap.fderiv
| Mathlib/Analysis/Calculus/FDeriv/Linear.lean | 136 | 139 | theorem IsBoundedLinearMap.fderivWithin (h : IsBoundedLinearMap π f)
(hxs : UniqueDiffWithinAt π s x) : fderivWithin π f s x = h.toContinuousLinearMap := by |
rw [DifferentiableAt.fderivWithin h.differentiableAt hxs]
exact h.fderiv
| 1,599 |
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.add from "leanprover-community/mathlib"@"e3fb84046afd187b710170887195d50bada934ee"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Filter Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
section Sum
variable {ΞΉ : Type*} {u : Finset ΞΉ} {A : ΞΉ β E β F} {A' : ΞΉ β E βL[π] F}
@[fun_prop]
| Mathlib/Analysis/Calculus/FDeriv/Add.lean | 346 | 350 | theorem HasStrictFDerivAt.sum (h : β i β u, HasStrictFDerivAt (A i) (A' i) x) :
HasStrictFDerivAt (fun y => β i β u, A i y) (β i β u, A' i) x := by |
dsimp [HasStrictFDerivAt] at *
convert IsLittleO.sum h
simp [Finset.sum_sub_distrib, ContinuousLinearMap.sum_apply]
| 1,600 |
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.add from "leanprover-community/mathlib"@"e3fb84046afd187b710170887195d50bada934ee"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Filter Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
section Sum
variable {ΞΉ : Type*} {u : Finset ΞΉ} {A : ΞΉ β E β F} {A' : ΞΉ β E βL[π] F}
@[fun_prop]
theorem HasStrictFDerivAt.sum (h : β i β u, HasStrictFDerivAt (A i) (A' i) x) :
HasStrictFDerivAt (fun y => β i β u, A i y) (β i β u, A' i) x := by
dsimp [HasStrictFDerivAt] at *
convert IsLittleO.sum h
simp [Finset.sum_sub_distrib, ContinuousLinearMap.sum_apply]
#align has_strict_fderiv_at.sum HasStrictFDerivAt.sum
| Mathlib/Analysis/Calculus/FDeriv/Add.lean | 353 | 357 | theorem HasFDerivAtFilter.sum (h : β i β u, HasFDerivAtFilter (A i) (A' i) x L) :
HasFDerivAtFilter (fun y => β i β u, A i y) (β i β u, A' i) x L := by |
simp only [hasFDerivAtFilter_iff_isLittleO] at *
convert IsLittleO.sum h
simp [ContinuousLinearMap.sum_apply]
| 1,600 |
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.add from "leanprover-community/mathlib"@"e3fb84046afd187b710170887195d50bada934ee"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Filter Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
section Neg
@[fun_prop]
theorem HasStrictFDerivAt.neg (h : HasStrictFDerivAt f f' x) :
HasStrictFDerivAt (fun x => -f x) (-f') x :=
(-1 : F βL[π] F).hasStrictFDerivAt.comp x h
#align has_strict_fderiv_at.neg HasStrictFDerivAt.neg
theorem HasFDerivAtFilter.neg (h : HasFDerivAtFilter f f' x L) :
HasFDerivAtFilter (fun x => -f x) (-f') x L :=
(-1 : F βL[π] F).hasFDerivAtFilter.comp x h tendsto_map
#align has_fderiv_at_filter.neg HasFDerivAtFilter.neg
@[fun_prop]
nonrec theorem HasFDerivWithinAt.neg (h : HasFDerivWithinAt f f' s x) :
HasFDerivWithinAt (fun x => -f x) (-f') s x :=
h.neg
#align has_fderiv_within_at.neg HasFDerivWithinAt.neg
@[fun_prop]
nonrec theorem HasFDerivAt.neg (h : HasFDerivAt f f' x) : HasFDerivAt (fun x => -f x) (-f') x :=
h.neg
#align has_fderiv_at.neg HasFDerivAt.neg
@[fun_prop]
theorem DifferentiableWithinAt.neg (h : DifferentiableWithinAt π f s x) :
DifferentiableWithinAt π (fun y => -f y) s x :=
h.hasFDerivWithinAt.neg.differentiableWithinAt
#align differentiable_within_at.neg DifferentiableWithinAt.neg
@[simp]
theorem differentiableWithinAt_neg_iff :
DifferentiableWithinAt π (fun y => -f y) s x β DifferentiableWithinAt π f s x :=
β¨fun h => by simpa only [neg_neg] using h.neg, fun h => h.negβ©
#align differentiable_within_at_neg_iff differentiableWithinAt_neg_iff
@[fun_prop]
theorem DifferentiableAt.neg (h : DifferentiableAt π f x) : DifferentiableAt π (fun y => -f y) x :=
h.hasFDerivAt.neg.differentiableAt
#align differentiable_at.neg DifferentiableAt.neg
@[simp]
theorem differentiableAt_neg_iff : DifferentiableAt π (fun y => -f y) x β DifferentiableAt π f x :=
β¨fun h => by simpa only [neg_neg] using h.neg, fun h => h.negβ©
#align differentiable_at_neg_iff differentiableAt_neg_iff
@[fun_prop]
theorem DifferentiableOn.neg (h : DifferentiableOn π f s) : DifferentiableOn π (fun y => -f y) s :=
fun x hx => (h x hx).neg
#align differentiable_on.neg DifferentiableOn.neg
@[simp]
theorem differentiableOn_neg_iff : DifferentiableOn π (fun y => -f y) s β DifferentiableOn π f s :=
β¨fun h => by simpa only [neg_neg] using h.neg, fun h => h.negβ©
#align differentiable_on_neg_iff differentiableOn_neg_iff
@[fun_prop]
theorem Differentiable.neg (h : Differentiable π f) : Differentiable π fun y => -f y := fun x =>
(h x).neg
#align differentiable.neg Differentiable.neg
@[simp]
theorem differentiable_neg_iff : (Differentiable π fun y => -f y) β Differentiable π f :=
β¨fun h => by simpa only [neg_neg] using h.neg, fun h => h.negβ©
#align differentiable_neg_iff differentiable_neg_iff
theorem fderivWithin_neg (hxs : UniqueDiffWithinAt π s x) :
fderivWithin π (fun y => -f y) s x = -fderivWithin π f s x :=
if h : DifferentiableWithinAt π f s x then h.hasFDerivWithinAt.neg.fderivWithin hxs
else by
rw [fderivWithin_zero_of_not_differentiableWithinAt h,
fderivWithin_zero_of_not_differentiableWithinAt, neg_zero]
simpa
#align fderiv_within_neg fderivWithin_neg
@[simp]
| Mathlib/Analysis/Calculus/FDeriv/Add.lean | 488 | 489 | theorem fderiv_neg : fderiv π (fun y => -f y) x = -fderiv π f x := by |
simp only [β fderivWithin_univ, fderivWithin_neg uniqueDiffWithinAt_univ]
| 1,600 |
import Mathlib.Analysis.Calculus.FDeriv.Add
variable {π ΞΉ : Type*} [DecidableEq ΞΉ] [Fintype ΞΉ] [NontriviallyNormedField π]
variable {E : ΞΉ β Type*} [β i, NormedAddCommGroup (E i)] [β i, NormedSpace π (E i)]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
@[fun_prop]
| Mathlib/Analysis/Calculus/FDeriv/Pi.lean | 17 | 29 | theorem hasFDerivAt_update (x : β i, E i) {i : ΞΉ} (y : E i) :
HasFDerivAt (Function.update x i) (.pi (Pi.single i (.id π (E i)))) y := by |
set l := (ContinuousLinearMap.pi (Pi.single i (.id π (E i))))
have update_eq : Function.update x i = (fun _ β¦ x) + l β (Β· - x i) := by
ext t j
dsimp [l, Pi.single, Function.update]
split_ifs with hji
Β· subst hji
simp
Β· simp
rw [update_eq]
convert (hasFDerivAt_const _ _).add (l.hasFDerivAt.comp y (hasFDerivAt_sub_const (x i)))
rw [zero_add, ContinuousLinearMap.comp_id]
| 1,601 |
import Mathlib.Analysis.NormedSpace.ConformalLinearMap
import Mathlib.Analysis.Calculus.FDeriv.Add
#align_import analysis.calculus.conformal.normed_space from "leanprover-community/mathlib"@"e3fb84046afd187b710170887195d50bada934ee"
noncomputable section
variable {X Y Z : Type*} [NormedAddCommGroup X] [NormedAddCommGroup Y] [NormedAddCommGroup Z]
[NormedSpace β X] [NormedSpace β Y] [NormedSpace β Z]
section LocConformality
open LinearIsometry ContinuousLinearMap
def ConformalAt (f : X β Y) (x : X) :=
β f' : X βL[β] Y, HasFDerivAt f f' x β§ IsConformalMap f'
#align conformal_at ConformalAt
theorem conformalAt_id (x : X) : ConformalAt _root_.id x :=
β¨id β X, hasFDerivAt_id _, isConformalMap_idβ©
#align conformal_at_id conformalAt_id
theorem conformalAt_const_smul {c : β} (h : c β 0) (x : X) : ConformalAt (fun x' : X => c β’ x') x :=
β¨c β’ ContinuousLinearMap.id β X, (hasFDerivAt_id x).const_smul c, isConformalMap_const_smul hβ©
#align conformal_at_const_smul conformalAt_const_smul
@[nontriviality]
theorem Subsingleton.conformalAt [Subsingleton X] (f : X β Y) (x : X) : ConformalAt f x :=
β¨0, hasFDerivAt_of_subsingleton _ _, isConformalMap_of_subsingleton _β©
#align subsingleton.conformal_at Subsingleton.conformalAt
| Mathlib/Analysis/Calculus/Conformal/NormedSpace.lean | 73 | 82 | theorem conformalAt_iff_isConformalMap_fderiv {f : X β Y} {x : X} :
ConformalAt f x β IsConformalMap (fderiv β f x) := by |
constructor
Β· rintro β¨f', hf, hf'β©
rwa [hf.fderiv]
Β· intro H
by_cases h : DifferentiableAt β f x
Β· exact β¨fderiv β f x, h.hasFDerivAt, Hβ©
Β· nontriviality X
exact absurd (fderiv_zero_of_not_differentiableAt h) H.ne_zero
| 1,602 |
import Mathlib.Analysis.NormedSpace.ConformalLinearMap
import Mathlib.Analysis.Calculus.FDeriv.Add
#align_import analysis.calculus.conformal.normed_space from "leanprover-community/mathlib"@"e3fb84046afd187b710170887195d50bada934ee"
noncomputable section
variable {X Y Z : Type*} [NormedAddCommGroup X] [NormedAddCommGroup Y] [NormedAddCommGroup Z]
[NormedSpace β X] [NormedSpace β Y] [NormedSpace β Z]
section LocConformality
open LinearIsometry ContinuousLinearMap
def ConformalAt (f : X β Y) (x : X) :=
β f' : X βL[β] Y, HasFDerivAt f f' x β§ IsConformalMap f'
#align conformal_at ConformalAt
theorem conformalAt_id (x : X) : ConformalAt _root_.id x :=
β¨id β X, hasFDerivAt_id _, isConformalMap_idβ©
#align conformal_at_id conformalAt_id
theorem conformalAt_const_smul {c : β} (h : c β 0) (x : X) : ConformalAt (fun x' : X => c β’ x') x :=
β¨c β’ ContinuousLinearMap.id β X, (hasFDerivAt_id x).const_smul c, isConformalMap_const_smul hβ©
#align conformal_at_const_smul conformalAt_const_smul
@[nontriviality]
theorem Subsingleton.conformalAt [Subsingleton X] (f : X β Y) (x : X) : ConformalAt f x :=
β¨0, hasFDerivAt_of_subsingleton _ _, isConformalMap_of_subsingleton _β©
#align subsingleton.conformal_at Subsingleton.conformalAt
theorem conformalAt_iff_isConformalMap_fderiv {f : X β Y} {x : X} :
ConformalAt f x β IsConformalMap (fderiv β f x) := by
constructor
Β· rintro β¨f', hf, hf'β©
rwa [hf.fderiv]
Β· intro H
by_cases h : DifferentiableAt β f x
Β· exact β¨fderiv β f x, h.hasFDerivAt, Hβ©
Β· nontriviality X
exact absurd (fderiv_zero_of_not_differentiableAt h) H.ne_zero
#align conformal_at_iff_is_conformal_map_fderiv conformalAt_iff_isConformalMap_fderiv
namespace ConformalAt
theorem differentiableAt {f : X β Y} {x : X} (h : ConformalAt f x) : DifferentiableAt β f x :=
let β¨_, hβ, _β© := h
hβ.differentiableAt
#align conformal_at.differentiable_at ConformalAt.differentiableAt
theorem congr {f g : X β Y} {x : X} {u : Set X} (hx : x β u) (hu : IsOpen u) (hf : ConformalAt f x)
(h : β x : X, x β u β g x = f x) : ConformalAt g x :=
let β¨f', hfderiv, hf'β© := hf
β¨f', hfderiv.congr_of_eventuallyEq ((hu.eventually_mem hx).mono h), hf'β©
#align conformal_at.congr ConformalAt.congr
| Mathlib/Analysis/Calculus/Conformal/NormedSpace.lean | 98 | 102 | theorem comp {f : X β Y} {g : Y β Z} (x : X) (hg : ConformalAt g (f x)) (hf : ConformalAt f x) :
ConformalAt (g β f) x := by |
rcases hf with β¨f', hfβ, cfβ©
rcases hg with β¨g', hgβ, cgβ©
exact β¨g'.comp f', hgβ.comp x hfβ, cg.comp cfβ©
| 1,602 |
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.prod from "leanprover-community/mathlib"@"e354e865255654389cc46e6032160238df2e0f40"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Filter Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
section CartesianProduct
section Pi
variable {ΞΉ : Type*} [Fintype ΞΉ] {F' : ΞΉ β Type*} [β i, NormedAddCommGroup (F' i)]
[β i, NormedSpace π (F' i)] {Ο : β i, E β F' i} {Ο' : β i, E βL[π] F' i} {Ξ¦ : E β β i, F' i}
{Ξ¦' : E βL[π] β i, F' i}
@[simp]
| Mathlib/Analysis/Calculus/FDeriv/Prod.lean | 400 | 403 | theorem hasStrictFDerivAt_pi' :
HasStrictFDerivAt Ξ¦ Ξ¦' x β β i, HasStrictFDerivAt (fun x => Ξ¦ x i) ((proj i).comp Ξ¦') x := by |
simp only [HasStrictFDerivAt, ContinuousLinearMap.coe_pi]
exact isLittleO_pi
| 1,603 |
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.prod from "leanprover-community/mathlib"@"e354e865255654389cc46e6032160238df2e0f40"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Filter Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
section CartesianProduct
section Pi
variable {ΞΉ : Type*} [Fintype ΞΉ] {F' : ΞΉ β Type*} [β i, NormedAddCommGroup (F' i)]
[β i, NormedSpace π (F' i)] {Ο : β i, E β F' i} {Ο' : β i, E βL[π] F' i} {Ξ¦ : E β β i, F' i}
{Ξ¦' : E βL[π] β i, F' i}
@[simp]
theorem hasStrictFDerivAt_pi' :
HasStrictFDerivAt Ξ¦ Ξ¦' x β β i, HasStrictFDerivAt (fun x => Ξ¦ x i) ((proj i).comp Ξ¦') x := by
simp only [HasStrictFDerivAt, ContinuousLinearMap.coe_pi]
exact isLittleO_pi
#align has_strict_fderiv_at_pi' hasStrictFDerivAt_pi'
@[fun_prop]
theorem hasStrictFDerivAt_pi'' (hΟ : β i, HasStrictFDerivAt (fun x => Ξ¦ x i) ((proj i).comp Ξ¦') x) :
HasStrictFDerivAt Ξ¦ Ξ¦' x := hasStrictFDerivAt_pi'.2 hΟ
@[fun_prop]
| Mathlib/Analysis/Calculus/FDeriv/Prod.lean | 411 | 417 | theorem hasStrictFDerivAt_apply (i : ΞΉ) (f : β i, F' i) :
HasStrictFDerivAt (π:=π) (fun f : β i, F' i => f i) (proj i) f := by |
let id' := ContinuousLinearMap.id π (β i, F' i)
have h := ((hasStrictFDerivAt_pi'
(Ξ¦ := fun (f : β i, F' i) (i' : ΞΉ) => f i') (Ξ¦':=id') (x:=f))).1
have h' : comp (proj i) id' = proj i := by rfl
rw [β h']; apply h; apply hasStrictFDerivAt_id
| 1,603 |
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.prod from "leanprover-community/mathlib"@"e354e865255654389cc46e6032160238df2e0f40"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Filter Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
section CartesianProduct
section Pi
variable {ΞΉ : Type*} [Fintype ΞΉ] {F' : ΞΉ β Type*} [β i, NormedAddCommGroup (F' i)]
[β i, NormedSpace π (F' i)] {Ο : β i, E β F' i} {Ο' : β i, E βL[π] F' i} {Ξ¦ : E β β i, F' i}
{Ξ¦' : E βL[π] β i, F' i}
@[simp]
theorem hasStrictFDerivAt_pi' :
HasStrictFDerivAt Ξ¦ Ξ¦' x β β i, HasStrictFDerivAt (fun x => Ξ¦ x i) ((proj i).comp Ξ¦') x := by
simp only [HasStrictFDerivAt, ContinuousLinearMap.coe_pi]
exact isLittleO_pi
#align has_strict_fderiv_at_pi' hasStrictFDerivAt_pi'
@[fun_prop]
theorem hasStrictFDerivAt_pi'' (hΟ : β i, HasStrictFDerivAt (fun x => Ξ¦ x i) ((proj i).comp Ξ¦') x) :
HasStrictFDerivAt Ξ¦ Ξ¦' x := hasStrictFDerivAt_pi'.2 hΟ
@[fun_prop]
theorem hasStrictFDerivAt_apply (i : ΞΉ) (f : β i, F' i) :
HasStrictFDerivAt (π:=π) (fun f : β i, F' i => f i) (proj i) f := by
let id' := ContinuousLinearMap.id π (β i, F' i)
have h := ((hasStrictFDerivAt_pi'
(Ξ¦ := fun (f : β i, F' i) (i' : ΞΉ) => f i') (Ξ¦':=id') (x:=f))).1
have h' : comp (proj i) id' = proj i := by rfl
rw [β h']; apply h; apply hasStrictFDerivAt_id
@[simp 1100] -- Porting note: increased priority to make lint happy
theorem hasStrictFDerivAt_pi :
HasStrictFDerivAt (fun x i => Ο i x) (ContinuousLinearMap.pi Ο') x β
β i, HasStrictFDerivAt (Ο i) (Ο' i) x :=
hasStrictFDerivAt_pi'
#align has_strict_fderiv_at_pi hasStrictFDerivAt_pi
@[simp]
| Mathlib/Analysis/Calculus/FDeriv/Prod.lean | 427 | 431 | theorem hasFDerivAtFilter_pi' :
HasFDerivAtFilter Ξ¦ Ξ¦' x L β
β i, HasFDerivAtFilter (fun x => Ξ¦ x i) ((proj i).comp Ξ¦') x L := by |
simp only [hasFDerivAtFilter_iff_isLittleO, ContinuousLinearMap.coe_pi]
exact isLittleO_pi
| 1,603 |
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.prod from "leanprover-community/mathlib"@"e354e865255654389cc46e6032160238df2e0f40"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Filter Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
section CartesianProduct
section Pi
variable {ΞΉ : Type*} [Fintype ΞΉ] {F' : ΞΉ β Type*} [β i, NormedAddCommGroup (F' i)]
[β i, NormedSpace π (F' i)] {Ο : β i, E β F' i} {Ο' : β i, E βL[π] F' i} {Ξ¦ : E β β i, F' i}
{Ξ¦' : E βL[π] β i, F' i}
@[simp]
theorem hasStrictFDerivAt_pi' :
HasStrictFDerivAt Ξ¦ Ξ¦' x β β i, HasStrictFDerivAt (fun x => Ξ¦ x i) ((proj i).comp Ξ¦') x := by
simp only [HasStrictFDerivAt, ContinuousLinearMap.coe_pi]
exact isLittleO_pi
#align has_strict_fderiv_at_pi' hasStrictFDerivAt_pi'
@[fun_prop]
theorem hasStrictFDerivAt_pi'' (hΟ : β i, HasStrictFDerivAt (fun x => Ξ¦ x i) ((proj i).comp Ξ¦') x) :
HasStrictFDerivAt Ξ¦ Ξ¦' x := hasStrictFDerivAt_pi'.2 hΟ
@[fun_prop]
theorem hasStrictFDerivAt_apply (i : ΞΉ) (f : β i, F' i) :
HasStrictFDerivAt (π:=π) (fun f : β i, F' i => f i) (proj i) f := by
let id' := ContinuousLinearMap.id π (β i, F' i)
have h := ((hasStrictFDerivAt_pi'
(Ξ¦ := fun (f : β i, F' i) (i' : ΞΉ) => f i') (Ξ¦':=id') (x:=f))).1
have h' : comp (proj i) id' = proj i := by rfl
rw [β h']; apply h; apply hasStrictFDerivAt_id
@[simp 1100] -- Porting note: increased priority to make lint happy
theorem hasStrictFDerivAt_pi :
HasStrictFDerivAt (fun x i => Ο i x) (ContinuousLinearMap.pi Ο') x β
β i, HasStrictFDerivAt (Ο i) (Ο' i) x :=
hasStrictFDerivAt_pi'
#align has_strict_fderiv_at_pi hasStrictFDerivAt_pi
@[simp]
theorem hasFDerivAtFilter_pi' :
HasFDerivAtFilter Ξ¦ Ξ¦' x L β
β i, HasFDerivAtFilter (fun x => Ξ¦ x i) ((proj i).comp Ξ¦') x L := by
simp only [hasFDerivAtFilter_iff_isLittleO, ContinuousLinearMap.coe_pi]
exact isLittleO_pi
#align has_fderiv_at_filter_pi' hasFDerivAtFilter_pi'
theorem hasFDerivAtFilter_pi :
HasFDerivAtFilter (fun x i => Ο i x) (ContinuousLinearMap.pi Ο') x L β
β i, HasFDerivAtFilter (Ο i) (Ο' i) x L :=
hasFDerivAtFilter_pi'
#align has_fderiv_at_filter_pi hasFDerivAtFilter_pi
@[simp]
theorem hasFDerivAt_pi' :
HasFDerivAt Ξ¦ Ξ¦' x β β i, HasFDerivAt (fun x => Ξ¦ x i) ((proj i).comp Ξ¦') x :=
hasFDerivAtFilter_pi'
#align has_fderiv_at_pi' hasFDerivAt_pi'
@[fun_prop]
theorem hasFDerivAt_pi'' (hΟ : β i, HasFDerivAt (fun x => Ξ¦ x i) ((proj i).comp Ξ¦') x) :
HasFDerivAt Ξ¦ Ξ¦' x := hasFDerivAt_pi'.2 hΟ
@[fun_prop]
| Mathlib/Analysis/Calculus/FDeriv/Prod.lean | 451 | 454 | theorem hasFDerivAt_apply (i : ΞΉ) (f : β i, F' i) :
HasFDerivAt (π:=π) (fun f : β i, F' i => f i) (proj i) f := by |
apply HasStrictFDerivAt.hasFDerivAt
apply hasStrictFDerivAt_apply
| 1,603 |
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.prod from "leanprover-community/mathlib"@"e354e865255654389cc46e6032160238df2e0f40"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Filter Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
section CartesianProduct
section Pi
variable {ΞΉ : Type*} [Fintype ΞΉ] {F' : ΞΉ β Type*} [β i, NormedAddCommGroup (F' i)]
[β i, NormedSpace π (F' i)] {Ο : β i, E β F' i} {Ο' : β i, E βL[π] F' i} {Ξ¦ : E β β i, F' i}
{Ξ¦' : E βL[π] β i, F' i}
@[simp]
theorem hasStrictFDerivAt_pi' :
HasStrictFDerivAt Ξ¦ Ξ¦' x β β i, HasStrictFDerivAt (fun x => Ξ¦ x i) ((proj i).comp Ξ¦') x := by
simp only [HasStrictFDerivAt, ContinuousLinearMap.coe_pi]
exact isLittleO_pi
#align has_strict_fderiv_at_pi' hasStrictFDerivAt_pi'
@[fun_prop]
theorem hasStrictFDerivAt_pi'' (hΟ : β i, HasStrictFDerivAt (fun x => Ξ¦ x i) ((proj i).comp Ξ¦') x) :
HasStrictFDerivAt Ξ¦ Ξ¦' x := hasStrictFDerivAt_pi'.2 hΟ
@[fun_prop]
theorem hasStrictFDerivAt_apply (i : ΞΉ) (f : β i, F' i) :
HasStrictFDerivAt (π:=π) (fun f : β i, F' i => f i) (proj i) f := by
let id' := ContinuousLinearMap.id π (β i, F' i)
have h := ((hasStrictFDerivAt_pi'
(Ξ¦ := fun (f : β i, F' i) (i' : ΞΉ) => f i') (Ξ¦':=id') (x:=f))).1
have h' : comp (proj i) id' = proj i := by rfl
rw [β h']; apply h; apply hasStrictFDerivAt_id
@[simp 1100] -- Porting note: increased priority to make lint happy
theorem hasStrictFDerivAt_pi :
HasStrictFDerivAt (fun x i => Ο i x) (ContinuousLinearMap.pi Ο') x β
β i, HasStrictFDerivAt (Ο i) (Ο' i) x :=
hasStrictFDerivAt_pi'
#align has_strict_fderiv_at_pi hasStrictFDerivAt_pi
@[simp]
theorem hasFDerivAtFilter_pi' :
HasFDerivAtFilter Ξ¦ Ξ¦' x L β
β i, HasFDerivAtFilter (fun x => Ξ¦ x i) ((proj i).comp Ξ¦') x L := by
simp only [hasFDerivAtFilter_iff_isLittleO, ContinuousLinearMap.coe_pi]
exact isLittleO_pi
#align has_fderiv_at_filter_pi' hasFDerivAtFilter_pi'
theorem hasFDerivAtFilter_pi :
HasFDerivAtFilter (fun x i => Ο i x) (ContinuousLinearMap.pi Ο') x L β
β i, HasFDerivAtFilter (Ο i) (Ο' i) x L :=
hasFDerivAtFilter_pi'
#align has_fderiv_at_filter_pi hasFDerivAtFilter_pi
@[simp]
theorem hasFDerivAt_pi' :
HasFDerivAt Ξ¦ Ξ¦' x β β i, HasFDerivAt (fun x => Ξ¦ x i) ((proj i).comp Ξ¦') x :=
hasFDerivAtFilter_pi'
#align has_fderiv_at_pi' hasFDerivAt_pi'
@[fun_prop]
theorem hasFDerivAt_pi'' (hΟ : β i, HasFDerivAt (fun x => Ξ¦ x i) ((proj i).comp Ξ¦') x) :
HasFDerivAt Ξ¦ Ξ¦' x := hasFDerivAt_pi'.2 hΟ
@[fun_prop]
theorem hasFDerivAt_apply (i : ΞΉ) (f : β i, F' i) :
HasFDerivAt (π:=π) (fun f : β i, F' i => f i) (proj i) f := by
apply HasStrictFDerivAt.hasFDerivAt
apply hasStrictFDerivAt_apply
theorem hasFDerivAt_pi :
HasFDerivAt (fun x i => Ο i x) (ContinuousLinearMap.pi Ο') x β
β i, HasFDerivAt (Ο i) (Ο' i) x :=
hasFDerivAtFilter_pi
#align has_fderiv_at_pi hasFDerivAt_pi
@[simp]
theorem hasFDerivWithinAt_pi' :
HasFDerivWithinAt Ξ¦ Ξ¦' s x β β i, HasFDerivWithinAt (fun x => Ξ¦ x i) ((proj i).comp Ξ¦') s x :=
hasFDerivAtFilter_pi'
#align has_fderiv_within_at_pi' hasFDerivWithinAt_pi'
@[fun_prop]
theorem hasFDerivWithinAt_pi''
(hΟ : β i, HasFDerivWithinAt (fun x => Ξ¦ x i) ((proj i).comp Ξ¦') s x) :
HasFDerivWithinAt Ξ¦ Ξ¦' s x := hasFDerivWithinAt_pi'.2 hΟ
@[fun_prop]
| Mathlib/Analysis/Calculus/FDeriv/Prod.lean | 474 | 480 | theorem hasFDerivWithinAt_apply (i : ΞΉ) (f : β i, F' i) (s' : Set (β i, F' i)) :
HasFDerivWithinAt (π:=π) (fun f : β i, F' i => f i) (proj i) s' f := by |
let id' := ContinuousLinearMap.id π (β i, F' i)
have h := ((hasFDerivWithinAt_pi'
(Ξ¦ := fun (f : β i, F' i) (i' : ΞΉ) => f i') (Ξ¦':=id') (x:=f) (s:=s'))).1
have h' : comp (proj i) id' = proj i := by rfl
rw [β h']; apply h; apply hasFDerivWithinAt_id
| 1,603 |
import Mathlib.Analysis.Calculus.FDeriv.Prod
#align_import analysis.calculus.fderiv.bilinear from "leanprover-community/mathlib"@"e3fb84046afd187b710170887195d50bada934ee"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
section BilinearMap
variable {b : E Γ F β G} {u : Set (E Γ F)}
open NormedField
-- Porting note (#11215): TODO: rewrite/golf using analytic functions?
@[fun_prop]
| Mathlib/Analysis/Calculus/FDeriv/Bilinear.lean | 51 | 74 | theorem IsBoundedBilinearMap.hasStrictFDerivAt (h : IsBoundedBilinearMap π b) (p : E Γ F) :
HasStrictFDerivAt b (h.deriv p) p := by |
simp only [HasStrictFDerivAt]
simp only [β map_add_left_nhds_zero (p, p), isLittleO_map]
set T := (E Γ F) Γ E Γ F
calc
_ = fun x β¦ h.deriv (x.1 - x.2) (x.2.1, x.1.2) := by
ext β¨β¨xβ, yββ©, β¨xβ, yββ©β©
rcases p with β¨x, yβ©
simp only [map_sub, deriv_apply, Function.comp_apply, Prod.mk_add_mk, h.add_right, h.add_left,
Prod.mk_sub_mk, h.map_sub_left, h.map_sub_right, sub_add_sub_cancel]
abel
-- _ =O[π (0 : T)] fun x β¦ βx.1 - x.2β * β(x.2.1, x.1.2)β :=
-- h.toContinuousLinearMap.derivβ.isBoundedBilinearMap.isBigO_comp
-- _ = o[π 0] fun x β¦ βx.1 - x.2β * 1 := _
_ =o[π (0 : T)] fun x β¦ x.1 - x.2 := by
-- TODO : add 2 `calc` steps instead of the next 3 lines
refine h.toContinuousLinearMap.derivβ.isBoundedBilinearMap.isBigO_comp.trans_isLittleO ?_
suffices (fun x : T β¦ βx.1 - x.2β * β(x.2.1, x.1.2)β) =o[π 0] fun x β¦ βx.1 - x.2β * 1 by
simpa only [mul_one, isLittleO_norm_right] using this
refine (isBigO_refl _ _).mul_isLittleO ((isLittleO_one_iff _).2 ?_)
-- TODO: `continuity` fails
exact (continuous_snd.fst.prod_mk continuous_fst.snd).norm.tendsto' _ _ (by simp)
_ = _ := by simp [(Β· β Β·)]
| 1,604 |
import Mathlib.Analysis.Calculus.FDeriv.Bilinear
#align_import analysis.calculus.fderiv.mul from "leanprover-community/mathlib"@"d608fc5d4e69d4cc21885913fb573a88b0deb521"
open scoped Classical
open Filter Asymptotics ContinuousLinearMap Set Metric Topology NNReal ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
section ContinuousMultilinearApplyConst
variable {ΞΉ : Type*} [Fintype ΞΉ]
{M : ΞΉ β Type*} [β i, NormedAddCommGroup (M i)] [β i, NormedSpace π (M i)]
{H : Type*} [NormedAddCommGroup H] [NormedSpace π H]
{c : E β ContinuousMultilinearMap π M H}
{c' : E βL[π] ContinuousMultilinearMap π M H}
@[fun_prop]
theorem HasStrictFDerivAt.continuousMultilinear_apply_const (hc : HasStrictFDerivAt c c' x)
(u : β i, M i) : HasStrictFDerivAt (fun y β¦ (c y) u) (c'.flipMultilinear u) x :=
(ContinuousMultilinearMap.apply π M H u).hasStrictFDerivAt.comp x hc
@[fun_prop]
theorem HasFDerivWithinAt.continuousMultilinear_apply_const (hc : HasFDerivWithinAt c c' s x)
(u : β i, M i) :
HasFDerivWithinAt (fun y β¦ (c y) u) (c'.flipMultilinear u) s x :=
(ContinuousMultilinearMap.apply π M H u).hasFDerivAt.comp_hasFDerivWithinAt x hc
@[fun_prop]
theorem HasFDerivAt.continuousMultilinear_apply_const (hc : HasFDerivAt c c' x) (u : β i, M i) :
HasFDerivAt (fun y β¦ (c y) u) (c'.flipMultilinear u) x :=
(ContinuousMultilinearMap.apply π M H u).hasFDerivAt.comp x hc
@[fun_prop]
theorem DifferentiableWithinAt.continuousMultilinear_apply_const
(hc : DifferentiableWithinAt π c s x) (u : β i, M i) :
DifferentiableWithinAt π (fun y β¦ (c y) u) s x :=
(hc.hasFDerivWithinAt.continuousMultilinear_apply_const u).differentiableWithinAt
@[fun_prop]
theorem DifferentiableAt.continuousMultilinear_apply_const (hc : DifferentiableAt π c x)
(u : β i, M i) :
DifferentiableAt π (fun y β¦ (c y) u) x :=
(hc.hasFDerivAt.continuousMultilinear_apply_const u).differentiableAt
@[fun_prop]
theorem DifferentiableOn.continuousMultilinear_apply_const (hc : DifferentiableOn π c s)
(u : β i, M i) : DifferentiableOn π (fun y β¦ (c y) u) s :=
fun x hx β¦ (hc x hx).continuousMultilinear_apply_const u
@[fun_prop]
theorem Differentiable.continuousMultilinear_apply_const (hc : Differentiable π c) (u : β i, M i) :
Differentiable π fun y β¦ (c y) u := fun x β¦ (hc x).continuousMultilinear_apply_const u
theorem fderivWithin_continuousMultilinear_apply_const (hxs : UniqueDiffWithinAt π s x)
(hc : DifferentiableWithinAt π c s x) (u : β i, M i) :
fderivWithin π (fun y β¦ (c y) u) s x = ((fderivWithin π c s x).flipMultilinear u) :=
(hc.hasFDerivWithinAt.continuousMultilinear_apply_const u).fderivWithin hxs
theorem fderiv_continuousMultilinear_apply_const (hc : DifferentiableAt π c x) (u : β i, M i) :
(fderiv π (fun y β¦ (c y) u) x) = (fderiv π c x).flipMultilinear u :=
(hc.hasFDerivAt.continuousMultilinear_apply_const u).fderiv
| Mathlib/Analysis/Calculus/FDeriv/Mul.lean | 224 | 227 | theorem fderivWithin_continuousMultilinear_apply_const_apply (hxs : UniqueDiffWithinAt π s x)
(hc : DifferentiableWithinAt π c s x) (u : β i, M i) (m : E) :
(fderivWithin π (fun y β¦ (c y) u) s x) m = (fderivWithin π c s x) m u := by |
simp [fderivWithin_continuousMultilinear_apply_const hxs hc]
| 1,605 |
import Mathlib.Analysis.Calculus.FDeriv.Bilinear
#align_import analysis.calculus.fderiv.mul from "leanprover-community/mathlib"@"d608fc5d4e69d4cc21885913fb573a88b0deb521"
open scoped Classical
open Filter Asymptotics ContinuousLinearMap Set Metric Topology NNReal ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
section ContinuousMultilinearApplyConst
variable {ΞΉ : Type*} [Fintype ΞΉ]
{M : ΞΉ β Type*} [β i, NormedAddCommGroup (M i)] [β i, NormedSpace π (M i)]
{H : Type*} [NormedAddCommGroup H] [NormedSpace π H]
{c : E β ContinuousMultilinearMap π M H}
{c' : E βL[π] ContinuousMultilinearMap π M H}
@[fun_prop]
theorem HasStrictFDerivAt.continuousMultilinear_apply_const (hc : HasStrictFDerivAt c c' x)
(u : β i, M i) : HasStrictFDerivAt (fun y β¦ (c y) u) (c'.flipMultilinear u) x :=
(ContinuousMultilinearMap.apply π M H u).hasStrictFDerivAt.comp x hc
@[fun_prop]
theorem HasFDerivWithinAt.continuousMultilinear_apply_const (hc : HasFDerivWithinAt c c' s x)
(u : β i, M i) :
HasFDerivWithinAt (fun y β¦ (c y) u) (c'.flipMultilinear u) s x :=
(ContinuousMultilinearMap.apply π M H u).hasFDerivAt.comp_hasFDerivWithinAt x hc
@[fun_prop]
theorem HasFDerivAt.continuousMultilinear_apply_const (hc : HasFDerivAt c c' x) (u : β i, M i) :
HasFDerivAt (fun y β¦ (c y) u) (c'.flipMultilinear u) x :=
(ContinuousMultilinearMap.apply π M H u).hasFDerivAt.comp x hc
@[fun_prop]
theorem DifferentiableWithinAt.continuousMultilinear_apply_const
(hc : DifferentiableWithinAt π c s x) (u : β i, M i) :
DifferentiableWithinAt π (fun y β¦ (c y) u) s x :=
(hc.hasFDerivWithinAt.continuousMultilinear_apply_const u).differentiableWithinAt
@[fun_prop]
theorem DifferentiableAt.continuousMultilinear_apply_const (hc : DifferentiableAt π c x)
(u : β i, M i) :
DifferentiableAt π (fun y β¦ (c y) u) x :=
(hc.hasFDerivAt.continuousMultilinear_apply_const u).differentiableAt
@[fun_prop]
theorem DifferentiableOn.continuousMultilinear_apply_const (hc : DifferentiableOn π c s)
(u : β i, M i) : DifferentiableOn π (fun y β¦ (c y) u) s :=
fun x hx β¦ (hc x hx).continuousMultilinear_apply_const u
@[fun_prop]
theorem Differentiable.continuousMultilinear_apply_const (hc : Differentiable π c) (u : β i, M i) :
Differentiable π fun y β¦ (c y) u := fun x β¦ (hc x).continuousMultilinear_apply_const u
theorem fderivWithin_continuousMultilinear_apply_const (hxs : UniqueDiffWithinAt π s x)
(hc : DifferentiableWithinAt π c s x) (u : β i, M i) :
fderivWithin π (fun y β¦ (c y) u) s x = ((fderivWithin π c s x).flipMultilinear u) :=
(hc.hasFDerivWithinAt.continuousMultilinear_apply_const u).fderivWithin hxs
theorem fderiv_continuousMultilinear_apply_const (hc : DifferentiableAt π c x) (u : β i, M i) :
(fderiv π (fun y β¦ (c y) u) x) = (fderiv π c x).flipMultilinear u :=
(hc.hasFDerivAt.continuousMultilinear_apply_const u).fderiv
theorem fderivWithin_continuousMultilinear_apply_const_apply (hxs : UniqueDiffWithinAt π s x)
(hc : DifferentiableWithinAt π c s x) (u : β i, M i) (m : E) :
(fderivWithin π (fun y β¦ (c y) u) s x) m = (fderivWithin π c s x) m u := by
simp [fderivWithin_continuousMultilinear_apply_const hxs hc]
| Mathlib/Analysis/Calculus/FDeriv/Mul.lean | 230 | 233 | theorem fderiv_continuousMultilinear_apply_const_apply (hc : DifferentiableAt π c x)
(u : β i, M i) (m : E) :
(fderiv π (fun y β¦ (c y) u) x) m = (fderiv π c x) m u := by |
simp [fderiv_continuousMultilinear_apply_const hc]
| 1,605 |
import Mathlib.Analysis.Calculus.FDeriv.Bilinear
#align_import analysis.calculus.fderiv.mul from "leanprover-community/mathlib"@"d608fc5d4e69d4cc21885913fb573a88b0deb521"
open scoped Classical
open Filter Asymptotics ContinuousLinearMap Set Metric Topology NNReal ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
section SMul
variable {π' : Type*} [NontriviallyNormedField π'] [NormedAlgebra π π'] [NormedSpace π' F]
[IsScalarTower π π' F]
variable {c : E β π'} {c' : E βL[π] π'}
@[fun_prop]
theorem HasStrictFDerivAt.smul (hc : HasStrictFDerivAt c c' x) (hf : HasStrictFDerivAt f f' x) :
HasStrictFDerivAt (fun y => c y β’ f y) (c x β’ f' + c'.smulRight (f x)) x :=
(isBoundedBilinearMap_smul.hasStrictFDerivAt (c x, f x)).comp x <| hc.prod hf
#align has_strict_fderiv_at.smul HasStrictFDerivAt.smul
@[fun_prop]
theorem HasFDerivWithinAt.smul (hc : HasFDerivWithinAt c c' s x) (hf : HasFDerivWithinAt f f' s x) :
HasFDerivWithinAt (fun y => c y β’ f y) (c x β’ f' + c'.smulRight (f x)) s x :=
(isBoundedBilinearMap_smul.hasFDerivAt (c x, f x)).comp_hasFDerivWithinAt x <| hc.prod hf
#align has_fderiv_within_at.smul HasFDerivWithinAt.smul
@[fun_prop]
theorem HasFDerivAt.smul (hc : HasFDerivAt c c' x) (hf : HasFDerivAt f f' x) :
HasFDerivAt (fun y => c y β’ f y) (c x β’ f' + c'.smulRight (f x)) x :=
(isBoundedBilinearMap_smul.hasFDerivAt (c x, f x)).comp x <| hc.prod hf
#align has_fderiv_at.smul HasFDerivAt.smul
@[fun_prop]
theorem DifferentiableWithinAt.smul (hc : DifferentiableWithinAt π c s x)
(hf : DifferentiableWithinAt π f s x) : DifferentiableWithinAt π (fun y => c y β’ f y) s x :=
(hc.hasFDerivWithinAt.smul hf.hasFDerivWithinAt).differentiableWithinAt
#align differentiable_within_at.smul DifferentiableWithinAt.smul
@[simp, fun_prop]
theorem DifferentiableAt.smul (hc : DifferentiableAt π c x) (hf : DifferentiableAt π f x) :
DifferentiableAt π (fun y => c y β’ f y) x :=
(hc.hasFDerivAt.smul hf.hasFDerivAt).differentiableAt
#align differentiable_at.smul DifferentiableAt.smul
@[fun_prop]
theorem DifferentiableOn.smul (hc : DifferentiableOn π c s) (hf : DifferentiableOn π f s) :
DifferentiableOn π (fun y => c y β’ f y) s := fun x hx => (hc x hx).smul (hf x hx)
#align differentiable_on.smul DifferentiableOn.smul
@[simp, fun_prop]
theorem Differentiable.smul (hc : Differentiable π c) (hf : Differentiable π f) :
Differentiable π fun y => c y β’ f y := fun x => (hc x).smul (hf x)
#align differentiable.smul Differentiable.smul
theorem fderivWithin_smul (hxs : UniqueDiffWithinAt π s x) (hc : DifferentiableWithinAt π c s x)
(hf : DifferentiableWithinAt π f s x) :
fderivWithin π (fun y => c y β’ f y) s x =
c x β’ fderivWithin π f s x + (fderivWithin π c s x).smulRight (f x) :=
(hc.hasFDerivWithinAt.smul hf.hasFDerivWithinAt).fderivWithin hxs
#align fderiv_within_smul fderivWithin_smul
theorem fderiv_smul (hc : DifferentiableAt π c x) (hf : DifferentiableAt π f x) :
fderiv π (fun y => c y β’ f y) x = c x β’ fderiv π f x + (fderiv π c x).smulRight (f x) :=
(hc.hasFDerivAt.smul hf.hasFDerivAt).fderiv
#align fderiv_smul fderiv_smul
@[fun_prop]
| Mathlib/Analysis/Calculus/FDeriv/Mul.lean | 307 | 309 | theorem HasStrictFDerivAt.smul_const (hc : HasStrictFDerivAt c c' x) (f : F) :
HasStrictFDerivAt (fun y => c y β’ f) (c'.smulRight f) x := by |
simpa only [smul_zero, zero_add] using hc.smul (hasStrictFDerivAt_const f x)
| 1,605 |
import Mathlib.Analysis.Calculus.FDeriv.Bilinear
#align_import analysis.calculus.fderiv.mul from "leanprover-community/mathlib"@"d608fc5d4e69d4cc21885913fb573a88b0deb521"
open scoped Classical
open Filter Asymptotics ContinuousLinearMap Set Metric Topology NNReal ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
section SMul
variable {π' : Type*} [NontriviallyNormedField π'] [NormedAlgebra π π'] [NormedSpace π' F]
[IsScalarTower π π' F]
variable {c : E β π'} {c' : E βL[π] π'}
@[fun_prop]
theorem HasStrictFDerivAt.smul (hc : HasStrictFDerivAt c c' x) (hf : HasStrictFDerivAt f f' x) :
HasStrictFDerivAt (fun y => c y β’ f y) (c x β’ f' + c'.smulRight (f x)) x :=
(isBoundedBilinearMap_smul.hasStrictFDerivAt (c x, f x)).comp x <| hc.prod hf
#align has_strict_fderiv_at.smul HasStrictFDerivAt.smul
@[fun_prop]
theorem HasFDerivWithinAt.smul (hc : HasFDerivWithinAt c c' s x) (hf : HasFDerivWithinAt f f' s x) :
HasFDerivWithinAt (fun y => c y β’ f y) (c x β’ f' + c'.smulRight (f x)) s x :=
(isBoundedBilinearMap_smul.hasFDerivAt (c x, f x)).comp_hasFDerivWithinAt x <| hc.prod hf
#align has_fderiv_within_at.smul HasFDerivWithinAt.smul
@[fun_prop]
theorem HasFDerivAt.smul (hc : HasFDerivAt c c' x) (hf : HasFDerivAt f f' x) :
HasFDerivAt (fun y => c y β’ f y) (c x β’ f' + c'.smulRight (f x)) x :=
(isBoundedBilinearMap_smul.hasFDerivAt (c x, f x)).comp x <| hc.prod hf
#align has_fderiv_at.smul HasFDerivAt.smul
@[fun_prop]
theorem DifferentiableWithinAt.smul (hc : DifferentiableWithinAt π c s x)
(hf : DifferentiableWithinAt π f s x) : DifferentiableWithinAt π (fun y => c y β’ f y) s x :=
(hc.hasFDerivWithinAt.smul hf.hasFDerivWithinAt).differentiableWithinAt
#align differentiable_within_at.smul DifferentiableWithinAt.smul
@[simp, fun_prop]
theorem DifferentiableAt.smul (hc : DifferentiableAt π c x) (hf : DifferentiableAt π f x) :
DifferentiableAt π (fun y => c y β’ f y) x :=
(hc.hasFDerivAt.smul hf.hasFDerivAt).differentiableAt
#align differentiable_at.smul DifferentiableAt.smul
@[fun_prop]
theorem DifferentiableOn.smul (hc : DifferentiableOn π c s) (hf : DifferentiableOn π f s) :
DifferentiableOn π (fun y => c y β’ f y) s := fun x hx => (hc x hx).smul (hf x hx)
#align differentiable_on.smul DifferentiableOn.smul
@[simp, fun_prop]
theorem Differentiable.smul (hc : Differentiable π c) (hf : Differentiable π f) :
Differentiable π fun y => c y β’ f y := fun x => (hc x).smul (hf x)
#align differentiable.smul Differentiable.smul
theorem fderivWithin_smul (hxs : UniqueDiffWithinAt π s x) (hc : DifferentiableWithinAt π c s x)
(hf : DifferentiableWithinAt π f s x) :
fderivWithin π (fun y => c y β’ f y) s x =
c x β’ fderivWithin π f s x + (fderivWithin π c s x).smulRight (f x) :=
(hc.hasFDerivWithinAt.smul hf.hasFDerivWithinAt).fderivWithin hxs
#align fderiv_within_smul fderivWithin_smul
theorem fderiv_smul (hc : DifferentiableAt π c x) (hf : DifferentiableAt π f x) :
fderiv π (fun y => c y β’ f y) x = c x β’ fderiv π f x + (fderiv π c x).smulRight (f x) :=
(hc.hasFDerivAt.smul hf.hasFDerivAt).fderiv
#align fderiv_smul fderiv_smul
@[fun_prop]
theorem HasStrictFDerivAt.smul_const (hc : HasStrictFDerivAt c c' x) (f : F) :
HasStrictFDerivAt (fun y => c y β’ f) (c'.smulRight f) x := by
simpa only [smul_zero, zero_add] using hc.smul (hasStrictFDerivAt_const f x)
#align has_strict_fderiv_at.smul_const HasStrictFDerivAt.smul_const
@[fun_prop]
| Mathlib/Analysis/Calculus/FDeriv/Mul.lean | 313 | 315 | theorem HasFDerivWithinAt.smul_const (hc : HasFDerivWithinAt c c' s x) (f : F) :
HasFDerivWithinAt (fun y => c y β’ f) (c'.smulRight f) s x := by |
simpa only [smul_zero, zero_add] using hc.smul (hasFDerivWithinAt_const f x s)
| 1,605 |
import Mathlib.Analysis.Calculus.FDeriv.Bilinear
#align_import analysis.calculus.fderiv.mul from "leanprover-community/mathlib"@"d608fc5d4e69d4cc21885913fb573a88b0deb521"
open scoped Classical
open Filter Asymptotics ContinuousLinearMap Set Metric Topology NNReal ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
section SMul
variable {π' : Type*} [NontriviallyNormedField π'] [NormedAlgebra π π'] [NormedSpace π' F]
[IsScalarTower π π' F]
variable {c : E β π'} {c' : E βL[π] π'}
@[fun_prop]
theorem HasStrictFDerivAt.smul (hc : HasStrictFDerivAt c c' x) (hf : HasStrictFDerivAt f f' x) :
HasStrictFDerivAt (fun y => c y β’ f y) (c x β’ f' + c'.smulRight (f x)) x :=
(isBoundedBilinearMap_smul.hasStrictFDerivAt (c x, f x)).comp x <| hc.prod hf
#align has_strict_fderiv_at.smul HasStrictFDerivAt.smul
@[fun_prop]
theorem HasFDerivWithinAt.smul (hc : HasFDerivWithinAt c c' s x) (hf : HasFDerivWithinAt f f' s x) :
HasFDerivWithinAt (fun y => c y β’ f y) (c x β’ f' + c'.smulRight (f x)) s x :=
(isBoundedBilinearMap_smul.hasFDerivAt (c x, f x)).comp_hasFDerivWithinAt x <| hc.prod hf
#align has_fderiv_within_at.smul HasFDerivWithinAt.smul
@[fun_prop]
theorem HasFDerivAt.smul (hc : HasFDerivAt c c' x) (hf : HasFDerivAt f f' x) :
HasFDerivAt (fun y => c y β’ f y) (c x β’ f' + c'.smulRight (f x)) x :=
(isBoundedBilinearMap_smul.hasFDerivAt (c x, f x)).comp x <| hc.prod hf
#align has_fderiv_at.smul HasFDerivAt.smul
@[fun_prop]
theorem DifferentiableWithinAt.smul (hc : DifferentiableWithinAt π c s x)
(hf : DifferentiableWithinAt π f s x) : DifferentiableWithinAt π (fun y => c y β’ f y) s x :=
(hc.hasFDerivWithinAt.smul hf.hasFDerivWithinAt).differentiableWithinAt
#align differentiable_within_at.smul DifferentiableWithinAt.smul
@[simp, fun_prop]
theorem DifferentiableAt.smul (hc : DifferentiableAt π c x) (hf : DifferentiableAt π f x) :
DifferentiableAt π (fun y => c y β’ f y) x :=
(hc.hasFDerivAt.smul hf.hasFDerivAt).differentiableAt
#align differentiable_at.smul DifferentiableAt.smul
@[fun_prop]
theorem DifferentiableOn.smul (hc : DifferentiableOn π c s) (hf : DifferentiableOn π f s) :
DifferentiableOn π (fun y => c y β’ f y) s := fun x hx => (hc x hx).smul (hf x hx)
#align differentiable_on.smul DifferentiableOn.smul
@[simp, fun_prop]
theorem Differentiable.smul (hc : Differentiable π c) (hf : Differentiable π f) :
Differentiable π fun y => c y β’ f y := fun x => (hc x).smul (hf x)
#align differentiable.smul Differentiable.smul
theorem fderivWithin_smul (hxs : UniqueDiffWithinAt π s x) (hc : DifferentiableWithinAt π c s x)
(hf : DifferentiableWithinAt π f s x) :
fderivWithin π (fun y => c y β’ f y) s x =
c x β’ fderivWithin π f s x + (fderivWithin π c s x).smulRight (f x) :=
(hc.hasFDerivWithinAt.smul hf.hasFDerivWithinAt).fderivWithin hxs
#align fderiv_within_smul fderivWithin_smul
theorem fderiv_smul (hc : DifferentiableAt π c x) (hf : DifferentiableAt π f x) :
fderiv π (fun y => c y β’ f y) x = c x β’ fderiv π f x + (fderiv π c x).smulRight (f x) :=
(hc.hasFDerivAt.smul hf.hasFDerivAt).fderiv
#align fderiv_smul fderiv_smul
@[fun_prop]
theorem HasStrictFDerivAt.smul_const (hc : HasStrictFDerivAt c c' x) (f : F) :
HasStrictFDerivAt (fun y => c y β’ f) (c'.smulRight f) x := by
simpa only [smul_zero, zero_add] using hc.smul (hasStrictFDerivAt_const f x)
#align has_strict_fderiv_at.smul_const HasStrictFDerivAt.smul_const
@[fun_prop]
theorem HasFDerivWithinAt.smul_const (hc : HasFDerivWithinAt c c' s x) (f : F) :
HasFDerivWithinAt (fun y => c y β’ f) (c'.smulRight f) s x := by
simpa only [smul_zero, zero_add] using hc.smul (hasFDerivWithinAt_const f x s)
#align has_fderiv_within_at.smul_const HasFDerivWithinAt.smul_const
@[fun_prop]
| Mathlib/Analysis/Calculus/FDeriv/Mul.lean | 319 | 321 | theorem HasFDerivAt.smul_const (hc : HasFDerivAt c c' x) (f : F) :
HasFDerivAt (fun y => c y β’ f) (c'.smulRight f) x := by |
simpa only [smul_zero, zero_add] using hc.smul (hasFDerivAt_const f x)
| 1,605 |
import Mathlib.Analysis.Calculus.FDeriv.Bilinear
#align_import analysis.calculus.fderiv.mul from "leanprover-community/mathlib"@"d608fc5d4e69d4cc21885913fb573a88b0deb521"
open scoped Classical
open Filter Asymptotics ContinuousLinearMap Set Metric Topology NNReal ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
section Mul
variable {πΈ πΈ' : Type*} [NormedRing πΈ] [NormedCommRing πΈ'] [NormedAlgebra π πΈ] [NormedAlgebra π πΈ']
{a b : E β πΈ} {a' b' : E βL[π] πΈ} {c d : E β πΈ'} {c' d' : E βL[π] πΈ'}
@[fun_prop]
theorem HasStrictFDerivAt.mul' {x : E} (ha : HasStrictFDerivAt a a' x)
(hb : HasStrictFDerivAt b b' x) :
HasStrictFDerivAt (fun y => a y * b y) (a x β’ b' + a'.smulRight (b x)) x :=
((ContinuousLinearMap.mul π πΈ).isBoundedBilinearMap.hasStrictFDerivAt (a x, b x)).comp x
(ha.prod hb)
#align has_strict_fderiv_at.mul' HasStrictFDerivAt.mul'
@[fun_prop]
| Mathlib/Analysis/Calculus/FDeriv/Mul.lean | 376 | 380 | theorem HasStrictFDerivAt.mul (hc : HasStrictFDerivAt c c' x) (hd : HasStrictFDerivAt d d' x) :
HasStrictFDerivAt (fun y => c y * d y) (c x β’ d' + d x β’ c') x := by |
convert hc.mul' hd
ext z
apply mul_comm
| 1,605 |
import Mathlib.Analysis.Calculus.FDeriv.Bilinear
#align_import analysis.calculus.fderiv.mul from "leanprover-community/mathlib"@"d608fc5d4e69d4cc21885913fb573a88b0deb521"
open scoped Classical
open Filter Asymptotics ContinuousLinearMap Set Metric Topology NNReal ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
section Mul
variable {πΈ πΈ' : Type*} [NormedRing πΈ] [NormedCommRing πΈ'] [NormedAlgebra π πΈ] [NormedAlgebra π πΈ']
{a b : E β πΈ} {a' b' : E βL[π] πΈ} {c d : E β πΈ'} {c' d' : E βL[π] πΈ'}
@[fun_prop]
theorem HasStrictFDerivAt.mul' {x : E} (ha : HasStrictFDerivAt a a' x)
(hb : HasStrictFDerivAt b b' x) :
HasStrictFDerivAt (fun y => a y * b y) (a x β’ b' + a'.smulRight (b x)) x :=
((ContinuousLinearMap.mul π πΈ).isBoundedBilinearMap.hasStrictFDerivAt (a x, b x)).comp x
(ha.prod hb)
#align has_strict_fderiv_at.mul' HasStrictFDerivAt.mul'
@[fun_prop]
theorem HasStrictFDerivAt.mul (hc : HasStrictFDerivAt c c' x) (hd : HasStrictFDerivAt d d' x) :
HasStrictFDerivAt (fun y => c y * d y) (c x β’ d' + d x β’ c') x := by
convert hc.mul' hd
ext z
apply mul_comm
#align has_strict_fderiv_at.mul HasStrictFDerivAt.mul
@[fun_prop]
theorem HasFDerivWithinAt.mul' (ha : HasFDerivWithinAt a a' s x) (hb : HasFDerivWithinAt b b' s x) :
HasFDerivWithinAt (fun y => a y * b y) (a x β’ b' + a'.smulRight (b x)) s x :=
((ContinuousLinearMap.mul π πΈ).isBoundedBilinearMap.hasFDerivAt (a x, b x)).comp_hasFDerivWithinAt
x (ha.prod hb)
#align has_fderiv_within_at.mul' HasFDerivWithinAt.mul'
@[fun_prop]
| Mathlib/Analysis/Calculus/FDeriv/Mul.lean | 391 | 395 | theorem HasFDerivWithinAt.mul (hc : HasFDerivWithinAt c c' s x) (hd : HasFDerivWithinAt d d' s x) :
HasFDerivWithinAt (fun y => c y * d y) (c x β’ d' + d x β’ c') s x := by |
convert hc.mul' hd
ext z
apply mul_comm
| 1,605 |
import Mathlib.Analysis.Calculus.FDeriv.Bilinear
#align_import analysis.calculus.fderiv.mul from "leanprover-community/mathlib"@"d608fc5d4e69d4cc21885913fb573a88b0deb521"
open scoped Classical
open Filter Asymptotics ContinuousLinearMap Set Metric Topology NNReal ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
section Mul
variable {πΈ πΈ' : Type*} [NormedRing πΈ] [NormedCommRing πΈ'] [NormedAlgebra π πΈ] [NormedAlgebra π πΈ']
{a b : E β πΈ} {a' b' : E βL[π] πΈ} {c d : E β πΈ'} {c' d' : E βL[π] πΈ'}
@[fun_prop]
theorem HasStrictFDerivAt.mul' {x : E} (ha : HasStrictFDerivAt a a' x)
(hb : HasStrictFDerivAt b b' x) :
HasStrictFDerivAt (fun y => a y * b y) (a x β’ b' + a'.smulRight (b x)) x :=
((ContinuousLinearMap.mul π πΈ).isBoundedBilinearMap.hasStrictFDerivAt (a x, b x)).comp x
(ha.prod hb)
#align has_strict_fderiv_at.mul' HasStrictFDerivAt.mul'
@[fun_prop]
theorem HasStrictFDerivAt.mul (hc : HasStrictFDerivAt c c' x) (hd : HasStrictFDerivAt d d' x) :
HasStrictFDerivAt (fun y => c y * d y) (c x β’ d' + d x β’ c') x := by
convert hc.mul' hd
ext z
apply mul_comm
#align has_strict_fderiv_at.mul HasStrictFDerivAt.mul
@[fun_prop]
theorem HasFDerivWithinAt.mul' (ha : HasFDerivWithinAt a a' s x) (hb : HasFDerivWithinAt b b' s x) :
HasFDerivWithinAt (fun y => a y * b y) (a x β’ b' + a'.smulRight (b x)) s x :=
((ContinuousLinearMap.mul π πΈ).isBoundedBilinearMap.hasFDerivAt (a x, b x)).comp_hasFDerivWithinAt
x (ha.prod hb)
#align has_fderiv_within_at.mul' HasFDerivWithinAt.mul'
@[fun_prop]
theorem HasFDerivWithinAt.mul (hc : HasFDerivWithinAt c c' s x) (hd : HasFDerivWithinAt d d' s x) :
HasFDerivWithinAt (fun y => c y * d y) (c x β’ d' + d x β’ c') s x := by
convert hc.mul' hd
ext z
apply mul_comm
#align has_fderiv_within_at.mul HasFDerivWithinAt.mul
@[fun_prop]
theorem HasFDerivAt.mul' (ha : HasFDerivAt a a' x) (hb : HasFDerivAt b b' x) :
HasFDerivAt (fun y => a y * b y) (a x β’ b' + a'.smulRight (b x)) x :=
((ContinuousLinearMap.mul π πΈ).isBoundedBilinearMap.hasFDerivAt (a x, b x)).comp x (ha.prod hb)
#align has_fderiv_at.mul' HasFDerivAt.mul'
@[fun_prop]
| Mathlib/Analysis/Calculus/FDeriv/Mul.lean | 405 | 409 | theorem HasFDerivAt.mul (hc : HasFDerivAt c c' x) (hd : HasFDerivAt d d' x) :
HasFDerivAt (fun y => c y * d y) (c x β’ d' + d x β’ c') x := by |
convert hc.mul' hd
ext z
apply mul_comm
| 1,605 |
import Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.equiv from "leanprover-community/mathlib"@"e3fb84046afd187b710170887195d50bada934ee"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Filter Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
namespace ContinuousLinearEquiv
variable (iso : E βL[π] F)
@[fun_prop]
protected theorem hasStrictFDerivAt : HasStrictFDerivAt iso (iso : E βL[π] F) x :=
iso.toContinuousLinearMap.hasStrictFDerivAt
#align continuous_linear_equiv.has_strict_fderiv_at ContinuousLinearEquiv.hasStrictFDerivAt
@[fun_prop]
protected theorem hasFDerivWithinAt : HasFDerivWithinAt iso (iso : E βL[π] F) s x :=
iso.toContinuousLinearMap.hasFDerivWithinAt
#align continuous_linear_equiv.has_fderiv_within_at ContinuousLinearEquiv.hasFDerivWithinAt
@[fun_prop]
protected theorem hasFDerivAt : HasFDerivAt iso (iso : E βL[π] F) x :=
iso.toContinuousLinearMap.hasFDerivAtFilter
#align continuous_linear_equiv.has_fderiv_at ContinuousLinearEquiv.hasFDerivAt
@[fun_prop]
protected theorem differentiableAt : DifferentiableAt π iso x :=
iso.hasFDerivAt.differentiableAt
#align continuous_linear_equiv.differentiable_at ContinuousLinearEquiv.differentiableAt
@[fun_prop]
protected theorem differentiableWithinAt : DifferentiableWithinAt π iso s x :=
iso.differentiableAt.differentiableWithinAt
#align continuous_linear_equiv.differentiable_within_at ContinuousLinearEquiv.differentiableWithinAt
protected theorem fderiv : fderiv π iso x = iso :=
iso.hasFDerivAt.fderiv
#align continuous_linear_equiv.fderiv ContinuousLinearEquiv.fderiv
protected theorem fderivWithin (hxs : UniqueDiffWithinAt π s x) : fderivWithin π iso s x = iso :=
iso.toContinuousLinearMap.fderivWithin hxs
#align continuous_linear_equiv.fderiv_within ContinuousLinearEquiv.fderivWithin
@[fun_prop]
protected theorem differentiable : Differentiable π iso := fun _ => iso.differentiableAt
#align continuous_linear_equiv.differentiable ContinuousLinearEquiv.differentiable
@[fun_prop]
protected theorem differentiableOn : DifferentiableOn π iso s :=
iso.differentiable.differentiableOn
#align continuous_linear_equiv.differentiable_on ContinuousLinearEquiv.differentiableOn
| Mathlib/Analysis/Calculus/FDeriv/Equiv.lean | 95 | 101 | theorem comp_differentiableWithinAt_iff {f : G β E} {s : Set G} {x : G} :
DifferentiableWithinAt π (iso β f) s x β DifferentiableWithinAt π f s x := by |
refine
β¨fun H => ?_, fun H => iso.differentiable.differentiableAt.comp_differentiableWithinAt x Hβ©
have : DifferentiableWithinAt π (iso.symm β iso β f) s x :=
iso.symm.differentiable.differentiableAt.comp_differentiableWithinAt x H
rwa [β Function.comp.assoc iso.symm iso f, iso.symm_comp_self] at this
| 1,606 |
import Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.equiv from "leanprover-community/mathlib"@"e3fb84046afd187b710170887195d50bada934ee"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Filter Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
namespace ContinuousLinearEquiv
variable (iso : E βL[π] F)
@[fun_prop]
protected theorem hasStrictFDerivAt : HasStrictFDerivAt iso (iso : E βL[π] F) x :=
iso.toContinuousLinearMap.hasStrictFDerivAt
#align continuous_linear_equiv.has_strict_fderiv_at ContinuousLinearEquiv.hasStrictFDerivAt
@[fun_prop]
protected theorem hasFDerivWithinAt : HasFDerivWithinAt iso (iso : E βL[π] F) s x :=
iso.toContinuousLinearMap.hasFDerivWithinAt
#align continuous_linear_equiv.has_fderiv_within_at ContinuousLinearEquiv.hasFDerivWithinAt
@[fun_prop]
protected theorem hasFDerivAt : HasFDerivAt iso (iso : E βL[π] F) x :=
iso.toContinuousLinearMap.hasFDerivAtFilter
#align continuous_linear_equiv.has_fderiv_at ContinuousLinearEquiv.hasFDerivAt
@[fun_prop]
protected theorem differentiableAt : DifferentiableAt π iso x :=
iso.hasFDerivAt.differentiableAt
#align continuous_linear_equiv.differentiable_at ContinuousLinearEquiv.differentiableAt
@[fun_prop]
protected theorem differentiableWithinAt : DifferentiableWithinAt π iso s x :=
iso.differentiableAt.differentiableWithinAt
#align continuous_linear_equiv.differentiable_within_at ContinuousLinearEquiv.differentiableWithinAt
protected theorem fderiv : fderiv π iso x = iso :=
iso.hasFDerivAt.fderiv
#align continuous_linear_equiv.fderiv ContinuousLinearEquiv.fderiv
protected theorem fderivWithin (hxs : UniqueDiffWithinAt π s x) : fderivWithin π iso s x = iso :=
iso.toContinuousLinearMap.fderivWithin hxs
#align continuous_linear_equiv.fderiv_within ContinuousLinearEquiv.fderivWithin
@[fun_prop]
protected theorem differentiable : Differentiable π iso := fun _ => iso.differentiableAt
#align continuous_linear_equiv.differentiable ContinuousLinearEquiv.differentiable
@[fun_prop]
protected theorem differentiableOn : DifferentiableOn π iso s :=
iso.differentiable.differentiableOn
#align continuous_linear_equiv.differentiable_on ContinuousLinearEquiv.differentiableOn
theorem comp_differentiableWithinAt_iff {f : G β E} {s : Set G} {x : G} :
DifferentiableWithinAt π (iso β f) s x β DifferentiableWithinAt π f s x := by
refine
β¨fun H => ?_, fun H => iso.differentiable.differentiableAt.comp_differentiableWithinAt x Hβ©
have : DifferentiableWithinAt π (iso.symm β iso β f) s x :=
iso.symm.differentiable.differentiableAt.comp_differentiableWithinAt x H
rwa [β Function.comp.assoc iso.symm iso f, iso.symm_comp_self] at this
#align continuous_linear_equiv.comp_differentiable_within_at_iff ContinuousLinearEquiv.comp_differentiableWithinAt_iff
| Mathlib/Analysis/Calculus/FDeriv/Equiv.lean | 104 | 107 | theorem comp_differentiableAt_iff {f : G β E} {x : G} :
DifferentiableAt π (iso β f) x β DifferentiableAt π f x := by |
rw [β differentiableWithinAt_univ, β differentiableWithinAt_univ,
iso.comp_differentiableWithinAt_iff]
| 1,606 |
import Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.equiv from "leanprover-community/mathlib"@"e3fb84046afd187b710170887195d50bada934ee"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Filter Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
namespace ContinuousLinearEquiv
variable (iso : E βL[π] F)
@[fun_prop]
protected theorem hasStrictFDerivAt : HasStrictFDerivAt iso (iso : E βL[π] F) x :=
iso.toContinuousLinearMap.hasStrictFDerivAt
#align continuous_linear_equiv.has_strict_fderiv_at ContinuousLinearEquiv.hasStrictFDerivAt
@[fun_prop]
protected theorem hasFDerivWithinAt : HasFDerivWithinAt iso (iso : E βL[π] F) s x :=
iso.toContinuousLinearMap.hasFDerivWithinAt
#align continuous_linear_equiv.has_fderiv_within_at ContinuousLinearEquiv.hasFDerivWithinAt
@[fun_prop]
protected theorem hasFDerivAt : HasFDerivAt iso (iso : E βL[π] F) x :=
iso.toContinuousLinearMap.hasFDerivAtFilter
#align continuous_linear_equiv.has_fderiv_at ContinuousLinearEquiv.hasFDerivAt
@[fun_prop]
protected theorem differentiableAt : DifferentiableAt π iso x :=
iso.hasFDerivAt.differentiableAt
#align continuous_linear_equiv.differentiable_at ContinuousLinearEquiv.differentiableAt
@[fun_prop]
protected theorem differentiableWithinAt : DifferentiableWithinAt π iso s x :=
iso.differentiableAt.differentiableWithinAt
#align continuous_linear_equiv.differentiable_within_at ContinuousLinearEquiv.differentiableWithinAt
protected theorem fderiv : fderiv π iso x = iso :=
iso.hasFDerivAt.fderiv
#align continuous_linear_equiv.fderiv ContinuousLinearEquiv.fderiv
protected theorem fderivWithin (hxs : UniqueDiffWithinAt π s x) : fderivWithin π iso s x = iso :=
iso.toContinuousLinearMap.fderivWithin hxs
#align continuous_linear_equiv.fderiv_within ContinuousLinearEquiv.fderivWithin
@[fun_prop]
protected theorem differentiable : Differentiable π iso := fun _ => iso.differentiableAt
#align continuous_linear_equiv.differentiable ContinuousLinearEquiv.differentiable
@[fun_prop]
protected theorem differentiableOn : DifferentiableOn π iso s :=
iso.differentiable.differentiableOn
#align continuous_linear_equiv.differentiable_on ContinuousLinearEquiv.differentiableOn
theorem comp_differentiableWithinAt_iff {f : G β E} {s : Set G} {x : G} :
DifferentiableWithinAt π (iso β f) s x β DifferentiableWithinAt π f s x := by
refine
β¨fun H => ?_, fun H => iso.differentiable.differentiableAt.comp_differentiableWithinAt x Hβ©
have : DifferentiableWithinAt π (iso.symm β iso β f) s x :=
iso.symm.differentiable.differentiableAt.comp_differentiableWithinAt x H
rwa [β Function.comp.assoc iso.symm iso f, iso.symm_comp_self] at this
#align continuous_linear_equiv.comp_differentiable_within_at_iff ContinuousLinearEquiv.comp_differentiableWithinAt_iff
theorem comp_differentiableAt_iff {f : G β E} {x : G} :
DifferentiableAt π (iso β f) x β DifferentiableAt π f x := by
rw [β differentiableWithinAt_univ, β differentiableWithinAt_univ,
iso.comp_differentiableWithinAt_iff]
#align continuous_linear_equiv.comp_differentiable_at_iff ContinuousLinearEquiv.comp_differentiableAt_iff
| Mathlib/Analysis/Calculus/FDeriv/Equiv.lean | 110 | 113 | theorem comp_differentiableOn_iff {f : G β E} {s : Set G} :
DifferentiableOn π (iso β f) s β DifferentiableOn π f s := by |
rw [DifferentiableOn, DifferentiableOn]
simp only [iso.comp_differentiableWithinAt_iff]
| 1,606 |
import Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.equiv from "leanprover-community/mathlib"@"e3fb84046afd187b710170887195d50bada934ee"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Filter Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
namespace ContinuousLinearEquiv
variable (iso : E βL[π] F)
@[fun_prop]
protected theorem hasStrictFDerivAt : HasStrictFDerivAt iso (iso : E βL[π] F) x :=
iso.toContinuousLinearMap.hasStrictFDerivAt
#align continuous_linear_equiv.has_strict_fderiv_at ContinuousLinearEquiv.hasStrictFDerivAt
@[fun_prop]
protected theorem hasFDerivWithinAt : HasFDerivWithinAt iso (iso : E βL[π] F) s x :=
iso.toContinuousLinearMap.hasFDerivWithinAt
#align continuous_linear_equiv.has_fderiv_within_at ContinuousLinearEquiv.hasFDerivWithinAt
@[fun_prop]
protected theorem hasFDerivAt : HasFDerivAt iso (iso : E βL[π] F) x :=
iso.toContinuousLinearMap.hasFDerivAtFilter
#align continuous_linear_equiv.has_fderiv_at ContinuousLinearEquiv.hasFDerivAt
@[fun_prop]
protected theorem differentiableAt : DifferentiableAt π iso x :=
iso.hasFDerivAt.differentiableAt
#align continuous_linear_equiv.differentiable_at ContinuousLinearEquiv.differentiableAt
@[fun_prop]
protected theorem differentiableWithinAt : DifferentiableWithinAt π iso s x :=
iso.differentiableAt.differentiableWithinAt
#align continuous_linear_equiv.differentiable_within_at ContinuousLinearEquiv.differentiableWithinAt
protected theorem fderiv : fderiv π iso x = iso :=
iso.hasFDerivAt.fderiv
#align continuous_linear_equiv.fderiv ContinuousLinearEquiv.fderiv
protected theorem fderivWithin (hxs : UniqueDiffWithinAt π s x) : fderivWithin π iso s x = iso :=
iso.toContinuousLinearMap.fderivWithin hxs
#align continuous_linear_equiv.fderiv_within ContinuousLinearEquiv.fderivWithin
@[fun_prop]
protected theorem differentiable : Differentiable π iso := fun _ => iso.differentiableAt
#align continuous_linear_equiv.differentiable ContinuousLinearEquiv.differentiable
@[fun_prop]
protected theorem differentiableOn : DifferentiableOn π iso s :=
iso.differentiable.differentiableOn
#align continuous_linear_equiv.differentiable_on ContinuousLinearEquiv.differentiableOn
theorem comp_differentiableWithinAt_iff {f : G β E} {s : Set G} {x : G} :
DifferentiableWithinAt π (iso β f) s x β DifferentiableWithinAt π f s x := by
refine
β¨fun H => ?_, fun H => iso.differentiable.differentiableAt.comp_differentiableWithinAt x Hβ©
have : DifferentiableWithinAt π (iso.symm β iso β f) s x :=
iso.symm.differentiable.differentiableAt.comp_differentiableWithinAt x H
rwa [β Function.comp.assoc iso.symm iso f, iso.symm_comp_self] at this
#align continuous_linear_equiv.comp_differentiable_within_at_iff ContinuousLinearEquiv.comp_differentiableWithinAt_iff
theorem comp_differentiableAt_iff {f : G β E} {x : G} :
DifferentiableAt π (iso β f) x β DifferentiableAt π f x := by
rw [β differentiableWithinAt_univ, β differentiableWithinAt_univ,
iso.comp_differentiableWithinAt_iff]
#align continuous_linear_equiv.comp_differentiable_at_iff ContinuousLinearEquiv.comp_differentiableAt_iff
theorem comp_differentiableOn_iff {f : G β E} {s : Set G} :
DifferentiableOn π (iso β f) s β DifferentiableOn π f s := by
rw [DifferentiableOn, DifferentiableOn]
simp only [iso.comp_differentiableWithinAt_iff]
#align continuous_linear_equiv.comp_differentiable_on_iff ContinuousLinearEquiv.comp_differentiableOn_iff
| Mathlib/Analysis/Calculus/FDeriv/Equiv.lean | 116 | 118 | theorem comp_differentiable_iff {f : G β E} : Differentiable π (iso β f) β Differentiable π f := by |
rw [β differentiableOn_univ, β differentiableOn_univ]
exact iso.comp_differentiableOn_iff
| 1,606 |
import Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.equiv from "leanprover-community/mathlib"@"e3fb84046afd187b710170887195d50bada934ee"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Filter Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
namespace ContinuousLinearEquiv
variable (iso : E βL[π] F)
@[fun_prop]
protected theorem hasStrictFDerivAt : HasStrictFDerivAt iso (iso : E βL[π] F) x :=
iso.toContinuousLinearMap.hasStrictFDerivAt
#align continuous_linear_equiv.has_strict_fderiv_at ContinuousLinearEquiv.hasStrictFDerivAt
@[fun_prop]
protected theorem hasFDerivWithinAt : HasFDerivWithinAt iso (iso : E βL[π] F) s x :=
iso.toContinuousLinearMap.hasFDerivWithinAt
#align continuous_linear_equiv.has_fderiv_within_at ContinuousLinearEquiv.hasFDerivWithinAt
@[fun_prop]
protected theorem hasFDerivAt : HasFDerivAt iso (iso : E βL[π] F) x :=
iso.toContinuousLinearMap.hasFDerivAtFilter
#align continuous_linear_equiv.has_fderiv_at ContinuousLinearEquiv.hasFDerivAt
@[fun_prop]
protected theorem differentiableAt : DifferentiableAt π iso x :=
iso.hasFDerivAt.differentiableAt
#align continuous_linear_equiv.differentiable_at ContinuousLinearEquiv.differentiableAt
@[fun_prop]
protected theorem differentiableWithinAt : DifferentiableWithinAt π iso s x :=
iso.differentiableAt.differentiableWithinAt
#align continuous_linear_equiv.differentiable_within_at ContinuousLinearEquiv.differentiableWithinAt
protected theorem fderiv : fderiv π iso x = iso :=
iso.hasFDerivAt.fderiv
#align continuous_linear_equiv.fderiv ContinuousLinearEquiv.fderiv
protected theorem fderivWithin (hxs : UniqueDiffWithinAt π s x) : fderivWithin π iso s x = iso :=
iso.toContinuousLinearMap.fderivWithin hxs
#align continuous_linear_equiv.fderiv_within ContinuousLinearEquiv.fderivWithin
@[fun_prop]
protected theorem differentiable : Differentiable π iso := fun _ => iso.differentiableAt
#align continuous_linear_equiv.differentiable ContinuousLinearEquiv.differentiable
@[fun_prop]
protected theorem differentiableOn : DifferentiableOn π iso s :=
iso.differentiable.differentiableOn
#align continuous_linear_equiv.differentiable_on ContinuousLinearEquiv.differentiableOn
theorem comp_differentiableWithinAt_iff {f : G β E} {s : Set G} {x : G} :
DifferentiableWithinAt π (iso β f) s x β DifferentiableWithinAt π f s x := by
refine
β¨fun H => ?_, fun H => iso.differentiable.differentiableAt.comp_differentiableWithinAt x Hβ©
have : DifferentiableWithinAt π (iso.symm β iso β f) s x :=
iso.symm.differentiable.differentiableAt.comp_differentiableWithinAt x H
rwa [β Function.comp.assoc iso.symm iso f, iso.symm_comp_self] at this
#align continuous_linear_equiv.comp_differentiable_within_at_iff ContinuousLinearEquiv.comp_differentiableWithinAt_iff
theorem comp_differentiableAt_iff {f : G β E} {x : G} :
DifferentiableAt π (iso β f) x β DifferentiableAt π f x := by
rw [β differentiableWithinAt_univ, β differentiableWithinAt_univ,
iso.comp_differentiableWithinAt_iff]
#align continuous_linear_equiv.comp_differentiable_at_iff ContinuousLinearEquiv.comp_differentiableAt_iff
theorem comp_differentiableOn_iff {f : G β E} {s : Set G} :
DifferentiableOn π (iso β f) s β DifferentiableOn π f s := by
rw [DifferentiableOn, DifferentiableOn]
simp only [iso.comp_differentiableWithinAt_iff]
#align continuous_linear_equiv.comp_differentiable_on_iff ContinuousLinearEquiv.comp_differentiableOn_iff
theorem comp_differentiable_iff {f : G β E} : Differentiable π (iso β f) β Differentiable π f := by
rw [β differentiableOn_univ, β differentiableOn_univ]
exact iso.comp_differentiableOn_iff
#align continuous_linear_equiv.comp_differentiable_iff ContinuousLinearEquiv.comp_differentiable_iff
| Mathlib/Analysis/Calculus/FDeriv/Equiv.lean | 121 | 130 | theorem comp_hasFDerivWithinAt_iff {f : G β E} {s : Set G} {x : G} {f' : G βL[π] E} :
HasFDerivWithinAt (iso β f) ((iso : E βL[π] F).comp f') s x β HasFDerivWithinAt f f' s x := by |
refine β¨fun H => ?_, fun H => iso.hasFDerivAt.comp_hasFDerivWithinAt x Hβ©
have A : f = iso.symm β iso β f := by
rw [β Function.comp.assoc, iso.symm_comp_self]
rfl
have B : f' = (iso.symm : F βL[π] E).comp ((iso : E βL[π] F).comp f') := by
rw [β ContinuousLinearMap.comp_assoc, iso.coe_symm_comp_coe, ContinuousLinearMap.id_comp]
rw [A, B]
exact iso.symm.hasFDerivAt.comp_hasFDerivWithinAt x H
| 1,606 |
import Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.equiv from "leanprover-community/mathlib"@"e3fb84046afd187b710170887195d50bada934ee"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Filter Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
namespace ContinuousLinearEquiv
variable (iso : E βL[π] F)
@[fun_prop]
protected theorem hasStrictFDerivAt : HasStrictFDerivAt iso (iso : E βL[π] F) x :=
iso.toContinuousLinearMap.hasStrictFDerivAt
#align continuous_linear_equiv.has_strict_fderiv_at ContinuousLinearEquiv.hasStrictFDerivAt
@[fun_prop]
protected theorem hasFDerivWithinAt : HasFDerivWithinAt iso (iso : E βL[π] F) s x :=
iso.toContinuousLinearMap.hasFDerivWithinAt
#align continuous_linear_equiv.has_fderiv_within_at ContinuousLinearEquiv.hasFDerivWithinAt
@[fun_prop]
protected theorem hasFDerivAt : HasFDerivAt iso (iso : E βL[π] F) x :=
iso.toContinuousLinearMap.hasFDerivAtFilter
#align continuous_linear_equiv.has_fderiv_at ContinuousLinearEquiv.hasFDerivAt
@[fun_prop]
protected theorem differentiableAt : DifferentiableAt π iso x :=
iso.hasFDerivAt.differentiableAt
#align continuous_linear_equiv.differentiable_at ContinuousLinearEquiv.differentiableAt
@[fun_prop]
protected theorem differentiableWithinAt : DifferentiableWithinAt π iso s x :=
iso.differentiableAt.differentiableWithinAt
#align continuous_linear_equiv.differentiable_within_at ContinuousLinearEquiv.differentiableWithinAt
protected theorem fderiv : fderiv π iso x = iso :=
iso.hasFDerivAt.fderiv
#align continuous_linear_equiv.fderiv ContinuousLinearEquiv.fderiv
protected theorem fderivWithin (hxs : UniqueDiffWithinAt π s x) : fderivWithin π iso s x = iso :=
iso.toContinuousLinearMap.fderivWithin hxs
#align continuous_linear_equiv.fderiv_within ContinuousLinearEquiv.fderivWithin
@[fun_prop]
protected theorem differentiable : Differentiable π iso := fun _ => iso.differentiableAt
#align continuous_linear_equiv.differentiable ContinuousLinearEquiv.differentiable
@[fun_prop]
protected theorem differentiableOn : DifferentiableOn π iso s :=
iso.differentiable.differentiableOn
#align continuous_linear_equiv.differentiable_on ContinuousLinearEquiv.differentiableOn
theorem comp_differentiableWithinAt_iff {f : G β E} {s : Set G} {x : G} :
DifferentiableWithinAt π (iso β f) s x β DifferentiableWithinAt π f s x := by
refine
β¨fun H => ?_, fun H => iso.differentiable.differentiableAt.comp_differentiableWithinAt x Hβ©
have : DifferentiableWithinAt π (iso.symm β iso β f) s x :=
iso.symm.differentiable.differentiableAt.comp_differentiableWithinAt x H
rwa [β Function.comp.assoc iso.symm iso f, iso.symm_comp_self] at this
#align continuous_linear_equiv.comp_differentiable_within_at_iff ContinuousLinearEquiv.comp_differentiableWithinAt_iff
theorem comp_differentiableAt_iff {f : G β E} {x : G} :
DifferentiableAt π (iso β f) x β DifferentiableAt π f x := by
rw [β differentiableWithinAt_univ, β differentiableWithinAt_univ,
iso.comp_differentiableWithinAt_iff]
#align continuous_linear_equiv.comp_differentiable_at_iff ContinuousLinearEquiv.comp_differentiableAt_iff
theorem comp_differentiableOn_iff {f : G β E} {s : Set G} :
DifferentiableOn π (iso β f) s β DifferentiableOn π f s := by
rw [DifferentiableOn, DifferentiableOn]
simp only [iso.comp_differentiableWithinAt_iff]
#align continuous_linear_equiv.comp_differentiable_on_iff ContinuousLinearEquiv.comp_differentiableOn_iff
theorem comp_differentiable_iff {f : G β E} : Differentiable π (iso β f) β Differentiable π f := by
rw [β differentiableOn_univ, β differentiableOn_univ]
exact iso.comp_differentiableOn_iff
#align continuous_linear_equiv.comp_differentiable_iff ContinuousLinearEquiv.comp_differentiable_iff
theorem comp_hasFDerivWithinAt_iff {f : G β E} {s : Set G} {x : G} {f' : G βL[π] E} :
HasFDerivWithinAt (iso β f) ((iso : E βL[π] F).comp f') s x β HasFDerivWithinAt f f' s x := by
refine β¨fun H => ?_, fun H => iso.hasFDerivAt.comp_hasFDerivWithinAt x Hβ©
have A : f = iso.symm β iso β f := by
rw [β Function.comp.assoc, iso.symm_comp_self]
rfl
have B : f' = (iso.symm : F βL[π] E).comp ((iso : E βL[π] F).comp f') := by
rw [β ContinuousLinearMap.comp_assoc, iso.coe_symm_comp_coe, ContinuousLinearMap.id_comp]
rw [A, B]
exact iso.symm.hasFDerivAt.comp_hasFDerivWithinAt x H
#align continuous_linear_equiv.comp_has_fderiv_within_at_iff ContinuousLinearEquiv.comp_hasFDerivWithinAt_iff
| Mathlib/Analysis/Calculus/FDeriv/Equiv.lean | 133 | 137 | theorem comp_hasStrictFDerivAt_iff {f : G β E} {x : G} {f' : G βL[π] E} :
HasStrictFDerivAt (iso β f) ((iso : E βL[π] F).comp f') x β HasStrictFDerivAt f f' x := by |
refine β¨fun H => ?_, fun H => iso.hasStrictFDerivAt.comp x Hβ©
convert iso.symm.hasStrictFDerivAt.comp x H using 1 <;>
ext z <;> apply (iso.symm_apply_apply _).symm
| 1,606 |
import Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.equiv from "leanprover-community/mathlib"@"e3fb84046afd187b710170887195d50bada934ee"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Filter Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
| Mathlib/Analysis/Calculus/FDeriv/Equiv.lean | 391 | 410 | theorem HasStrictFDerivAt.of_local_left_inverse {f : E β F} {f' : E βL[π] F} {g : F β E} {a : F}
(hg : ContinuousAt g a) (hf : HasStrictFDerivAt f (f' : E βL[π] F) (g a))
(hfg : βαΆ y in π a, f (g y) = y) : HasStrictFDerivAt g (f'.symm : F βL[π] E) a := by |
replace hg := hg.prod_map' hg
replace hfg := hfg.prod_mk_nhds hfg
have :
(fun p : F Γ F => g p.1 - g p.2 - f'.symm (p.1 - p.2)) =O[π (a, a)] fun p : F Γ F =>
f' (g p.1 - g p.2) - (p.1 - p.2) := by
refine ((f'.symm : F βL[π] E).isBigO_comp _ _).congr (fun x => ?_) fun _ => rfl
simp
refine this.trans_isLittleO ?_
clear this
refine ((hf.comp_tendsto hg).symm.congr'
(hfg.mono ?_) (eventually_of_forall fun _ => rfl)).trans_isBigO ?_
Β· rintro p β¨hp1, hp2β©
simp [hp1, hp2]
Β· refine (hf.isBigO_sub_rev.comp_tendsto hg).congr' (eventually_of_forall fun _ => rfl)
(hfg.mono ?_)
rintro p β¨hp1, hp2β©
simp only [(Β· β Β·), hp1, hp2]
| 1,606 |
import Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.equiv from "leanprover-community/mathlib"@"e3fb84046afd187b710170887195d50bada934ee"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Filter Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
theorem HasStrictFDerivAt.of_local_left_inverse {f : E β F} {f' : E βL[π] F} {g : F β E} {a : F}
(hg : ContinuousAt g a) (hf : HasStrictFDerivAt f (f' : E βL[π] F) (g a))
(hfg : βαΆ y in π a, f (g y) = y) : HasStrictFDerivAt g (f'.symm : F βL[π] E) a := by
replace hg := hg.prod_map' hg
replace hfg := hfg.prod_mk_nhds hfg
have :
(fun p : F Γ F => g p.1 - g p.2 - f'.symm (p.1 - p.2)) =O[π (a, a)] fun p : F Γ F =>
f' (g p.1 - g p.2) - (p.1 - p.2) := by
refine ((f'.symm : F βL[π] E).isBigO_comp _ _).congr (fun x => ?_) fun _ => rfl
simp
refine this.trans_isLittleO ?_
clear this
refine ((hf.comp_tendsto hg).symm.congr'
(hfg.mono ?_) (eventually_of_forall fun _ => rfl)).trans_isBigO ?_
Β· rintro p β¨hp1, hp2β©
simp [hp1, hp2]
Β· refine (hf.isBigO_sub_rev.comp_tendsto hg).congr' (eventually_of_forall fun _ => rfl)
(hfg.mono ?_)
rintro p β¨hp1, hp2β©
simp only [(Β· β Β·), hp1, hp2]
#align has_strict_fderiv_at.of_local_left_inverse HasStrictFDerivAt.of_local_left_inverse
| Mathlib/Analysis/Calculus/FDeriv/Equiv.lean | 418 | 433 | theorem HasFDerivAt.of_local_left_inverse {f : E β F} {f' : E βL[π] F} {g : F β E} {a : F}
(hg : ContinuousAt g a) (hf : HasFDerivAt f (f' : E βL[π] F) (g a))
(hfg : βαΆ y in π a, f (g y) = y) : HasFDerivAt g (f'.symm : F βL[π] E) a := by |
have : (fun x : F => g x - g a - f'.symm (x - a)) =O[π a]
fun x : F => f' (g x - g a) - (x - a) := by
refine ((f'.symm : F βL[π] E).isBigO_comp _ _).congr (fun x => ?_) fun _ => rfl
simp
refine HasFDerivAtFilter.of_isLittleO <| this.trans_isLittleO ?_
clear this
refine ((hf.isLittleO.comp_tendsto hg).symm.congr' (hfg.mono ?_) .rfl).trans_isBigO ?_
Β· intro p hp
simp [hp, hfg.self_of_nhds]
Β· refine ((hf.isBigO_sub_rev f'.antilipschitz).comp_tendsto hg).congr'
(eventually_of_forall fun _ => rfl) (hfg.mono ?_)
rintro p hp
simp only [(Β· β Β·), hp, hfg.self_of_nhds]
| 1,606 |
import Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.equiv from "leanprover-community/mathlib"@"e3fb84046afd187b710170887195d50bada934ee"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal Filter Asymptotics ENNReal
noncomputable section
section
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
variable {G : Type*} [NormedAddCommGroup G] [NormedSpace π G]
variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace π G']
variable {f fβ fβ g : E β F}
variable {f' fβ' fβ' g' : E βL[π] F}
variable (e : E βL[π] F)
variable {x : E}
variable {s t : Set E}
variable {L Lβ Lβ : Filter E}
theorem HasStrictFDerivAt.of_local_left_inverse {f : E β F} {f' : E βL[π] F} {g : F β E} {a : F}
(hg : ContinuousAt g a) (hf : HasStrictFDerivAt f (f' : E βL[π] F) (g a))
(hfg : βαΆ y in π a, f (g y) = y) : HasStrictFDerivAt g (f'.symm : F βL[π] E) a := by
replace hg := hg.prod_map' hg
replace hfg := hfg.prod_mk_nhds hfg
have :
(fun p : F Γ F => g p.1 - g p.2 - f'.symm (p.1 - p.2)) =O[π (a, a)] fun p : F Γ F =>
f' (g p.1 - g p.2) - (p.1 - p.2) := by
refine ((f'.symm : F βL[π] E).isBigO_comp _ _).congr (fun x => ?_) fun _ => rfl
simp
refine this.trans_isLittleO ?_
clear this
refine ((hf.comp_tendsto hg).symm.congr'
(hfg.mono ?_) (eventually_of_forall fun _ => rfl)).trans_isBigO ?_
Β· rintro p β¨hp1, hp2β©
simp [hp1, hp2]
Β· refine (hf.isBigO_sub_rev.comp_tendsto hg).congr' (eventually_of_forall fun _ => rfl)
(hfg.mono ?_)
rintro p β¨hp1, hp2β©
simp only [(Β· β Β·), hp1, hp2]
#align has_strict_fderiv_at.of_local_left_inverse HasStrictFDerivAt.of_local_left_inverse
theorem HasFDerivAt.of_local_left_inverse {f : E β F} {f' : E βL[π] F} {g : F β E} {a : F}
(hg : ContinuousAt g a) (hf : HasFDerivAt f (f' : E βL[π] F) (g a))
(hfg : βαΆ y in π a, f (g y) = y) : HasFDerivAt g (f'.symm : F βL[π] E) a := by
have : (fun x : F => g x - g a - f'.symm (x - a)) =O[π a]
fun x : F => f' (g x - g a) - (x - a) := by
refine ((f'.symm : F βL[π] E).isBigO_comp _ _).congr (fun x => ?_) fun _ => rfl
simp
refine HasFDerivAtFilter.of_isLittleO <| this.trans_isLittleO ?_
clear this
refine ((hf.isLittleO.comp_tendsto hg).symm.congr' (hfg.mono ?_) .rfl).trans_isBigO ?_
Β· intro p hp
simp [hp, hfg.self_of_nhds]
Β· refine ((hf.isBigO_sub_rev f'.antilipschitz).comp_tendsto hg).congr'
(eventually_of_forall fun _ => rfl) (hfg.mono ?_)
rintro p hp
simp only [(Β· β Β·), hp, hfg.self_of_nhds]
#align has_fderiv_at.of_local_left_inverse HasFDerivAt.of_local_left_inverse
theorem PartialHomeomorph.hasStrictFDerivAt_symm (f : PartialHomeomorph E F) {f' : E βL[π] F}
{a : F} (ha : a β f.target) (htff' : HasStrictFDerivAt f (f' : E βL[π] F) (f.symm a)) :
HasStrictFDerivAt f.symm (f'.symm : F βL[π] E) a :=
htff'.of_local_left_inverse (f.symm.continuousAt ha) (f.eventually_right_inverse ha)
#align local_homeomorph.has_strict_fderiv_at_symm PartialHomeomorph.hasStrictFDerivAt_symm
theorem PartialHomeomorph.hasFDerivAt_symm (f : PartialHomeomorph E F) {f' : E βL[π] F} {a : F}
(ha : a β f.target) (htff' : HasFDerivAt f (f' : E βL[π] F) (f.symm a)) :
HasFDerivAt f.symm (f'.symm : F βL[π] E) a :=
htff'.of_local_left_inverse (f.symm.continuousAt ha) (f.eventually_right_inverse ha)
#align local_homeomorph.has_fderiv_at_symm PartialHomeomorph.hasFDerivAt_symm
| Mathlib/Analysis/Calculus/FDeriv/Equiv.lean | 459 | 465 | theorem HasFDerivWithinAt.eventually_ne (h : HasFDerivWithinAt f f' s x)
(hf' : β C, β z, βzβ β€ C * βf' zβ) : βαΆ z in π[s \ {x}] x, f z β f x := by |
rw [nhdsWithin, diff_eq, β inf_principal, β inf_assoc, eventually_inf_principal]
have A : (fun z => z - x) =O[π[s] x] fun z => f' (z - x) :=
isBigO_iff.2 <| hf'.imp fun C hC => eventually_of_forall fun z => hC _
have : (fun z => f z - f x) ~[π[s] x] fun z => f' (z - x) := h.isLittleO.trans_isBigO A
simpa [not_imp_not, sub_eq_zero] using (A.trans this.isBigO_symm).eq_zero_imp
| 1,606 |
import Mathlib.Analysis.Calculus.FDeriv.Equiv
import Mathlib.Analysis.Calculus.FormalMultilinearSeries
#align_import analysis.calculus.cont_diff_def from "leanprover-community/mathlib"@"3a69562db5a458db8322b190ec8d9a8bbd8a5b14"
noncomputable section
open scoped Classical
open NNReal Topology Filter
local notation "β" => (β€ : ββ)
open Set Fin Filter Function
universe u uE uF uG uX
variable {π : Type u} [NontriviallyNormedField π] {E : Type uE} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type uF} [NormedAddCommGroup F] [NormedSpace π F] {G : Type uG}
[NormedAddCommGroup G] [NormedSpace π G] {X : Type uX} [NormedAddCommGroup X] [NormedSpace π X]
{s sβ t u : Set E} {f fβ : E β F} {g : F β G} {x xβ : E} {c : F} {m n : ββ}
{p : E β FormalMultilinearSeries π E F}
structure HasFTaylorSeriesUpToOn (n : ββ) (f : E β F) (p : E β FormalMultilinearSeries π E F)
(s : Set E) : Prop where
zero_eq : β x β s, (p x 0).uncurry0 = f x
protected fderivWithin : β m : β, (m : ββ) < n β β x β s,
HasFDerivWithinAt (p Β· m) (p x m.succ).curryLeft s x
cont : β m : β, (m : ββ) β€ n β ContinuousOn (p Β· m) s
#align has_ftaylor_series_up_to_on HasFTaylorSeriesUpToOn
| Mathlib/Analysis/Calculus/ContDiff/Defs.lean | 196 | 199 | theorem HasFTaylorSeriesUpToOn.zero_eq' (h : HasFTaylorSeriesUpToOn n f p s) {x : E} (hx : x β s) :
p x 0 = (continuousMultilinearCurryFin0 π E F).symm (f x) := by |
rw [β h.zero_eq x hx]
exact (p x 0).uncurry0_curry0.symm
| 1,607 |
import Mathlib.Analysis.Calculus.FDeriv.Equiv
import Mathlib.Analysis.Calculus.FormalMultilinearSeries
#align_import analysis.calculus.cont_diff_def from "leanprover-community/mathlib"@"3a69562db5a458db8322b190ec8d9a8bbd8a5b14"
noncomputable section
open scoped Classical
open NNReal Topology Filter
local notation "β" => (β€ : ββ)
open Set Fin Filter Function
universe u uE uF uG uX
variable {π : Type u} [NontriviallyNormedField π] {E : Type uE} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type uF} [NormedAddCommGroup F] [NormedSpace π F] {G : Type uG}
[NormedAddCommGroup G] [NormedSpace π G] {X : Type uX} [NormedAddCommGroup X] [NormedSpace π X]
{s sβ t u : Set E} {f fβ : E β F} {g : F β G} {x xβ : E} {c : F} {m n : ββ}
{p : E β FormalMultilinearSeries π E F}
structure HasFTaylorSeriesUpToOn (n : ββ) (f : E β F) (p : E β FormalMultilinearSeries π E F)
(s : Set E) : Prop where
zero_eq : β x β s, (p x 0).uncurry0 = f x
protected fderivWithin : β m : β, (m : ββ) < n β β x β s,
HasFDerivWithinAt (p Β· m) (p x m.succ).curryLeft s x
cont : β m : β, (m : ββ) β€ n β ContinuousOn (p Β· m) s
#align has_ftaylor_series_up_to_on HasFTaylorSeriesUpToOn
theorem HasFTaylorSeriesUpToOn.zero_eq' (h : HasFTaylorSeriesUpToOn n f p s) {x : E} (hx : x β s) :
p x 0 = (continuousMultilinearCurryFin0 π E F).symm (f x) := by
rw [β h.zero_eq x hx]
exact (p x 0).uncurry0_curry0.symm
#align has_ftaylor_series_up_to_on.zero_eq' HasFTaylorSeriesUpToOn.zero_eq'
| Mathlib/Analysis/Calculus/ContDiff/Defs.lean | 204 | 208 | theorem HasFTaylorSeriesUpToOn.congr (h : HasFTaylorSeriesUpToOn n f p s)
(hβ : β x β s, fβ x = f x) : HasFTaylorSeriesUpToOn n fβ p s := by |
refine β¨fun x hx => ?_, h.fderivWithin, h.contβ©
rw [hβ x hx]
exact h.zero_eq x hx
| 1,607 |
import Mathlib.Analysis.Calculus.FDeriv.Equiv
import Mathlib.Analysis.Calculus.FormalMultilinearSeries
#align_import analysis.calculus.cont_diff_def from "leanprover-community/mathlib"@"3a69562db5a458db8322b190ec8d9a8bbd8a5b14"
noncomputable section
open scoped Classical
open NNReal Topology Filter
local notation "β" => (β€ : ββ)
open Set Fin Filter Function
universe u uE uF uG uX
variable {π : Type u} [NontriviallyNormedField π] {E : Type uE} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type uF} [NormedAddCommGroup F] [NormedSpace π F] {G : Type uG}
[NormedAddCommGroup G] [NormedSpace π G] {X : Type uX} [NormedAddCommGroup X] [NormedSpace π X]
{s sβ t u : Set E} {f fβ : E β F} {g : F β G} {x xβ : E} {c : F} {m n : ββ}
{p : E β FormalMultilinearSeries π E F}
structure HasFTaylorSeriesUpToOn (n : ββ) (f : E β F) (p : E β FormalMultilinearSeries π E F)
(s : Set E) : Prop where
zero_eq : β x β s, (p x 0).uncurry0 = f x
protected fderivWithin : β m : β, (m : ββ) < n β β x β s,
HasFDerivWithinAt (p Β· m) (p x m.succ).curryLeft s x
cont : β m : β, (m : ββ) β€ n β ContinuousOn (p Β· m) s
#align has_ftaylor_series_up_to_on HasFTaylorSeriesUpToOn
theorem HasFTaylorSeriesUpToOn.zero_eq' (h : HasFTaylorSeriesUpToOn n f p s) {x : E} (hx : x β s) :
p x 0 = (continuousMultilinearCurryFin0 π E F).symm (f x) := by
rw [β h.zero_eq x hx]
exact (p x 0).uncurry0_curry0.symm
#align has_ftaylor_series_up_to_on.zero_eq' HasFTaylorSeriesUpToOn.zero_eq'
theorem HasFTaylorSeriesUpToOn.congr (h : HasFTaylorSeriesUpToOn n f p s)
(hβ : β x β s, fβ x = f x) : HasFTaylorSeriesUpToOn n fβ p s := by
refine β¨fun x hx => ?_, h.fderivWithin, h.contβ©
rw [hβ x hx]
exact h.zero_eq x hx
#align has_ftaylor_series_up_to_on.congr HasFTaylorSeriesUpToOn.congr
theorem HasFTaylorSeriesUpToOn.mono (h : HasFTaylorSeriesUpToOn n f p s) {t : Set E} (hst : t β s) :
HasFTaylorSeriesUpToOn n f p t :=
β¨fun x hx => h.zero_eq x (hst hx), fun m hm x hx => (h.fderivWithin m hm x (hst hx)).mono hst,
fun m hm => (h.cont m hm).mono hstβ©
#align has_ftaylor_series_up_to_on.mono HasFTaylorSeriesUpToOn.mono
theorem HasFTaylorSeriesUpToOn.of_le (h : HasFTaylorSeriesUpToOn n f p s) (hmn : m β€ n) :
HasFTaylorSeriesUpToOn m f p s :=
β¨h.zero_eq, fun k hk x hx => h.fderivWithin k (lt_of_lt_of_le hk hmn) x hx, fun k hk =>
h.cont k (le_trans hk hmn)β©
#align has_ftaylor_series_up_to_on.of_le HasFTaylorSeriesUpToOn.of_le
| Mathlib/Analysis/Calculus/ContDiff/Defs.lean | 223 | 226 | theorem HasFTaylorSeriesUpToOn.continuousOn (h : HasFTaylorSeriesUpToOn n f p s) :
ContinuousOn f s := by |
have := (h.cont 0 bot_le).congr fun x hx => (h.zero_eq' hx).symm
rwa [β (continuousMultilinearCurryFin0 π E F).symm.comp_continuousOn_iff]
| 1,607 |
import Mathlib.Analysis.Calculus.FDeriv.Equiv
import Mathlib.Analysis.Calculus.FormalMultilinearSeries
#align_import analysis.calculus.cont_diff_def from "leanprover-community/mathlib"@"3a69562db5a458db8322b190ec8d9a8bbd8a5b14"
noncomputable section
open scoped Classical
open NNReal Topology Filter
local notation "β" => (β€ : ββ)
open Set Fin Filter Function
universe u uE uF uG uX
variable {π : Type u} [NontriviallyNormedField π] {E : Type uE} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type uF} [NormedAddCommGroup F] [NormedSpace π F] {G : Type uG}
[NormedAddCommGroup G] [NormedSpace π G] {X : Type uX} [NormedAddCommGroup X] [NormedSpace π X]
{s sβ t u : Set E} {f fβ : E β F} {g : F β G} {x xβ : E} {c : F} {m n : ββ}
{p : E β FormalMultilinearSeries π E F}
structure HasFTaylorSeriesUpToOn (n : ββ) (f : E β F) (p : E β FormalMultilinearSeries π E F)
(s : Set E) : Prop where
zero_eq : β x β s, (p x 0).uncurry0 = f x
protected fderivWithin : β m : β, (m : ββ) < n β β x β s,
HasFDerivWithinAt (p Β· m) (p x m.succ).curryLeft s x
cont : β m : β, (m : ββ) β€ n β ContinuousOn (p Β· m) s
#align has_ftaylor_series_up_to_on HasFTaylorSeriesUpToOn
theorem HasFTaylorSeriesUpToOn.zero_eq' (h : HasFTaylorSeriesUpToOn n f p s) {x : E} (hx : x β s) :
p x 0 = (continuousMultilinearCurryFin0 π E F).symm (f x) := by
rw [β h.zero_eq x hx]
exact (p x 0).uncurry0_curry0.symm
#align has_ftaylor_series_up_to_on.zero_eq' HasFTaylorSeriesUpToOn.zero_eq'
theorem HasFTaylorSeriesUpToOn.congr (h : HasFTaylorSeriesUpToOn n f p s)
(hβ : β x β s, fβ x = f x) : HasFTaylorSeriesUpToOn n fβ p s := by
refine β¨fun x hx => ?_, h.fderivWithin, h.contβ©
rw [hβ x hx]
exact h.zero_eq x hx
#align has_ftaylor_series_up_to_on.congr HasFTaylorSeriesUpToOn.congr
theorem HasFTaylorSeriesUpToOn.mono (h : HasFTaylorSeriesUpToOn n f p s) {t : Set E} (hst : t β s) :
HasFTaylorSeriesUpToOn n f p t :=
β¨fun x hx => h.zero_eq x (hst hx), fun m hm x hx => (h.fderivWithin m hm x (hst hx)).mono hst,
fun m hm => (h.cont m hm).mono hstβ©
#align has_ftaylor_series_up_to_on.mono HasFTaylorSeriesUpToOn.mono
theorem HasFTaylorSeriesUpToOn.of_le (h : HasFTaylorSeriesUpToOn n f p s) (hmn : m β€ n) :
HasFTaylorSeriesUpToOn m f p s :=
β¨h.zero_eq, fun k hk x hx => h.fderivWithin k (lt_of_lt_of_le hk hmn) x hx, fun k hk =>
h.cont k (le_trans hk hmn)β©
#align has_ftaylor_series_up_to_on.of_le HasFTaylorSeriesUpToOn.of_le
theorem HasFTaylorSeriesUpToOn.continuousOn (h : HasFTaylorSeriesUpToOn n f p s) :
ContinuousOn f s := by
have := (h.cont 0 bot_le).congr fun x hx => (h.zero_eq' hx).symm
rwa [β (continuousMultilinearCurryFin0 π E F).symm.comp_continuousOn_iff]
#align has_ftaylor_series_up_to_on.continuous_on HasFTaylorSeriesUpToOn.continuousOn
| Mathlib/Analysis/Calculus/ContDiff/Defs.lean | 229 | 237 | theorem hasFTaylorSeriesUpToOn_zero_iff :
HasFTaylorSeriesUpToOn 0 f p s β ContinuousOn f s β§ β x β s, (p x 0).uncurry0 = f x := by |
refine β¨fun H => β¨H.continuousOn, H.zero_eqβ©, fun H =>
β¨H.2, fun m hm => False.elim (not_le.2 hm bot_le), fun m hm β¦ ?_β©β©
obtain rfl : m = 0 := mod_cast hm.antisymm (zero_le _)
have : EqOn (p Β· 0) ((continuousMultilinearCurryFin0 π E F).symm β f) s := fun x hx β¦
(continuousMultilinearCurryFin0 π E F).eq_symm_apply.2 (H.2 x hx)
rw [continuousOn_congr this, LinearIsometryEquiv.comp_continuousOn_iff]
exact H.1
| 1,607 |
import Mathlib.Analysis.Calculus.FDeriv.Equiv
import Mathlib.Analysis.Calculus.FormalMultilinearSeries
#align_import analysis.calculus.cont_diff_def from "leanprover-community/mathlib"@"3a69562db5a458db8322b190ec8d9a8bbd8a5b14"
noncomputable section
open scoped Classical
open NNReal Topology Filter
local notation "β" => (β€ : ββ)
open Set Fin Filter Function
universe u uE uF uG uX
variable {π : Type u} [NontriviallyNormedField π] {E : Type uE} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type uF} [NormedAddCommGroup F] [NormedSpace π F] {G : Type uG}
[NormedAddCommGroup G] [NormedSpace π G] {X : Type uX} [NormedAddCommGroup X] [NormedSpace π X]
{s sβ t u : Set E} {f fβ : E β F} {g : F β G} {x xβ : E} {c : F} {m n : ββ}
{p : E β FormalMultilinearSeries π E F}
structure HasFTaylorSeriesUpToOn (n : ββ) (f : E β F) (p : E β FormalMultilinearSeries π E F)
(s : Set E) : Prop where
zero_eq : β x β s, (p x 0).uncurry0 = f x
protected fderivWithin : β m : β, (m : ββ) < n β β x β s,
HasFDerivWithinAt (p Β· m) (p x m.succ).curryLeft s x
cont : β m : β, (m : ββ) β€ n β ContinuousOn (p Β· m) s
#align has_ftaylor_series_up_to_on HasFTaylorSeriesUpToOn
theorem HasFTaylorSeriesUpToOn.zero_eq' (h : HasFTaylorSeriesUpToOn n f p s) {x : E} (hx : x β s) :
p x 0 = (continuousMultilinearCurryFin0 π E F).symm (f x) := by
rw [β h.zero_eq x hx]
exact (p x 0).uncurry0_curry0.symm
#align has_ftaylor_series_up_to_on.zero_eq' HasFTaylorSeriesUpToOn.zero_eq'
theorem HasFTaylorSeriesUpToOn.congr (h : HasFTaylorSeriesUpToOn n f p s)
(hβ : β x β s, fβ x = f x) : HasFTaylorSeriesUpToOn n fβ p s := by
refine β¨fun x hx => ?_, h.fderivWithin, h.contβ©
rw [hβ x hx]
exact h.zero_eq x hx
#align has_ftaylor_series_up_to_on.congr HasFTaylorSeriesUpToOn.congr
theorem HasFTaylorSeriesUpToOn.mono (h : HasFTaylorSeriesUpToOn n f p s) {t : Set E} (hst : t β s) :
HasFTaylorSeriesUpToOn n f p t :=
β¨fun x hx => h.zero_eq x (hst hx), fun m hm x hx => (h.fderivWithin m hm x (hst hx)).mono hst,
fun m hm => (h.cont m hm).mono hstβ©
#align has_ftaylor_series_up_to_on.mono HasFTaylorSeriesUpToOn.mono
theorem HasFTaylorSeriesUpToOn.of_le (h : HasFTaylorSeriesUpToOn n f p s) (hmn : m β€ n) :
HasFTaylorSeriesUpToOn m f p s :=
β¨h.zero_eq, fun k hk x hx => h.fderivWithin k (lt_of_lt_of_le hk hmn) x hx, fun k hk =>
h.cont k (le_trans hk hmn)β©
#align has_ftaylor_series_up_to_on.of_le HasFTaylorSeriesUpToOn.of_le
theorem HasFTaylorSeriesUpToOn.continuousOn (h : HasFTaylorSeriesUpToOn n f p s) :
ContinuousOn f s := by
have := (h.cont 0 bot_le).congr fun x hx => (h.zero_eq' hx).symm
rwa [β (continuousMultilinearCurryFin0 π E F).symm.comp_continuousOn_iff]
#align has_ftaylor_series_up_to_on.continuous_on HasFTaylorSeriesUpToOn.continuousOn
theorem hasFTaylorSeriesUpToOn_zero_iff :
HasFTaylorSeriesUpToOn 0 f p s β ContinuousOn f s β§ β x β s, (p x 0).uncurry0 = f x := by
refine β¨fun H => β¨H.continuousOn, H.zero_eqβ©, fun H =>
β¨H.2, fun m hm => False.elim (not_le.2 hm bot_le), fun m hm β¦ ?_β©β©
obtain rfl : m = 0 := mod_cast hm.antisymm (zero_le _)
have : EqOn (p Β· 0) ((continuousMultilinearCurryFin0 π E F).symm β f) s := fun x hx β¦
(continuousMultilinearCurryFin0 π E F).eq_symm_apply.2 (H.2 x hx)
rw [continuousOn_congr this, LinearIsometryEquiv.comp_continuousOn_iff]
exact H.1
#align has_ftaylor_series_up_to_on_zero_iff hasFTaylorSeriesUpToOn_zero_iff
| Mathlib/Analysis/Calculus/ContDiff/Defs.lean | 240 | 250 | theorem hasFTaylorSeriesUpToOn_top_iff :
HasFTaylorSeriesUpToOn β f p s β β n : β, HasFTaylorSeriesUpToOn n f p s := by |
constructor
Β· intro H n; exact H.of_le le_top
Β· intro H
constructor
Β· exact (H 0).zero_eq
Β· intro m _
apply (H m.succ).fderivWithin m (WithTop.coe_lt_coe.2 (lt_add_one m))
Β· intro m _
apply (H m).cont m le_rfl
| 1,607 |
import Mathlib.Analysis.NormedSpace.BoundedLinearMaps
import Mathlib.Topology.FiberBundle.Basic
#align_import topology.vector_bundle.basic from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"
noncomputable section
open scoped Classical
open Bundle Set
open scoped Topology
variable (R : Type*) {B : Type*} (F : Type*) (E : B β Type*)
section TopologicalVectorSpace
variable {F E}
variable [Semiring R] [TopologicalSpace F] [TopologicalSpace B]
protected class Pretrivialization.IsLinear [AddCommMonoid F] [Module R F] [β x, AddCommMonoid (E x)]
[β x, Module R (E x)] (e : Pretrivialization F (Ο F E)) : Prop where
linear : β b β e.baseSet, IsLinearMap R fun x : E b => (e β¨b, xβ©).2
#align pretrivialization.is_linear Pretrivialization.IsLinear
namespace Pretrivialization
variable (e : Pretrivialization F (Ο F E)) {x : TotalSpace F E} {b : B} {y : E b}
theorem linear [AddCommMonoid F] [Module R F] [β x, AddCommMonoid (E x)] [β x, Module R (E x)]
[e.IsLinear R] {b : B} (hb : b β e.baseSet) :
IsLinearMap R fun x : E b => (e β¨b, xβ©).2 :=
Pretrivialization.IsLinear.linear b hb
#align pretrivialization.linear Pretrivialization.linear
variable [AddCommMonoid F] [Module R F] [β x, AddCommMonoid (E x)] [β x, Module R (E x)]
@[simps!]
protected def symmβ (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) : F ββ[R] E b := by
refine IsLinearMap.mk' (e.symm b) ?_
by_cases hb : b β e.baseSet
Β· exact (((e.linear R hb).mk' _).inverse (e.symm b) (e.symm_apply_apply_mk hb) fun v β¦
congr_arg Prod.snd <| e.apply_mk_symm hb v).isLinear
Β· rw [e.coe_symm_of_not_mem hb]
exact (0 : F ββ[R] E b).isLinear
#align pretrivialization.symmβ Pretrivialization.symmβ
@[simps (config := .asFn)]
def linearEquivAt (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) (hb : b β e.baseSet) :
E b ββ[R] F where
toFun y := (e β¨b, yβ©).2
invFun := e.symm b
left_inv := e.symm_apply_apply_mk hb
right_inv v := by simp_rw [e.apply_mk_symm hb v]
map_add' v w := (e.linear R hb).map_add v w
map_smul' c v := (e.linear R hb).map_smul c v
#align pretrivialization.linear_equiv_at Pretrivialization.linearEquivAt
protected def linearMapAt (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) : E b ββ[R] F :=
if hb : b β e.baseSet then e.linearEquivAt R b hb else 0
#align pretrivialization.linear_map_at Pretrivialization.linearMapAt
variable {R}
| Mathlib/Topology/VectorBundle/Basic.lean | 120 | 123 | theorem coe_linearMapAt (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) :
β(e.linearMapAt R b) = fun y => if b β e.baseSet then (e β¨b, yβ©).2 else 0 := by |
rw [Pretrivialization.linearMapAt]
split_ifs <;> rfl
| 1,608 |
import Mathlib.Analysis.NormedSpace.BoundedLinearMaps
import Mathlib.Topology.FiberBundle.Basic
#align_import topology.vector_bundle.basic from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"
noncomputable section
open scoped Classical
open Bundle Set
open scoped Topology
variable (R : Type*) {B : Type*} (F : Type*) (E : B β Type*)
section TopologicalVectorSpace
variable {F E}
variable [Semiring R] [TopologicalSpace F] [TopologicalSpace B]
protected class Pretrivialization.IsLinear [AddCommMonoid F] [Module R F] [β x, AddCommMonoid (E x)]
[β x, Module R (E x)] (e : Pretrivialization F (Ο F E)) : Prop where
linear : β b β e.baseSet, IsLinearMap R fun x : E b => (e β¨b, xβ©).2
#align pretrivialization.is_linear Pretrivialization.IsLinear
namespace Pretrivialization
variable (e : Pretrivialization F (Ο F E)) {x : TotalSpace F E} {b : B} {y : E b}
theorem linear [AddCommMonoid F] [Module R F] [β x, AddCommMonoid (E x)] [β x, Module R (E x)]
[e.IsLinear R] {b : B} (hb : b β e.baseSet) :
IsLinearMap R fun x : E b => (e β¨b, xβ©).2 :=
Pretrivialization.IsLinear.linear b hb
#align pretrivialization.linear Pretrivialization.linear
variable [AddCommMonoid F] [Module R F] [β x, AddCommMonoid (E x)] [β x, Module R (E x)]
@[simps!]
protected def symmβ (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) : F ββ[R] E b := by
refine IsLinearMap.mk' (e.symm b) ?_
by_cases hb : b β e.baseSet
Β· exact (((e.linear R hb).mk' _).inverse (e.symm b) (e.symm_apply_apply_mk hb) fun v β¦
congr_arg Prod.snd <| e.apply_mk_symm hb v).isLinear
Β· rw [e.coe_symm_of_not_mem hb]
exact (0 : F ββ[R] E b).isLinear
#align pretrivialization.symmβ Pretrivialization.symmβ
@[simps (config := .asFn)]
def linearEquivAt (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) (hb : b β e.baseSet) :
E b ββ[R] F where
toFun y := (e β¨b, yβ©).2
invFun := e.symm b
left_inv := e.symm_apply_apply_mk hb
right_inv v := by simp_rw [e.apply_mk_symm hb v]
map_add' v w := (e.linear R hb).map_add v w
map_smul' c v := (e.linear R hb).map_smul c v
#align pretrivialization.linear_equiv_at Pretrivialization.linearEquivAt
protected def linearMapAt (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) : E b ββ[R] F :=
if hb : b β e.baseSet then e.linearEquivAt R b hb else 0
#align pretrivialization.linear_map_at Pretrivialization.linearMapAt
variable {R}
theorem coe_linearMapAt (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) :
β(e.linearMapAt R b) = fun y => if b β e.baseSet then (e β¨b, yβ©).2 else 0 := by
rw [Pretrivialization.linearMapAt]
split_ifs <;> rfl
#align pretrivialization.coe_linear_map_at Pretrivialization.coe_linearMapAt
| Mathlib/Topology/VectorBundle/Basic.lean | 126 | 128 | theorem coe_linearMapAt_of_mem (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B}
(hb : b β e.baseSet) : β(e.linearMapAt R b) = fun y => (e β¨b, yβ©).2 := by |
simp_rw [coe_linearMapAt, if_pos hb]
| 1,608 |
import Mathlib.Analysis.NormedSpace.BoundedLinearMaps
import Mathlib.Topology.FiberBundle.Basic
#align_import topology.vector_bundle.basic from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"
noncomputable section
open scoped Classical
open Bundle Set
open scoped Topology
variable (R : Type*) {B : Type*} (F : Type*) (E : B β Type*)
section TopologicalVectorSpace
variable {F E}
variable [Semiring R] [TopologicalSpace F] [TopologicalSpace B]
protected class Pretrivialization.IsLinear [AddCommMonoid F] [Module R F] [β x, AddCommMonoid (E x)]
[β x, Module R (E x)] (e : Pretrivialization F (Ο F E)) : Prop where
linear : β b β e.baseSet, IsLinearMap R fun x : E b => (e β¨b, xβ©).2
#align pretrivialization.is_linear Pretrivialization.IsLinear
namespace Pretrivialization
variable (e : Pretrivialization F (Ο F E)) {x : TotalSpace F E} {b : B} {y : E b}
theorem linear [AddCommMonoid F] [Module R F] [β x, AddCommMonoid (E x)] [β x, Module R (E x)]
[e.IsLinear R] {b : B} (hb : b β e.baseSet) :
IsLinearMap R fun x : E b => (e β¨b, xβ©).2 :=
Pretrivialization.IsLinear.linear b hb
#align pretrivialization.linear Pretrivialization.linear
variable [AddCommMonoid F] [Module R F] [β x, AddCommMonoid (E x)] [β x, Module R (E x)]
@[simps!]
protected def symmβ (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) : F ββ[R] E b := by
refine IsLinearMap.mk' (e.symm b) ?_
by_cases hb : b β e.baseSet
Β· exact (((e.linear R hb).mk' _).inverse (e.symm b) (e.symm_apply_apply_mk hb) fun v β¦
congr_arg Prod.snd <| e.apply_mk_symm hb v).isLinear
Β· rw [e.coe_symm_of_not_mem hb]
exact (0 : F ββ[R] E b).isLinear
#align pretrivialization.symmβ Pretrivialization.symmβ
@[simps (config := .asFn)]
def linearEquivAt (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) (hb : b β e.baseSet) :
E b ββ[R] F where
toFun y := (e β¨b, yβ©).2
invFun := e.symm b
left_inv := e.symm_apply_apply_mk hb
right_inv v := by simp_rw [e.apply_mk_symm hb v]
map_add' v w := (e.linear R hb).map_add v w
map_smul' c v := (e.linear R hb).map_smul c v
#align pretrivialization.linear_equiv_at Pretrivialization.linearEquivAt
protected def linearMapAt (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) : E b ββ[R] F :=
if hb : b β e.baseSet then e.linearEquivAt R b hb else 0
#align pretrivialization.linear_map_at Pretrivialization.linearMapAt
variable {R}
theorem coe_linearMapAt (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) :
β(e.linearMapAt R b) = fun y => if b β e.baseSet then (e β¨b, yβ©).2 else 0 := by
rw [Pretrivialization.linearMapAt]
split_ifs <;> rfl
#align pretrivialization.coe_linear_map_at Pretrivialization.coe_linearMapAt
theorem coe_linearMapAt_of_mem (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B}
(hb : b β e.baseSet) : β(e.linearMapAt R b) = fun y => (e β¨b, yβ©).2 := by
simp_rw [coe_linearMapAt, if_pos hb]
#align pretrivialization.coe_linear_map_at_of_mem Pretrivialization.coe_linearMapAt_of_mem
| Mathlib/Topology/VectorBundle/Basic.lean | 131 | 133 | theorem linearMapAt_apply (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B} (y : E b) :
e.linearMapAt R b y = if b β e.baseSet then (e β¨b, yβ©).2 else 0 := by |
rw [coe_linearMapAt]
| 1,608 |
import Mathlib.Analysis.NormedSpace.BoundedLinearMaps
import Mathlib.Topology.FiberBundle.Basic
#align_import topology.vector_bundle.basic from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"
noncomputable section
open scoped Classical
open Bundle Set
open scoped Topology
variable (R : Type*) {B : Type*} (F : Type*) (E : B β Type*)
section TopologicalVectorSpace
variable {F E}
variable [Semiring R] [TopologicalSpace F] [TopologicalSpace B]
protected class Pretrivialization.IsLinear [AddCommMonoid F] [Module R F] [β x, AddCommMonoid (E x)]
[β x, Module R (E x)] (e : Pretrivialization F (Ο F E)) : Prop where
linear : β b β e.baseSet, IsLinearMap R fun x : E b => (e β¨b, xβ©).2
#align pretrivialization.is_linear Pretrivialization.IsLinear
namespace Pretrivialization
variable (e : Pretrivialization F (Ο F E)) {x : TotalSpace F E} {b : B} {y : E b}
theorem linear [AddCommMonoid F] [Module R F] [β x, AddCommMonoid (E x)] [β x, Module R (E x)]
[e.IsLinear R] {b : B} (hb : b β e.baseSet) :
IsLinearMap R fun x : E b => (e β¨b, xβ©).2 :=
Pretrivialization.IsLinear.linear b hb
#align pretrivialization.linear Pretrivialization.linear
variable [AddCommMonoid F] [Module R F] [β x, AddCommMonoid (E x)] [β x, Module R (E x)]
@[simps!]
protected def symmβ (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) : F ββ[R] E b := by
refine IsLinearMap.mk' (e.symm b) ?_
by_cases hb : b β e.baseSet
Β· exact (((e.linear R hb).mk' _).inverse (e.symm b) (e.symm_apply_apply_mk hb) fun v β¦
congr_arg Prod.snd <| e.apply_mk_symm hb v).isLinear
Β· rw [e.coe_symm_of_not_mem hb]
exact (0 : F ββ[R] E b).isLinear
#align pretrivialization.symmβ Pretrivialization.symmβ
@[simps (config := .asFn)]
def linearEquivAt (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) (hb : b β e.baseSet) :
E b ββ[R] F where
toFun y := (e β¨b, yβ©).2
invFun := e.symm b
left_inv := e.symm_apply_apply_mk hb
right_inv v := by simp_rw [e.apply_mk_symm hb v]
map_add' v w := (e.linear R hb).map_add v w
map_smul' c v := (e.linear R hb).map_smul c v
#align pretrivialization.linear_equiv_at Pretrivialization.linearEquivAt
protected def linearMapAt (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) : E b ββ[R] F :=
if hb : b β e.baseSet then e.linearEquivAt R b hb else 0
#align pretrivialization.linear_map_at Pretrivialization.linearMapAt
variable {R}
theorem coe_linearMapAt (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) :
β(e.linearMapAt R b) = fun y => if b β e.baseSet then (e β¨b, yβ©).2 else 0 := by
rw [Pretrivialization.linearMapAt]
split_ifs <;> rfl
#align pretrivialization.coe_linear_map_at Pretrivialization.coe_linearMapAt
theorem coe_linearMapAt_of_mem (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B}
(hb : b β e.baseSet) : β(e.linearMapAt R b) = fun y => (e β¨b, yβ©).2 := by
simp_rw [coe_linearMapAt, if_pos hb]
#align pretrivialization.coe_linear_map_at_of_mem Pretrivialization.coe_linearMapAt_of_mem
theorem linearMapAt_apply (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B} (y : E b) :
e.linearMapAt R b y = if b β e.baseSet then (e β¨b, yβ©).2 else 0 := by
rw [coe_linearMapAt]
#align pretrivialization.linear_map_at_apply Pretrivialization.linearMapAt_apply
theorem linearMapAt_def_of_mem (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B}
(hb : b β e.baseSet) : e.linearMapAt R b = e.linearEquivAt R b hb :=
dif_pos hb
#align pretrivialization.linear_map_at_def_of_mem Pretrivialization.linearMapAt_def_of_mem
theorem linearMapAt_def_of_not_mem (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B}
(hb : b β e.baseSet) : e.linearMapAt R b = 0 :=
dif_neg hb
#align pretrivialization.linear_map_at_def_of_not_mem Pretrivialization.linearMapAt_def_of_not_mem
theorem linearMapAt_eq_zero (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B}
(hb : b β e.baseSet) : e.linearMapAt R b = 0 :=
dif_neg hb
#align pretrivialization.linear_map_at_eq_zero Pretrivialization.linearMapAt_eq_zero
| Mathlib/Topology/VectorBundle/Basic.lean | 151 | 154 | theorem symmβ_linearMapAt (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B}
(hb : b β e.baseSet) (y : E b) : e.symmβ R b (e.linearMapAt R b y) = y := by |
rw [e.linearMapAt_def_of_mem hb]
exact (e.linearEquivAt R b hb).left_inv y
| 1,608 |
import Mathlib.Analysis.NormedSpace.BoundedLinearMaps
import Mathlib.Topology.FiberBundle.Basic
#align_import topology.vector_bundle.basic from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"
noncomputable section
open scoped Classical
open Bundle Set
open scoped Topology
variable (R : Type*) {B : Type*} (F : Type*) (E : B β Type*)
section TopologicalVectorSpace
variable {F E}
variable [Semiring R] [TopologicalSpace F] [TopologicalSpace B]
protected class Pretrivialization.IsLinear [AddCommMonoid F] [Module R F] [β x, AddCommMonoid (E x)]
[β x, Module R (E x)] (e : Pretrivialization F (Ο F E)) : Prop where
linear : β b β e.baseSet, IsLinearMap R fun x : E b => (e β¨b, xβ©).2
#align pretrivialization.is_linear Pretrivialization.IsLinear
namespace Pretrivialization
variable (e : Pretrivialization F (Ο F E)) {x : TotalSpace F E} {b : B} {y : E b}
theorem linear [AddCommMonoid F] [Module R F] [β x, AddCommMonoid (E x)] [β x, Module R (E x)]
[e.IsLinear R] {b : B} (hb : b β e.baseSet) :
IsLinearMap R fun x : E b => (e β¨b, xβ©).2 :=
Pretrivialization.IsLinear.linear b hb
#align pretrivialization.linear Pretrivialization.linear
variable [AddCommMonoid F] [Module R F] [β x, AddCommMonoid (E x)] [β x, Module R (E x)]
@[simps!]
protected def symmβ (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) : F ββ[R] E b := by
refine IsLinearMap.mk' (e.symm b) ?_
by_cases hb : b β e.baseSet
Β· exact (((e.linear R hb).mk' _).inverse (e.symm b) (e.symm_apply_apply_mk hb) fun v β¦
congr_arg Prod.snd <| e.apply_mk_symm hb v).isLinear
Β· rw [e.coe_symm_of_not_mem hb]
exact (0 : F ββ[R] E b).isLinear
#align pretrivialization.symmβ Pretrivialization.symmβ
@[simps (config := .asFn)]
def linearEquivAt (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) (hb : b β e.baseSet) :
E b ββ[R] F where
toFun y := (e β¨b, yβ©).2
invFun := e.symm b
left_inv := e.symm_apply_apply_mk hb
right_inv v := by simp_rw [e.apply_mk_symm hb v]
map_add' v w := (e.linear R hb).map_add v w
map_smul' c v := (e.linear R hb).map_smul c v
#align pretrivialization.linear_equiv_at Pretrivialization.linearEquivAt
protected def linearMapAt (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) : E b ββ[R] F :=
if hb : b β e.baseSet then e.linearEquivAt R b hb else 0
#align pretrivialization.linear_map_at Pretrivialization.linearMapAt
variable {R}
theorem coe_linearMapAt (e : Pretrivialization F (Ο F E)) [e.IsLinear R] (b : B) :
β(e.linearMapAt R b) = fun y => if b β e.baseSet then (e β¨b, yβ©).2 else 0 := by
rw [Pretrivialization.linearMapAt]
split_ifs <;> rfl
#align pretrivialization.coe_linear_map_at Pretrivialization.coe_linearMapAt
theorem coe_linearMapAt_of_mem (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B}
(hb : b β e.baseSet) : β(e.linearMapAt R b) = fun y => (e β¨b, yβ©).2 := by
simp_rw [coe_linearMapAt, if_pos hb]
#align pretrivialization.coe_linear_map_at_of_mem Pretrivialization.coe_linearMapAt_of_mem
theorem linearMapAt_apply (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B} (y : E b) :
e.linearMapAt R b y = if b β e.baseSet then (e β¨b, yβ©).2 else 0 := by
rw [coe_linearMapAt]
#align pretrivialization.linear_map_at_apply Pretrivialization.linearMapAt_apply
theorem linearMapAt_def_of_mem (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B}
(hb : b β e.baseSet) : e.linearMapAt R b = e.linearEquivAt R b hb :=
dif_pos hb
#align pretrivialization.linear_map_at_def_of_mem Pretrivialization.linearMapAt_def_of_mem
theorem linearMapAt_def_of_not_mem (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B}
(hb : b β e.baseSet) : e.linearMapAt R b = 0 :=
dif_neg hb
#align pretrivialization.linear_map_at_def_of_not_mem Pretrivialization.linearMapAt_def_of_not_mem
theorem linearMapAt_eq_zero (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B}
(hb : b β e.baseSet) : e.linearMapAt R b = 0 :=
dif_neg hb
#align pretrivialization.linear_map_at_eq_zero Pretrivialization.linearMapAt_eq_zero
theorem symmβ_linearMapAt (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B}
(hb : b β e.baseSet) (y : E b) : e.symmβ R b (e.linearMapAt R b y) = y := by
rw [e.linearMapAt_def_of_mem hb]
exact (e.linearEquivAt R b hb).left_inv y
#align pretrivialization.symmβ_linear_map_at Pretrivialization.symmβ_linearMapAt
| Mathlib/Topology/VectorBundle/Basic.lean | 157 | 160 | theorem linearMapAt_symmβ (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B}
(hb : b β e.baseSet) (y : F) : e.linearMapAt R b (e.symmβ R b y) = y := by |
rw [e.linearMapAt_def_of_mem hb]
exact (e.linearEquivAt R b hb).right_inv y
| 1,608 |
import Mathlib.Topology.FiberBundle.Constructions
import Mathlib.Topology.VectorBundle.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.Prod
#align_import topology.vector_bundle.constructions from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"
noncomputable section
open scoped Classical
open Bundle Set FiberBundle
namespace Bundle.Trivial
variable (π : Type*) (B : Type*) (F : Type*) [NontriviallyNormedField π] [NormedAddCommGroup F]
[NormedSpace π F] [TopologicalSpace B]
instance trivialization.isLinear : (trivialization B F).IsLinear π where
linear _ _ := β¨fun _ _ => rfl, fun _ _ => rflβ©
#align bundle.trivial.trivialization.is_linear Bundle.Trivial.trivialization.isLinear
variable {π}
| Mathlib/Topology/VectorBundle/Constructions.lean | 50 | 55 | theorem trivialization.coordChangeL (b : B) :
(trivialization B F).coordChangeL π (trivialization B F) b =
ContinuousLinearEquiv.refl π F := by |
ext v
rw [Trivialization.coordChangeL_apply']
exacts [rfl, β¨mem_univ _, mem_univ _β©]
| 1,609 |
import Mathlib.Topology.FiberBundle.Constructions
import Mathlib.Topology.VectorBundle.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.Prod
#align_import topology.vector_bundle.constructions from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"
noncomputable section
open scoped Classical
open Bundle Set FiberBundle
section
variable (π : Type*) {B : Type*} [NontriviallyNormedField π] [TopologicalSpace B] (Fβ : Type*)
[NormedAddCommGroup Fβ] [NormedSpace π Fβ] (Eβ : B β Type*) [TopologicalSpace (TotalSpace Fβ Eβ)]
(Fβ : Type*) [NormedAddCommGroup Fβ] [NormedSpace π Fβ] (Eβ : B β Type*)
[TopologicalSpace (TotalSpace Fβ Eβ)]
namespace Trivialization
variable {Fβ Eβ Fβ Eβ}
variable [β x, AddCommMonoid (Eβ x)] [β x, Module π (Eβ x)]
[β x, AddCommMonoid (Eβ x)] [β x, Module π (Eβ x)] (eβ eβ' : Trivialization Fβ (Ο Fβ Eβ))
(eβ eβ' : Trivialization Fβ (Ο Fβ Eβ))
instance prod.isLinear [eβ.IsLinear π] [eβ.IsLinear π] : (eβ.prod eβ).IsLinear π where
linear := fun _ β¨hβ, hββ© =>
(((eβ.linear π hβ).mk' _).prodMap ((eβ.linear π hβ).mk' _)).isLinear
#align trivialization.prod.is_linear Trivialization.prod.isLinear
@[simp]
| Mathlib/Topology/VectorBundle/Constructions.lean | 96 | 106 | theorem coordChangeL_prod [eβ.IsLinear π] [eβ'.IsLinear π] [eβ.IsLinear π] [eβ'.IsLinear π] β¦bβ¦
(hb : b β (eβ.prod eβ).baseSet β© (eβ'.prod eβ').baseSet) :
((eβ.prod eβ).coordChangeL π (eβ'.prod eβ') b : Fβ Γ Fβ βL[π] Fβ Γ Fβ) =
(eβ.coordChangeL π eβ' b : Fβ βL[π] Fβ).prodMap (eβ.coordChangeL π eβ' b) := by |
rw [ContinuousLinearMap.ext_iff, ContinuousLinearMap.coe_prodMap']
rintro β¨vβ, vββ©
show
(eβ.prod eβ).coordChangeL π (eβ'.prod eβ') b (vβ, vβ) =
(eβ.coordChangeL π eβ' b vβ, eβ.coordChangeL π eβ' b vβ)
rw [eβ.coordChangeL_apply eβ', eβ.coordChangeL_apply eβ', (eβ.prod eβ).coordChangeL_apply']
exacts [rfl, hb, β¨hb.1.2, hb.2.2β©, β¨hb.1.1, hb.2.1β©]
| 1,609 |
import Mathlib.Topology.VectorBundle.Basic
#align_import topology.vector_bundle.hom from "leanprover-community/mathlib"@"8905e5ed90859939681a725b00f6063e65096d95"
noncomputable section
open scoped Bundle
open Bundle Set ContinuousLinearMap
variable {πβ : Type*} [NontriviallyNormedField πβ] {πβ : Type*} [NontriviallyNormedField πβ]
(Ο : πβ β+* πβ) [iΟ : RingHomIsometric Ο]
variable {B : Type*}
variable {Fβ : Type*} [NormedAddCommGroup Fβ] [NormedSpace πβ Fβ] (Eβ : B β Type*)
[β x, AddCommGroup (Eβ x)] [β x, Module πβ (Eβ x)] [TopologicalSpace (TotalSpace Fβ Eβ)]
variable {Fβ : Type*} [NormedAddCommGroup Fβ] [NormedSpace πβ Fβ] (Eβ : B β Type*)
[β x, AddCommGroup (Eβ x)] [β x, Module πβ (Eβ x)] [TopologicalSpace (TotalSpace Fβ Eβ)]
protected abbrev Bundle.ContinuousLinearMap [β x, TopologicalSpace (Eβ x)]
[β x, TopologicalSpace (Eβ x)] : B β Type _ := fun x => Eβ x βSL[Ο] Eβ x
#align bundle.continuous_linear_map Bundle.ContinuousLinearMap
-- Porting note: possibly remove after the port
instance Bundle.ContinuousLinearMap.module [β x, TopologicalSpace (Eβ x)]
[β x, TopologicalSpace (Eβ x)] [β x, TopologicalAddGroup (Eβ x)]
[β x, ContinuousConstSMul πβ (Eβ x)] : β x, Module πβ (Bundle.ContinuousLinearMap Ο Eβ Eβ x) :=
fun _ => inferInstance
#align bundle.continuous_linear_map.module Bundle.ContinuousLinearMap.module
variable {Eβ Eβ}
variable [TopologicalSpace B] (eβ eβ' : Trivialization Fβ (Ο Fβ Eβ))
(eβ eβ' : Trivialization Fβ (Ο Fβ Eβ))
namespace Pretrivialization
def continuousLinearMapCoordChange [eβ.IsLinear πβ] [eβ'.IsLinear πβ] [eβ.IsLinear πβ]
[eβ'.IsLinear πβ] (b : B) : (Fβ βSL[Ο] Fβ) βL[πβ] Fβ βSL[Ο] Fβ :=
((eβ'.coordChangeL πβ eβ b).symm.arrowCongrSL (eβ.coordChangeL πβ eβ' b) :
(Fβ βSL[Ο] Fβ) βL[πβ] Fβ βSL[Ο] Fβ)
#align pretrivialization.continuous_linear_map_coord_change Pretrivialization.continuousLinearMapCoordChange
variable {Ο eβ eβ' eβ eβ'}
variable [β x, TopologicalSpace (Eβ x)] [FiberBundle Fβ Eβ]
variable [β x, TopologicalSpace (Eβ x)] [ita : β x, TopologicalAddGroup (Eβ x)] [FiberBundle Fβ Eβ]
| Mathlib/Topology/VectorBundle/Hom.lean | 92 | 112 | theorem continuousOn_continuousLinearMapCoordChange [VectorBundle πβ Fβ Eβ] [VectorBundle πβ Fβ Eβ]
[MemTrivializationAtlas eβ] [MemTrivializationAtlas eβ'] [MemTrivializationAtlas eβ]
[MemTrivializationAtlas eβ'] :
ContinuousOn (continuousLinearMapCoordChange Ο eβ eβ' eβ eβ')
(eβ.baseSet β© eβ.baseSet β© (eβ'.baseSet β© eβ'.baseSet)) := by |
have hβ := (compSL Fβ Fβ Fβ Ο (RingHom.id πβ)).continuous
have hβ := (ContinuousLinearMap.flip (compSL Fβ Fβ Fβ (RingHom.id πβ) Ο)).continuous
have hβ := continuousOn_coordChange πβ eβ' eβ
have hβ := continuousOn_coordChange πβ eβ eβ'
refine ((hβ.comp_continuousOn (hβ.mono ?_)).clm_comp (hβ.comp_continuousOn (hβ.mono ?_))).congr ?_
Β· mfld_set_tac
Β· mfld_set_tac
Β· intro b _; ext L v
-- Porting note: was
-- simp only [continuousLinearMapCoordChange, ContinuousLinearEquiv.coe_coe,
-- ContinuousLinearEquiv.arrowCongrββ_apply, LinearEquiv.toFun_eq_coe, coe_comp',
-- ContinuousLinearEquiv.arrowCongrSL_apply, comp_apply, Function.comp, compSL_apply,
-- flip_apply, ContinuousLinearEquiv.symm_symm]
-- Now `simp` fails to use `ContinuousLinearMap.comp_apply` in this case
dsimp [continuousLinearMapCoordChange]
rw [ContinuousLinearEquiv.symm_symm]
| 1,610 |
import Mathlib.Analysis.Calculus.FDeriv.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
#align_import analysis.calculus.deriv.basic from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
noncomputable section
open scoped Classical Topology Filter ENNReal NNReal
open Filter Asymptotics Set
open ContinuousLinearMap (smulRight smulRight_one_eq_iff)
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
def HasDerivAtFilter (f : π β F) (f' : F) (x : π) (L : Filter π) :=
HasFDerivAtFilter f (smulRight (1 : π βL[π] π) f') x L
#align has_deriv_at_filter HasDerivAtFilter
def HasDerivWithinAt (f : π β F) (f' : F) (s : Set π) (x : π) :=
HasDerivAtFilter f f' x (π[s] x)
#align has_deriv_within_at HasDerivWithinAt
def HasDerivAt (f : π β F) (f' : F) (x : π) :=
HasDerivAtFilter f f' x (π x)
#align has_deriv_at HasDerivAt
def HasStrictDerivAt (f : π β F) (f' : F) (x : π) :=
HasStrictFDerivAt f (smulRight (1 : π βL[π] π) f') x
#align has_strict_deriv_at HasStrictDerivAt
def derivWithin (f : π β F) (s : Set π) (x : π) :=
fderivWithin π f s x 1
#align deriv_within derivWithin
def deriv (f : π β F) (x : π) :=
fderiv π f x 1
#align deriv deriv
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L Lβ Lβ : Filter π}
| Mathlib/Analysis/Calculus/Deriv/Basic.lean | 161 | 162 | theorem hasFDerivAtFilter_iff_hasDerivAtFilter {f' : π βL[π] F} :
HasFDerivAtFilter f f' x L β HasDerivAtFilter f (f' 1) x L := by | simp [HasDerivAtFilter]
| 1,611 |
import Mathlib.Analysis.Calculus.FDeriv.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
#align_import analysis.calculus.deriv.basic from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
noncomputable section
open scoped Classical Topology Filter ENNReal NNReal
open Filter Asymptotics Set
open ContinuousLinearMap (smulRight smulRight_one_eq_iff)
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
def HasDerivAtFilter (f : π β F) (f' : F) (x : π) (L : Filter π) :=
HasFDerivAtFilter f (smulRight (1 : π βL[π] π) f') x L
#align has_deriv_at_filter HasDerivAtFilter
def HasDerivWithinAt (f : π β F) (f' : F) (s : Set π) (x : π) :=
HasDerivAtFilter f f' x (π[s] x)
#align has_deriv_within_at HasDerivWithinAt
def HasDerivAt (f : π β F) (f' : F) (x : π) :=
HasDerivAtFilter f f' x (π x)
#align has_deriv_at HasDerivAt
def HasStrictDerivAt (f : π β F) (f' : F) (x : π) :=
HasStrictFDerivAt f (smulRight (1 : π βL[π] π) f') x
#align has_strict_deriv_at HasStrictDerivAt
def derivWithin (f : π β F) (s : Set π) (x : π) :=
fderivWithin π f s x 1
#align deriv_within derivWithin
def deriv (f : π β F) (x : π) :=
fderiv π f x 1
#align deriv deriv
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L Lβ Lβ : Filter π}
theorem hasFDerivAtFilter_iff_hasDerivAtFilter {f' : π βL[π] F} :
HasFDerivAtFilter f f' x L β HasDerivAtFilter f (f' 1) x L := by simp [HasDerivAtFilter]
#align has_fderiv_at_filter_iff_has_deriv_at_filter hasFDerivAtFilter_iff_hasDerivAtFilter
theorem HasFDerivAtFilter.hasDerivAtFilter {f' : π βL[π] F} :
HasFDerivAtFilter f f' x L β HasDerivAtFilter f (f' 1) x L :=
hasFDerivAtFilter_iff_hasDerivAtFilter.mp
#align has_fderiv_at_filter.has_deriv_at_filter HasFDerivAtFilter.hasDerivAtFilter
theorem hasFDerivWithinAt_iff_hasDerivWithinAt {f' : π βL[π] F} :
HasFDerivWithinAt f f' s x β HasDerivWithinAt f (f' 1) s x :=
hasFDerivAtFilter_iff_hasDerivAtFilter
#align has_fderiv_within_at_iff_has_deriv_within_at hasFDerivWithinAt_iff_hasDerivWithinAt
theorem hasDerivWithinAt_iff_hasFDerivWithinAt {f' : F} :
HasDerivWithinAt f f' s x β HasFDerivWithinAt f (smulRight (1 : π βL[π] π) f') s x :=
Iff.rfl
#align has_deriv_within_at_iff_has_fderiv_within_at hasDerivWithinAt_iff_hasFDerivWithinAt
theorem HasFDerivWithinAt.hasDerivWithinAt {f' : π βL[π] F} :
HasFDerivWithinAt f f' s x β HasDerivWithinAt f (f' 1) s x :=
hasFDerivWithinAt_iff_hasDerivWithinAt.mp
#align has_fderiv_within_at.has_deriv_within_at HasFDerivWithinAt.hasDerivWithinAt
theorem HasDerivWithinAt.hasFDerivWithinAt {f' : F} :
HasDerivWithinAt f f' s x β HasFDerivWithinAt f (smulRight (1 : π βL[π] π) f') s x :=
hasDerivWithinAt_iff_hasFDerivWithinAt.mp
#align has_deriv_within_at.has_fderiv_within_at HasDerivWithinAt.hasFDerivWithinAt
theorem hasFDerivAt_iff_hasDerivAt {f' : π βL[π] F} : HasFDerivAt f f' x β HasDerivAt f (f' 1) x :=
hasFDerivAtFilter_iff_hasDerivAtFilter
#align has_fderiv_at_iff_has_deriv_at hasFDerivAt_iff_hasDerivAt
theorem HasFDerivAt.hasDerivAt {f' : π βL[π] F} : HasFDerivAt f f' x β HasDerivAt f (f' 1) x :=
hasFDerivAt_iff_hasDerivAt.mp
#align has_fderiv_at.has_deriv_at HasFDerivAt.hasDerivAt
| Mathlib/Analysis/Calculus/Deriv/Basic.lean | 201 | 203 | theorem hasStrictFDerivAt_iff_hasStrictDerivAt {f' : π βL[π] F} :
HasStrictFDerivAt f f' x β HasStrictDerivAt f (f' 1) x := by |
simp [HasStrictDerivAt, HasStrictFDerivAt]
| 1,611 |
import Mathlib.Analysis.Calculus.Deriv.Basic
#align_import analysis.calculus.deriv.support from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v
variable {π : Type u} [NontriviallyNormedField π]
variable {E : Type v} [NormedAddCommGroup E] [NormedSpace π E]
variable {f : π β E}
section Support
open Function
| Mathlib/Analysis/Calculus/Deriv/Support.lean | 36 | 41 | theorem support_deriv_subset : support (deriv f) β tsupport f := by |
intro x
rw [β not_imp_not]
intro h2x
rw [not_mem_tsupport_iff_eventuallyEq] at h2x
exact nmem_support.mpr (h2x.deriv_eq.trans (deriv_const x 0))
| 1,612 |
import Mathlib.Analysis.Calculus.FDeriv.Pi
import Mathlib.Analysis.Calculus.Deriv.Basic
variable {π ΞΉ : Type*} [DecidableEq ΞΉ] [Fintype ΞΉ] [NontriviallyNormedField π]
| Mathlib/Analysis/Calculus/Deriv/Pi.lean | 15 | 22 | theorem hasDerivAt_update (x : ΞΉ β π) (i : ΞΉ) (y : π) :
HasDerivAt (Function.update x i) (Pi.single i (1 : π)) y := by |
convert (hasFDerivAt_update x y).hasDerivAt
ext z j
rw [Pi.single, Function.update_apply]
split_ifs with h
Β· simp [h]
Β· simp [Pi.single_eq_of_ne h]
| 1,613 |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Comp
import Mathlib.Analysis.Calculus.FDeriv.RestrictScalars
#align_import analysis.calculus.deriv.comp from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Topology Filter ENNReal
open Filter Asymptotics Set
open ContinuousLinearMap (smulRight smulRight_one_eq_iff)
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L Lβ Lβ : Filter π}
section Composition
variable {π' : Type*} [NontriviallyNormedField π'] [NormedAlgebra π π'] [NormedSpace π' F]
[IsScalarTower π π' F] {s' t' : Set π'} {h : π β π'} {hβ : π β π} {hβ : π' β π'} {h' hβ' : π'}
{hβ' : π} {gβ : π' β F} {gβ' : F} {L' : Filter π'} {y : π'} (x)
| Mathlib/Analysis/Calculus/Deriv/Comp.lean | 74 | 77 | theorem HasDerivAtFilter.scomp (hg : HasDerivAtFilter gβ gβ' (h x) L')
(hh : HasDerivAtFilter h h' x L) (hL : Tendsto h L L') :
HasDerivAtFilter (gβ β h) (h' β’ gβ') x L := by |
simpa using ((hg.restrictScalars π).comp x hh hL).hasDerivAtFilter
| 1,614 |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Comp
import Mathlib.Analysis.Calculus.FDeriv.RestrictScalars
#align_import analysis.calculus.deriv.comp from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Topology Filter ENNReal
open Filter Asymptotics Set
open ContinuousLinearMap (smulRight smulRight_one_eq_iff)
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L Lβ Lβ : Filter π}
section Composition
variable {π' : Type*} [NontriviallyNormedField π'] [NormedAlgebra π π'] [NormedSpace π' F]
[IsScalarTower π π' F] {s' t' : Set π'} {h : π β π'} {hβ : π β π} {hβ : π' β π'} {h' hβ' : π'}
{hβ' : π} {gβ : π' β F} {gβ' : F} {L' : Filter π'} {y : π'} (x)
theorem HasDerivAtFilter.scomp (hg : HasDerivAtFilter gβ gβ' (h x) L')
(hh : HasDerivAtFilter h h' x L) (hL : Tendsto h L L') :
HasDerivAtFilter (gβ β h) (h' β’ gβ') x L := by
simpa using ((hg.restrictScalars π).comp x hh hL).hasDerivAtFilter
#align has_deriv_at_filter.scomp HasDerivAtFilter.scomp
| Mathlib/Analysis/Calculus/Deriv/Comp.lean | 80 | 83 | theorem HasDerivAtFilter.scomp_of_eq (hg : HasDerivAtFilter gβ gβ' y L')
(hh : HasDerivAtFilter h h' x L) (hy : y = h x) (hL : Tendsto h L L') :
HasDerivAtFilter (gβ β h) (h' β’ gβ') x L := by |
rw [hy] at hg; exact hg.scomp x hh hL
| 1,614 |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Comp
import Mathlib.Analysis.Calculus.FDeriv.RestrictScalars
#align_import analysis.calculus.deriv.comp from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Topology Filter ENNReal
open Filter Asymptotics Set
open ContinuousLinearMap (smulRight smulRight_one_eq_iff)
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L Lβ Lβ : Filter π}
section Composition
variable {π' : Type*} [NontriviallyNormedField π'] [NormedAlgebra π π'] [NormedSpace π' F]
[IsScalarTower π π' F] {s' t' : Set π'} {h : π β π'} {hβ : π β π} {hβ : π' β π'} {h' hβ' : π'}
{hβ' : π} {gβ : π' β F} {gβ' : F} {L' : Filter π'} {y : π'} (x)
theorem HasDerivAtFilter.scomp (hg : HasDerivAtFilter gβ gβ' (h x) L')
(hh : HasDerivAtFilter h h' x L) (hL : Tendsto h L L') :
HasDerivAtFilter (gβ β h) (h' β’ gβ') x L := by
simpa using ((hg.restrictScalars π).comp x hh hL).hasDerivAtFilter
#align has_deriv_at_filter.scomp HasDerivAtFilter.scomp
theorem HasDerivAtFilter.scomp_of_eq (hg : HasDerivAtFilter gβ gβ' y L')
(hh : HasDerivAtFilter h h' x L) (hy : y = h x) (hL : Tendsto h L L') :
HasDerivAtFilter (gβ β h) (h' β’ gβ') x L := by
rw [hy] at hg; exact hg.scomp x hh hL
theorem HasDerivWithinAt.scomp_hasDerivAt (hg : HasDerivWithinAt gβ gβ' s' (h x))
(hh : HasDerivAt h h' x) (hs : β x, h x β s') : HasDerivAt (gβ β h) (h' β’ gβ') x :=
hg.scomp x hh <| tendsto_inf.2 β¨hh.continuousAt, tendsto_principal.2 <| eventually_of_forall hsβ©
#align has_deriv_within_at.scomp_has_deriv_at HasDerivWithinAt.scomp_hasDerivAt
| Mathlib/Analysis/Calculus/Deriv/Comp.lean | 90 | 93 | theorem HasDerivWithinAt.scomp_hasDerivAt_of_eq (hg : HasDerivWithinAt gβ gβ' s' y)
(hh : HasDerivAt h h' x) (hs : β x, h x β s') (hy : y = h x) :
HasDerivAt (gβ β h) (h' β’ gβ') x := by |
rw [hy] at hg; exact hg.scomp_hasDerivAt x hh hs
| 1,614 |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Comp
import Mathlib.Analysis.Calculus.FDeriv.RestrictScalars
#align_import analysis.calculus.deriv.comp from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Topology Filter ENNReal
open Filter Asymptotics Set
open ContinuousLinearMap (smulRight smulRight_one_eq_iff)
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L Lβ Lβ : Filter π}
section Composition
variable {π' : Type*} [NontriviallyNormedField π'] [NormedAlgebra π π'] [NormedSpace π' F]
[IsScalarTower π π' F] {s' t' : Set π'} {h : π β π'} {hβ : π β π} {hβ : π' β π'} {h' hβ' : π'}
{hβ' : π} {gβ : π' β F} {gβ' : F} {L' : Filter π'} {y : π'} (x)
theorem HasDerivAtFilter.scomp (hg : HasDerivAtFilter gβ gβ' (h x) L')
(hh : HasDerivAtFilter h h' x L) (hL : Tendsto h L L') :
HasDerivAtFilter (gβ β h) (h' β’ gβ') x L := by
simpa using ((hg.restrictScalars π).comp x hh hL).hasDerivAtFilter
#align has_deriv_at_filter.scomp HasDerivAtFilter.scomp
theorem HasDerivAtFilter.scomp_of_eq (hg : HasDerivAtFilter gβ gβ' y L')
(hh : HasDerivAtFilter h h' x L) (hy : y = h x) (hL : Tendsto h L L') :
HasDerivAtFilter (gβ β h) (h' β’ gβ') x L := by
rw [hy] at hg; exact hg.scomp x hh hL
theorem HasDerivWithinAt.scomp_hasDerivAt (hg : HasDerivWithinAt gβ gβ' s' (h x))
(hh : HasDerivAt h h' x) (hs : β x, h x β s') : HasDerivAt (gβ β h) (h' β’ gβ') x :=
hg.scomp x hh <| tendsto_inf.2 β¨hh.continuousAt, tendsto_principal.2 <| eventually_of_forall hsβ©
#align has_deriv_within_at.scomp_has_deriv_at HasDerivWithinAt.scomp_hasDerivAt
theorem HasDerivWithinAt.scomp_hasDerivAt_of_eq (hg : HasDerivWithinAt gβ gβ' s' y)
(hh : HasDerivAt h h' x) (hs : β x, h x β s') (hy : y = h x) :
HasDerivAt (gβ β h) (h' β’ gβ') x := by
rw [hy] at hg; exact hg.scomp_hasDerivAt x hh hs
nonrec theorem HasDerivWithinAt.scomp (hg : HasDerivWithinAt gβ gβ' t' (h x))
(hh : HasDerivWithinAt h h' s x) (hst : MapsTo h s t') :
HasDerivWithinAt (gβ β h) (h' β’ gβ') s x :=
hg.scomp x hh <| hh.continuousWithinAt.tendsto_nhdsWithin hst
#align has_deriv_within_at.scomp HasDerivWithinAt.scomp
| Mathlib/Analysis/Calculus/Deriv/Comp.lean | 101 | 104 | theorem HasDerivWithinAt.scomp_of_eq (hg : HasDerivWithinAt gβ gβ' t' y)
(hh : HasDerivWithinAt h h' s x) (hst : MapsTo h s t') (hy : y = h x) :
HasDerivWithinAt (gβ β h) (h' β’ gβ') s x := by |
rw [hy] at hg; exact hg.scomp x hh hst
| 1,614 |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Comp
import Mathlib.Analysis.Calculus.FDeriv.RestrictScalars
#align_import analysis.calculus.deriv.comp from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Topology Filter ENNReal
open Filter Asymptotics Set
open ContinuousLinearMap (smulRight smulRight_one_eq_iff)
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L Lβ Lβ : Filter π}
section Composition
variable {π' : Type*} [NontriviallyNormedField π'] [NormedAlgebra π π'] [NormedSpace π' F]
[IsScalarTower π π' F] {s' t' : Set π'} {h : π β π'} {hβ : π β π} {hβ : π' β π'} {h' hβ' : π'}
{hβ' : π} {gβ : π' β F} {gβ' : F} {L' : Filter π'} {y : π'} (x)
theorem HasDerivAtFilter.scomp (hg : HasDerivAtFilter gβ gβ' (h x) L')
(hh : HasDerivAtFilter h h' x L) (hL : Tendsto h L L') :
HasDerivAtFilter (gβ β h) (h' β’ gβ') x L := by
simpa using ((hg.restrictScalars π).comp x hh hL).hasDerivAtFilter
#align has_deriv_at_filter.scomp HasDerivAtFilter.scomp
theorem HasDerivAtFilter.scomp_of_eq (hg : HasDerivAtFilter gβ gβ' y L')
(hh : HasDerivAtFilter h h' x L) (hy : y = h x) (hL : Tendsto h L L') :
HasDerivAtFilter (gβ β h) (h' β’ gβ') x L := by
rw [hy] at hg; exact hg.scomp x hh hL
theorem HasDerivWithinAt.scomp_hasDerivAt (hg : HasDerivWithinAt gβ gβ' s' (h x))
(hh : HasDerivAt h h' x) (hs : β x, h x β s') : HasDerivAt (gβ β h) (h' β’ gβ') x :=
hg.scomp x hh <| tendsto_inf.2 β¨hh.continuousAt, tendsto_principal.2 <| eventually_of_forall hsβ©
#align has_deriv_within_at.scomp_has_deriv_at HasDerivWithinAt.scomp_hasDerivAt
theorem HasDerivWithinAt.scomp_hasDerivAt_of_eq (hg : HasDerivWithinAt gβ gβ' s' y)
(hh : HasDerivAt h h' x) (hs : β x, h x β s') (hy : y = h x) :
HasDerivAt (gβ β h) (h' β’ gβ') x := by
rw [hy] at hg; exact hg.scomp_hasDerivAt x hh hs
nonrec theorem HasDerivWithinAt.scomp (hg : HasDerivWithinAt gβ gβ' t' (h x))
(hh : HasDerivWithinAt h h' s x) (hst : MapsTo h s t') :
HasDerivWithinAt (gβ β h) (h' β’ gβ') s x :=
hg.scomp x hh <| hh.continuousWithinAt.tendsto_nhdsWithin hst
#align has_deriv_within_at.scomp HasDerivWithinAt.scomp
theorem HasDerivWithinAt.scomp_of_eq (hg : HasDerivWithinAt gβ gβ' t' y)
(hh : HasDerivWithinAt h h' s x) (hst : MapsTo h s t') (hy : y = h x) :
HasDerivWithinAt (gβ β h) (h' β’ gβ') s x := by
rw [hy] at hg; exact hg.scomp x hh hst
nonrec theorem HasDerivAt.scomp (hg : HasDerivAt gβ gβ' (h x)) (hh : HasDerivAt h h' x) :
HasDerivAt (gβ β h) (h' β’ gβ') x :=
hg.scomp x hh hh.continuousAt
#align has_deriv_at.scomp HasDerivAt.scomp
| Mathlib/Analysis/Calculus/Deriv/Comp.lean | 113 | 116 | theorem HasDerivAt.scomp_of_eq
(hg : HasDerivAt gβ gβ' y) (hh : HasDerivAt h h' x) (hy : y = h x) :
HasDerivAt (gβ β h) (h' β’ gβ') x := by |
rw [hy] at hg; exact hg.scomp x hh
| 1,614 |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Comp
import Mathlib.Analysis.Calculus.FDeriv.RestrictScalars
#align_import analysis.calculus.deriv.comp from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Topology Filter ENNReal
open Filter Asymptotics Set
open ContinuousLinearMap (smulRight smulRight_one_eq_iff)
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L Lβ Lβ : Filter π}
section Composition
variable {π' : Type*} [NontriviallyNormedField π'] [NormedAlgebra π π'] [NormedSpace π' F]
[IsScalarTower π π' F] {s' t' : Set π'} {h : π β π'} {hβ : π β π} {hβ : π' β π'} {h' hβ' : π'}
{hβ' : π} {gβ : π' β F} {gβ' : F} {L' : Filter π'} {y : π'} (x)
theorem HasDerivAtFilter.scomp (hg : HasDerivAtFilter gβ gβ' (h x) L')
(hh : HasDerivAtFilter h h' x L) (hL : Tendsto h L L') :
HasDerivAtFilter (gβ β h) (h' β’ gβ') x L := by
simpa using ((hg.restrictScalars π).comp x hh hL).hasDerivAtFilter
#align has_deriv_at_filter.scomp HasDerivAtFilter.scomp
theorem HasDerivAtFilter.scomp_of_eq (hg : HasDerivAtFilter gβ gβ' y L')
(hh : HasDerivAtFilter h h' x L) (hy : y = h x) (hL : Tendsto h L L') :
HasDerivAtFilter (gβ β h) (h' β’ gβ') x L := by
rw [hy] at hg; exact hg.scomp x hh hL
theorem HasDerivWithinAt.scomp_hasDerivAt (hg : HasDerivWithinAt gβ gβ' s' (h x))
(hh : HasDerivAt h h' x) (hs : β x, h x β s') : HasDerivAt (gβ β h) (h' β’ gβ') x :=
hg.scomp x hh <| tendsto_inf.2 β¨hh.continuousAt, tendsto_principal.2 <| eventually_of_forall hsβ©
#align has_deriv_within_at.scomp_has_deriv_at HasDerivWithinAt.scomp_hasDerivAt
theorem HasDerivWithinAt.scomp_hasDerivAt_of_eq (hg : HasDerivWithinAt gβ gβ' s' y)
(hh : HasDerivAt h h' x) (hs : β x, h x β s') (hy : y = h x) :
HasDerivAt (gβ β h) (h' β’ gβ') x := by
rw [hy] at hg; exact hg.scomp_hasDerivAt x hh hs
nonrec theorem HasDerivWithinAt.scomp (hg : HasDerivWithinAt gβ gβ' t' (h x))
(hh : HasDerivWithinAt h h' s x) (hst : MapsTo h s t') :
HasDerivWithinAt (gβ β h) (h' β’ gβ') s x :=
hg.scomp x hh <| hh.continuousWithinAt.tendsto_nhdsWithin hst
#align has_deriv_within_at.scomp HasDerivWithinAt.scomp
theorem HasDerivWithinAt.scomp_of_eq (hg : HasDerivWithinAt gβ gβ' t' y)
(hh : HasDerivWithinAt h h' s x) (hst : MapsTo h s t') (hy : y = h x) :
HasDerivWithinAt (gβ β h) (h' β’ gβ') s x := by
rw [hy] at hg; exact hg.scomp x hh hst
nonrec theorem HasDerivAt.scomp (hg : HasDerivAt gβ gβ' (h x)) (hh : HasDerivAt h h' x) :
HasDerivAt (gβ β h) (h' β’ gβ') x :=
hg.scomp x hh hh.continuousAt
#align has_deriv_at.scomp HasDerivAt.scomp
theorem HasDerivAt.scomp_of_eq
(hg : HasDerivAt gβ gβ' y) (hh : HasDerivAt h h' x) (hy : y = h x) :
HasDerivAt (gβ β h) (h' β’ gβ') x := by
rw [hy] at hg; exact hg.scomp x hh
| Mathlib/Analysis/Calculus/Deriv/Comp.lean | 118 | 120 | theorem HasStrictDerivAt.scomp (hg : HasStrictDerivAt gβ gβ' (h x)) (hh : HasStrictDerivAt h h' x) :
HasStrictDerivAt (gβ β h) (h' β’ gβ') x := by |
simpa using ((hg.restrictScalars π).comp x hh).hasStrictDerivAt
| 1,614 |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Comp
import Mathlib.Analysis.Calculus.FDeriv.RestrictScalars
#align_import analysis.calculus.deriv.comp from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Topology Filter ENNReal
open Filter Asymptotics Set
open ContinuousLinearMap (smulRight smulRight_one_eq_iff)
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L Lβ Lβ : Filter π}
section Composition
variable {π' : Type*} [NontriviallyNormedField π'] [NormedAlgebra π π'] [NormedSpace π' F]
[IsScalarTower π π' F] {s' t' : Set π'} {h : π β π'} {hβ : π β π} {hβ : π' β π'} {h' hβ' : π'}
{hβ' : π} {gβ : π' β F} {gβ' : F} {L' : Filter π'} {y : π'} (x)
theorem HasDerivAtFilter.scomp (hg : HasDerivAtFilter gβ gβ' (h x) L')
(hh : HasDerivAtFilter h h' x L) (hL : Tendsto h L L') :
HasDerivAtFilter (gβ β h) (h' β’ gβ') x L := by
simpa using ((hg.restrictScalars π).comp x hh hL).hasDerivAtFilter
#align has_deriv_at_filter.scomp HasDerivAtFilter.scomp
theorem HasDerivAtFilter.scomp_of_eq (hg : HasDerivAtFilter gβ gβ' y L')
(hh : HasDerivAtFilter h h' x L) (hy : y = h x) (hL : Tendsto h L L') :
HasDerivAtFilter (gβ β h) (h' β’ gβ') x L := by
rw [hy] at hg; exact hg.scomp x hh hL
theorem HasDerivWithinAt.scomp_hasDerivAt (hg : HasDerivWithinAt gβ gβ' s' (h x))
(hh : HasDerivAt h h' x) (hs : β x, h x β s') : HasDerivAt (gβ β h) (h' β’ gβ') x :=
hg.scomp x hh <| tendsto_inf.2 β¨hh.continuousAt, tendsto_principal.2 <| eventually_of_forall hsβ©
#align has_deriv_within_at.scomp_has_deriv_at HasDerivWithinAt.scomp_hasDerivAt
theorem HasDerivWithinAt.scomp_hasDerivAt_of_eq (hg : HasDerivWithinAt gβ gβ' s' y)
(hh : HasDerivAt h h' x) (hs : β x, h x β s') (hy : y = h x) :
HasDerivAt (gβ β h) (h' β’ gβ') x := by
rw [hy] at hg; exact hg.scomp_hasDerivAt x hh hs
nonrec theorem HasDerivWithinAt.scomp (hg : HasDerivWithinAt gβ gβ' t' (h x))
(hh : HasDerivWithinAt h h' s x) (hst : MapsTo h s t') :
HasDerivWithinAt (gβ β h) (h' β’ gβ') s x :=
hg.scomp x hh <| hh.continuousWithinAt.tendsto_nhdsWithin hst
#align has_deriv_within_at.scomp HasDerivWithinAt.scomp
theorem HasDerivWithinAt.scomp_of_eq (hg : HasDerivWithinAt gβ gβ' t' y)
(hh : HasDerivWithinAt h h' s x) (hst : MapsTo h s t') (hy : y = h x) :
HasDerivWithinAt (gβ β h) (h' β’ gβ') s x := by
rw [hy] at hg; exact hg.scomp x hh hst
nonrec theorem HasDerivAt.scomp (hg : HasDerivAt gβ gβ' (h x)) (hh : HasDerivAt h h' x) :
HasDerivAt (gβ β h) (h' β’ gβ') x :=
hg.scomp x hh hh.continuousAt
#align has_deriv_at.scomp HasDerivAt.scomp
theorem HasDerivAt.scomp_of_eq
(hg : HasDerivAt gβ gβ' y) (hh : HasDerivAt h h' x) (hy : y = h x) :
HasDerivAt (gβ β h) (h' β’ gβ') x := by
rw [hy] at hg; exact hg.scomp x hh
theorem HasStrictDerivAt.scomp (hg : HasStrictDerivAt gβ gβ' (h x)) (hh : HasStrictDerivAt h h' x) :
HasStrictDerivAt (gβ β h) (h' β’ gβ') x := by
simpa using ((hg.restrictScalars π).comp x hh).hasStrictDerivAt
#align has_strict_deriv_at.scomp HasStrictDerivAt.scomp
| Mathlib/Analysis/Calculus/Deriv/Comp.lean | 123 | 126 | theorem HasStrictDerivAt.scomp_of_eq
(hg : HasStrictDerivAt gβ gβ' y) (hh : HasStrictDerivAt h h' x) (hy : y = h x) :
HasStrictDerivAt (gβ β h) (h' β’ gβ') x := by |
rw [hy] at hg; exact hg.scomp x hh
| 1,614 |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Comp
import Mathlib.Analysis.Calculus.FDeriv.RestrictScalars
#align_import analysis.calculus.deriv.comp from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Topology Filter ENNReal
open Filter Asymptotics Set
open ContinuousLinearMap (smulRight smulRight_one_eq_iff)
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L Lβ Lβ : Filter π}
section Composition
variable {π' : Type*} [NontriviallyNormedField π'] [NormedAlgebra π π'] [NormedSpace π' F]
[IsScalarTower π π' F] {s' t' : Set π'} {h : π β π'} {hβ : π β π} {hβ : π' β π'} {h' hβ' : π'}
{hβ' : π} {gβ : π' β F} {gβ' : F} {L' : Filter π'} {y : π'} (x)
theorem HasDerivAtFilter.scomp (hg : HasDerivAtFilter gβ gβ' (h x) L')
(hh : HasDerivAtFilter h h' x L) (hL : Tendsto h L L') :
HasDerivAtFilter (gβ β h) (h' β’ gβ') x L := by
simpa using ((hg.restrictScalars π).comp x hh hL).hasDerivAtFilter
#align has_deriv_at_filter.scomp HasDerivAtFilter.scomp
theorem HasDerivAtFilter.scomp_of_eq (hg : HasDerivAtFilter gβ gβ' y L')
(hh : HasDerivAtFilter h h' x L) (hy : y = h x) (hL : Tendsto h L L') :
HasDerivAtFilter (gβ β h) (h' β’ gβ') x L := by
rw [hy] at hg; exact hg.scomp x hh hL
theorem HasDerivWithinAt.scomp_hasDerivAt (hg : HasDerivWithinAt gβ gβ' s' (h x))
(hh : HasDerivAt h h' x) (hs : β x, h x β s') : HasDerivAt (gβ β h) (h' β’ gβ') x :=
hg.scomp x hh <| tendsto_inf.2 β¨hh.continuousAt, tendsto_principal.2 <| eventually_of_forall hsβ©
#align has_deriv_within_at.scomp_has_deriv_at HasDerivWithinAt.scomp_hasDerivAt
theorem HasDerivWithinAt.scomp_hasDerivAt_of_eq (hg : HasDerivWithinAt gβ gβ' s' y)
(hh : HasDerivAt h h' x) (hs : β x, h x β s') (hy : y = h x) :
HasDerivAt (gβ β h) (h' β’ gβ') x := by
rw [hy] at hg; exact hg.scomp_hasDerivAt x hh hs
nonrec theorem HasDerivWithinAt.scomp (hg : HasDerivWithinAt gβ gβ' t' (h x))
(hh : HasDerivWithinAt h h' s x) (hst : MapsTo h s t') :
HasDerivWithinAt (gβ β h) (h' β’ gβ') s x :=
hg.scomp x hh <| hh.continuousWithinAt.tendsto_nhdsWithin hst
#align has_deriv_within_at.scomp HasDerivWithinAt.scomp
theorem HasDerivWithinAt.scomp_of_eq (hg : HasDerivWithinAt gβ gβ' t' y)
(hh : HasDerivWithinAt h h' s x) (hst : MapsTo h s t') (hy : y = h x) :
HasDerivWithinAt (gβ β h) (h' β’ gβ') s x := by
rw [hy] at hg; exact hg.scomp x hh hst
nonrec theorem HasDerivAt.scomp (hg : HasDerivAt gβ gβ' (h x)) (hh : HasDerivAt h h' x) :
HasDerivAt (gβ β h) (h' β’ gβ') x :=
hg.scomp x hh hh.continuousAt
#align has_deriv_at.scomp HasDerivAt.scomp
theorem HasDerivAt.scomp_of_eq
(hg : HasDerivAt gβ gβ' y) (hh : HasDerivAt h h' x) (hy : y = h x) :
HasDerivAt (gβ β h) (h' β’ gβ') x := by
rw [hy] at hg; exact hg.scomp x hh
theorem HasStrictDerivAt.scomp (hg : HasStrictDerivAt gβ gβ' (h x)) (hh : HasStrictDerivAt h h' x) :
HasStrictDerivAt (gβ β h) (h' β’ gβ') x := by
simpa using ((hg.restrictScalars π).comp x hh).hasStrictDerivAt
#align has_strict_deriv_at.scomp HasStrictDerivAt.scomp
theorem HasStrictDerivAt.scomp_of_eq
(hg : HasStrictDerivAt gβ gβ' y) (hh : HasStrictDerivAt h h' x) (hy : y = h x) :
HasStrictDerivAt (gβ β h) (h' β’ gβ') x := by
rw [hy] at hg; exact hg.scomp x hh
theorem HasDerivAt.scomp_hasDerivWithinAt (hg : HasDerivAt gβ gβ' (h x))
(hh : HasDerivWithinAt h h' s x) : HasDerivWithinAt (gβ β h) (h' β’ gβ') s x :=
HasDerivWithinAt.scomp x hg.hasDerivWithinAt hh (mapsTo_univ _ _)
#align has_deriv_at.scomp_has_deriv_within_at HasDerivAt.scomp_hasDerivWithinAt
| Mathlib/Analysis/Calculus/Deriv/Comp.lean | 133 | 136 | theorem HasDerivAt.scomp_hasDerivWithinAt_of_eq (hg : HasDerivAt gβ gβ' y)
(hh : HasDerivWithinAt h h' s x) (hy : y = h x) :
HasDerivWithinAt (gβ β h) (h' β’ gβ') s x := by |
rw [hy] at hg; exact hg.scomp_hasDerivWithinAt x hh
| 1,614 |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Comp
import Mathlib.Analysis.Calculus.FDeriv.RestrictScalars
#align_import analysis.calculus.deriv.comp from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Topology Filter ENNReal
open Filter Asymptotics Set
open ContinuousLinearMap (smulRight smulRight_one_eq_iff)
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L Lβ Lβ : Filter π}
section CompositionVector
open ContinuousLinearMap
variable {l : F β E} {l' : F βL[π] E} {y : F}
variable (x)
theorem HasFDerivWithinAt.comp_hasDerivWithinAt {t : Set F} (hl : HasFDerivWithinAt l l' t (f x))
(hf : HasDerivWithinAt f f' s x) (hst : MapsTo f s t) :
HasDerivWithinAt (l β f) (l' f') s x := by
simpa only [one_apply, one_smul, smulRight_apply, coe_comp', (Β· β Β·)] using
(hl.comp x hf.hasFDerivWithinAt hst).hasDerivWithinAt
#align has_fderiv_within_at.comp_has_deriv_within_at HasFDerivWithinAt.comp_hasDerivWithinAt
| Mathlib/Analysis/Calculus/Deriv/Comp.lean | 357 | 361 | theorem HasFDerivWithinAt.comp_hasDerivWithinAt_of_eq {t : Set F}
(hl : HasFDerivWithinAt l l' t y)
(hf : HasDerivWithinAt f f' s x) (hst : MapsTo f s t) (hy : y = f x) :
HasDerivWithinAt (l β f) (l' f') s x := by |
rw [hy] at hl; exact hl.comp_hasDerivWithinAt x hf hst
| 1,614 |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Comp
import Mathlib.Analysis.Calculus.FDeriv.RestrictScalars
#align_import analysis.calculus.deriv.comp from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Topology Filter ENNReal
open Filter Asymptotics Set
open ContinuousLinearMap (smulRight smulRight_one_eq_iff)
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L Lβ Lβ : Filter π}
section CompositionVector
open ContinuousLinearMap
variable {l : F β E} {l' : F βL[π] E} {y : F}
variable (x)
theorem HasFDerivWithinAt.comp_hasDerivWithinAt {t : Set F} (hl : HasFDerivWithinAt l l' t (f x))
(hf : HasDerivWithinAt f f' s x) (hst : MapsTo f s t) :
HasDerivWithinAt (l β f) (l' f') s x := by
simpa only [one_apply, one_smul, smulRight_apply, coe_comp', (Β· β Β·)] using
(hl.comp x hf.hasFDerivWithinAt hst).hasDerivWithinAt
#align has_fderiv_within_at.comp_has_deriv_within_at HasFDerivWithinAt.comp_hasDerivWithinAt
theorem HasFDerivWithinAt.comp_hasDerivWithinAt_of_eq {t : Set F}
(hl : HasFDerivWithinAt l l' t y)
(hf : HasDerivWithinAt f f' s x) (hst : MapsTo f s t) (hy : y = f x) :
HasDerivWithinAt (l β f) (l' f') s x := by
rw [hy] at hl; exact hl.comp_hasDerivWithinAt x hf hst
theorem HasFDerivAt.comp_hasDerivWithinAt (hl : HasFDerivAt l l' (f x))
(hf : HasDerivWithinAt f f' s x) : HasDerivWithinAt (l β f) (l' f') s x :=
hl.hasFDerivWithinAt.comp_hasDerivWithinAt x hf (mapsTo_univ _ _)
#align has_fderiv_at.comp_has_deriv_within_at HasFDerivAt.comp_hasDerivWithinAt
| Mathlib/Analysis/Calculus/Deriv/Comp.lean | 368 | 371 | theorem HasFDerivAt.comp_hasDerivWithinAt_of_eq (hl : HasFDerivAt l l' y)
(hf : HasDerivWithinAt f f' s x) (hy : y = f x) :
HasDerivWithinAt (l β f) (l' f') s x := by |
rw [hy] at hl; exact hl.comp_hasDerivWithinAt x hf
| 1,614 |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Comp
import Mathlib.Analysis.Calculus.FDeriv.RestrictScalars
#align_import analysis.calculus.deriv.comp from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Topology Filter ENNReal
open Filter Asymptotics Set
open ContinuousLinearMap (smulRight smulRight_one_eq_iff)
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L Lβ Lβ : Filter π}
section CompositionVector
open ContinuousLinearMap
variable {l : F β E} {l' : F βL[π] E} {y : F}
variable (x)
theorem HasFDerivWithinAt.comp_hasDerivWithinAt {t : Set F} (hl : HasFDerivWithinAt l l' t (f x))
(hf : HasDerivWithinAt f f' s x) (hst : MapsTo f s t) :
HasDerivWithinAt (l β f) (l' f') s x := by
simpa only [one_apply, one_smul, smulRight_apply, coe_comp', (Β· β Β·)] using
(hl.comp x hf.hasFDerivWithinAt hst).hasDerivWithinAt
#align has_fderiv_within_at.comp_has_deriv_within_at HasFDerivWithinAt.comp_hasDerivWithinAt
theorem HasFDerivWithinAt.comp_hasDerivWithinAt_of_eq {t : Set F}
(hl : HasFDerivWithinAt l l' t y)
(hf : HasDerivWithinAt f f' s x) (hst : MapsTo f s t) (hy : y = f x) :
HasDerivWithinAt (l β f) (l' f') s x := by
rw [hy] at hl; exact hl.comp_hasDerivWithinAt x hf hst
theorem HasFDerivAt.comp_hasDerivWithinAt (hl : HasFDerivAt l l' (f x))
(hf : HasDerivWithinAt f f' s x) : HasDerivWithinAt (l β f) (l' f') s x :=
hl.hasFDerivWithinAt.comp_hasDerivWithinAt x hf (mapsTo_univ _ _)
#align has_fderiv_at.comp_has_deriv_within_at HasFDerivAt.comp_hasDerivWithinAt
theorem HasFDerivAt.comp_hasDerivWithinAt_of_eq (hl : HasFDerivAt l l' y)
(hf : HasDerivWithinAt f f' s x) (hy : y = f x) :
HasDerivWithinAt (l β f) (l' f') s x := by
rw [hy] at hl; exact hl.comp_hasDerivWithinAt x hf
theorem HasFDerivAt.comp_hasDerivAt (hl : HasFDerivAt l l' (f x)) (hf : HasDerivAt f f' x) :
HasDerivAt (l β f) (l' f') x :=
hasDerivWithinAt_univ.mp <| hl.comp_hasDerivWithinAt x hf.hasDerivWithinAt
#align has_fderiv_at.comp_has_deriv_at HasFDerivAt.comp_hasDerivAt
| Mathlib/Analysis/Calculus/Deriv/Comp.lean | 382 | 385 | theorem HasFDerivAt.comp_hasDerivAt_of_eq
(hl : HasFDerivAt l l' y) (hf : HasDerivAt f f' x) (hy : y = f x) :
HasDerivAt (l β f) (l' f') x := by |
rw [hy] at hl; exact hl.comp_hasDerivAt x hf
| 1,614 |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Comp
import Mathlib.Analysis.Calculus.FDeriv.RestrictScalars
#align_import analysis.calculus.deriv.comp from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Topology Filter ENNReal
open Filter Asymptotics Set
open ContinuousLinearMap (smulRight smulRight_one_eq_iff)
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L Lβ Lβ : Filter π}
section CompositionVector
open ContinuousLinearMap
variable {l : F β E} {l' : F βL[π] E} {y : F}
variable (x)
theorem HasFDerivWithinAt.comp_hasDerivWithinAt {t : Set F} (hl : HasFDerivWithinAt l l' t (f x))
(hf : HasDerivWithinAt f f' s x) (hst : MapsTo f s t) :
HasDerivWithinAt (l β f) (l' f') s x := by
simpa only [one_apply, one_smul, smulRight_apply, coe_comp', (Β· β Β·)] using
(hl.comp x hf.hasFDerivWithinAt hst).hasDerivWithinAt
#align has_fderiv_within_at.comp_has_deriv_within_at HasFDerivWithinAt.comp_hasDerivWithinAt
theorem HasFDerivWithinAt.comp_hasDerivWithinAt_of_eq {t : Set F}
(hl : HasFDerivWithinAt l l' t y)
(hf : HasDerivWithinAt f f' s x) (hst : MapsTo f s t) (hy : y = f x) :
HasDerivWithinAt (l β f) (l' f') s x := by
rw [hy] at hl; exact hl.comp_hasDerivWithinAt x hf hst
theorem HasFDerivAt.comp_hasDerivWithinAt (hl : HasFDerivAt l l' (f x))
(hf : HasDerivWithinAt f f' s x) : HasDerivWithinAt (l β f) (l' f') s x :=
hl.hasFDerivWithinAt.comp_hasDerivWithinAt x hf (mapsTo_univ _ _)
#align has_fderiv_at.comp_has_deriv_within_at HasFDerivAt.comp_hasDerivWithinAt
theorem HasFDerivAt.comp_hasDerivWithinAt_of_eq (hl : HasFDerivAt l l' y)
(hf : HasDerivWithinAt f f' s x) (hy : y = f x) :
HasDerivWithinAt (l β f) (l' f') s x := by
rw [hy] at hl; exact hl.comp_hasDerivWithinAt x hf
theorem HasFDerivAt.comp_hasDerivAt (hl : HasFDerivAt l l' (f x)) (hf : HasDerivAt f f' x) :
HasDerivAt (l β f) (l' f') x :=
hasDerivWithinAt_univ.mp <| hl.comp_hasDerivWithinAt x hf.hasDerivWithinAt
#align has_fderiv_at.comp_has_deriv_at HasFDerivAt.comp_hasDerivAt
theorem HasFDerivAt.comp_hasDerivAt_of_eq
(hl : HasFDerivAt l l' y) (hf : HasDerivAt f f' x) (hy : y = f x) :
HasDerivAt (l β f) (l' f') x := by
rw [hy] at hl; exact hl.comp_hasDerivAt x hf
theorem HasStrictFDerivAt.comp_hasStrictDerivAt (hl : HasStrictFDerivAt l l' (f x))
(hf : HasStrictDerivAt f f' x) : HasStrictDerivAt (l β f) (l' f') x := by
simpa only [one_apply, one_smul, smulRight_apply, coe_comp', (Β· β Β·)] using
(hl.comp x hf.hasStrictFDerivAt).hasStrictDerivAt
#align has_strict_fderiv_at.comp_has_strict_deriv_at HasStrictFDerivAt.comp_hasStrictDerivAt
| Mathlib/Analysis/Calculus/Deriv/Comp.lean | 393 | 396 | theorem HasStrictFDerivAt.comp_hasStrictDerivAt_of_eq (hl : HasStrictFDerivAt l l' y)
(hf : HasStrictDerivAt f f' x) (hy : y = f x) :
HasStrictDerivAt (l β f) (l' f') x := by |
rw [hy] at hl; exact hl.comp_hasStrictDerivAt x hf
| 1,614 |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Comp
import Mathlib.Analysis.Calculus.FDeriv.RestrictScalars
#align_import analysis.calculus.deriv.comp from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Topology Filter ENNReal
open Filter Asymptotics Set
open ContinuousLinearMap (smulRight smulRight_one_eq_iff)
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L Lβ Lβ : Filter π}
section CompositionVector
open ContinuousLinearMap
variable {l : F β E} {l' : F βL[π] E} {y : F}
variable (x)
theorem HasFDerivWithinAt.comp_hasDerivWithinAt {t : Set F} (hl : HasFDerivWithinAt l l' t (f x))
(hf : HasDerivWithinAt f f' s x) (hst : MapsTo f s t) :
HasDerivWithinAt (l β f) (l' f') s x := by
simpa only [one_apply, one_smul, smulRight_apply, coe_comp', (Β· β Β·)] using
(hl.comp x hf.hasFDerivWithinAt hst).hasDerivWithinAt
#align has_fderiv_within_at.comp_has_deriv_within_at HasFDerivWithinAt.comp_hasDerivWithinAt
theorem HasFDerivWithinAt.comp_hasDerivWithinAt_of_eq {t : Set F}
(hl : HasFDerivWithinAt l l' t y)
(hf : HasDerivWithinAt f f' s x) (hst : MapsTo f s t) (hy : y = f x) :
HasDerivWithinAt (l β f) (l' f') s x := by
rw [hy] at hl; exact hl.comp_hasDerivWithinAt x hf hst
theorem HasFDerivAt.comp_hasDerivWithinAt (hl : HasFDerivAt l l' (f x))
(hf : HasDerivWithinAt f f' s x) : HasDerivWithinAt (l β f) (l' f') s x :=
hl.hasFDerivWithinAt.comp_hasDerivWithinAt x hf (mapsTo_univ _ _)
#align has_fderiv_at.comp_has_deriv_within_at HasFDerivAt.comp_hasDerivWithinAt
theorem HasFDerivAt.comp_hasDerivWithinAt_of_eq (hl : HasFDerivAt l l' y)
(hf : HasDerivWithinAt f f' s x) (hy : y = f x) :
HasDerivWithinAt (l β f) (l' f') s x := by
rw [hy] at hl; exact hl.comp_hasDerivWithinAt x hf
theorem HasFDerivAt.comp_hasDerivAt (hl : HasFDerivAt l l' (f x)) (hf : HasDerivAt f f' x) :
HasDerivAt (l β f) (l' f') x :=
hasDerivWithinAt_univ.mp <| hl.comp_hasDerivWithinAt x hf.hasDerivWithinAt
#align has_fderiv_at.comp_has_deriv_at HasFDerivAt.comp_hasDerivAt
theorem HasFDerivAt.comp_hasDerivAt_of_eq
(hl : HasFDerivAt l l' y) (hf : HasDerivAt f f' x) (hy : y = f x) :
HasDerivAt (l β f) (l' f') x := by
rw [hy] at hl; exact hl.comp_hasDerivAt x hf
theorem HasStrictFDerivAt.comp_hasStrictDerivAt (hl : HasStrictFDerivAt l l' (f x))
(hf : HasStrictDerivAt f f' x) : HasStrictDerivAt (l β f) (l' f') x := by
simpa only [one_apply, one_smul, smulRight_apply, coe_comp', (Β· β Β·)] using
(hl.comp x hf.hasStrictFDerivAt).hasStrictDerivAt
#align has_strict_fderiv_at.comp_has_strict_deriv_at HasStrictFDerivAt.comp_hasStrictDerivAt
theorem HasStrictFDerivAt.comp_hasStrictDerivAt_of_eq (hl : HasStrictFDerivAt l l' y)
(hf : HasStrictDerivAt f f' x) (hy : y = f x) :
HasStrictDerivAt (l β f) (l' f') x := by
rw [hy] at hl; exact hl.comp_hasStrictDerivAt x hf
theorem fderivWithin.comp_derivWithin {t : Set F} (hl : DifferentiableWithinAt π l t (f x))
(hf : DifferentiableWithinAt π f s x) (hs : MapsTo f s t) (hxs : UniqueDiffWithinAt π s x) :
derivWithin (l β f) s x = (fderivWithin π l t (f x) : F β E) (derivWithin f s x) :=
(hl.hasFDerivWithinAt.comp_hasDerivWithinAt x hf.hasDerivWithinAt hs).derivWithin hxs
#align fderiv_within.comp_deriv_within fderivWithin.comp_derivWithin
| Mathlib/Analysis/Calculus/Deriv/Comp.lean | 404 | 408 | theorem fderivWithin.comp_derivWithin_of_eq {t : Set F} (hl : DifferentiableWithinAt π l t y)
(hf : DifferentiableWithinAt π f s x) (hs : MapsTo f s t) (hxs : UniqueDiffWithinAt π s x)
(hy : y = f x) :
derivWithin (l β f) s x = (fderivWithin π l t (f x) : F β E) (derivWithin f s x) := by |
rw [hy] at hl; exact fderivWithin.comp_derivWithin x hl hf hs hxs
| 1,614 |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Comp
import Mathlib.Analysis.Calculus.FDeriv.RestrictScalars
#align_import analysis.calculus.deriv.comp from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Topology Filter ENNReal
open Filter Asymptotics Set
open ContinuousLinearMap (smulRight smulRight_one_eq_iff)
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L Lβ Lβ : Filter π}
section CompositionVector
open ContinuousLinearMap
variable {l : F β E} {l' : F βL[π] E} {y : F}
variable (x)
theorem HasFDerivWithinAt.comp_hasDerivWithinAt {t : Set F} (hl : HasFDerivWithinAt l l' t (f x))
(hf : HasDerivWithinAt f f' s x) (hst : MapsTo f s t) :
HasDerivWithinAt (l β f) (l' f') s x := by
simpa only [one_apply, one_smul, smulRight_apply, coe_comp', (Β· β Β·)] using
(hl.comp x hf.hasFDerivWithinAt hst).hasDerivWithinAt
#align has_fderiv_within_at.comp_has_deriv_within_at HasFDerivWithinAt.comp_hasDerivWithinAt
theorem HasFDerivWithinAt.comp_hasDerivWithinAt_of_eq {t : Set F}
(hl : HasFDerivWithinAt l l' t y)
(hf : HasDerivWithinAt f f' s x) (hst : MapsTo f s t) (hy : y = f x) :
HasDerivWithinAt (l β f) (l' f') s x := by
rw [hy] at hl; exact hl.comp_hasDerivWithinAt x hf hst
theorem HasFDerivAt.comp_hasDerivWithinAt (hl : HasFDerivAt l l' (f x))
(hf : HasDerivWithinAt f f' s x) : HasDerivWithinAt (l β f) (l' f') s x :=
hl.hasFDerivWithinAt.comp_hasDerivWithinAt x hf (mapsTo_univ _ _)
#align has_fderiv_at.comp_has_deriv_within_at HasFDerivAt.comp_hasDerivWithinAt
theorem HasFDerivAt.comp_hasDerivWithinAt_of_eq (hl : HasFDerivAt l l' y)
(hf : HasDerivWithinAt f f' s x) (hy : y = f x) :
HasDerivWithinAt (l β f) (l' f') s x := by
rw [hy] at hl; exact hl.comp_hasDerivWithinAt x hf
theorem HasFDerivAt.comp_hasDerivAt (hl : HasFDerivAt l l' (f x)) (hf : HasDerivAt f f' x) :
HasDerivAt (l β f) (l' f') x :=
hasDerivWithinAt_univ.mp <| hl.comp_hasDerivWithinAt x hf.hasDerivWithinAt
#align has_fderiv_at.comp_has_deriv_at HasFDerivAt.comp_hasDerivAt
theorem HasFDerivAt.comp_hasDerivAt_of_eq
(hl : HasFDerivAt l l' y) (hf : HasDerivAt f f' x) (hy : y = f x) :
HasDerivAt (l β f) (l' f') x := by
rw [hy] at hl; exact hl.comp_hasDerivAt x hf
theorem HasStrictFDerivAt.comp_hasStrictDerivAt (hl : HasStrictFDerivAt l l' (f x))
(hf : HasStrictDerivAt f f' x) : HasStrictDerivAt (l β f) (l' f') x := by
simpa only [one_apply, one_smul, smulRight_apply, coe_comp', (Β· β Β·)] using
(hl.comp x hf.hasStrictFDerivAt).hasStrictDerivAt
#align has_strict_fderiv_at.comp_has_strict_deriv_at HasStrictFDerivAt.comp_hasStrictDerivAt
theorem HasStrictFDerivAt.comp_hasStrictDerivAt_of_eq (hl : HasStrictFDerivAt l l' y)
(hf : HasStrictDerivAt f f' x) (hy : y = f x) :
HasStrictDerivAt (l β f) (l' f') x := by
rw [hy] at hl; exact hl.comp_hasStrictDerivAt x hf
theorem fderivWithin.comp_derivWithin {t : Set F} (hl : DifferentiableWithinAt π l t (f x))
(hf : DifferentiableWithinAt π f s x) (hs : MapsTo f s t) (hxs : UniqueDiffWithinAt π s x) :
derivWithin (l β f) s x = (fderivWithin π l t (f x) : F β E) (derivWithin f s x) :=
(hl.hasFDerivWithinAt.comp_hasDerivWithinAt x hf.hasDerivWithinAt hs).derivWithin hxs
#align fderiv_within.comp_deriv_within fderivWithin.comp_derivWithin
theorem fderivWithin.comp_derivWithin_of_eq {t : Set F} (hl : DifferentiableWithinAt π l t y)
(hf : DifferentiableWithinAt π f s x) (hs : MapsTo f s t) (hxs : UniqueDiffWithinAt π s x)
(hy : y = f x) :
derivWithin (l β f) s x = (fderivWithin π l t (f x) : F β E) (derivWithin f s x) := by
rw [hy] at hl; exact fderivWithin.comp_derivWithin x hl hf hs hxs
theorem fderiv.comp_deriv (hl : DifferentiableAt π l (f x)) (hf : DifferentiableAt π f x) :
deriv (l β f) x = (fderiv π l (f x) : F β E) (deriv f x) :=
(hl.hasFDerivAt.comp_hasDerivAt x hf.hasDerivAt).deriv
#align fderiv.comp_deriv fderiv.comp_deriv
| Mathlib/Analysis/Calculus/Deriv/Comp.lean | 415 | 418 | theorem fderiv.comp_deriv_of_eq (hl : DifferentiableAt π l y) (hf : DifferentiableAt π f x)
(hy : y = f x) :
deriv (l β f) x = (fderiv π l (f x) : F β E) (deriv f x) := by |
rw [hy] at hl; exact fderiv.comp_deriv x hl hf
| 1,614 |
import Mathlib.Analysis.Calculus.Deriv.Comp
import Mathlib.Analysis.Calculus.FDeriv.Equiv
#align_import analysis.calculus.deriv.inverse from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Topology Filter ENNReal
open Filter Asymptotics Set
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L Lβ Lβ : Filter π}
theorem HasStrictDerivAt.hasStrictFDerivAt_equiv {f : π β π} {f' x : π}
(hf : HasStrictDerivAt f f' x) (hf' : f' β 0) :
HasStrictFDerivAt f (ContinuousLinearEquiv.unitsEquivAut π (Units.mk0 f' hf') : π βL[π] π) x :=
hf
#align has_strict_deriv_at.has_strict_fderiv_at_equiv HasStrictDerivAt.hasStrictFDerivAt_equiv
theorem HasDerivAt.hasFDerivAt_equiv {f : π β π} {f' x : π} (hf : HasDerivAt f f' x)
(hf' : f' β 0) :
HasFDerivAt f (ContinuousLinearEquiv.unitsEquivAut π (Units.mk0 f' hf') : π βL[π] π) x :=
hf
#align has_deriv_at.has_fderiv_at_equiv HasDerivAt.hasFDerivAt_equiv
theorem HasStrictDerivAt.of_local_left_inverse {f g : π β π} {f' a : π} (hg : ContinuousAt g a)
(hf : HasStrictDerivAt f f' (g a)) (hf' : f' β 0) (hfg : βαΆ y in π a, f (g y) = y) :
HasStrictDerivAt g f'β»ΒΉ a :=
(hf.hasStrictFDerivAt_equiv hf').of_local_left_inverse hg hfg
#align has_strict_deriv_at.of_local_left_inverse HasStrictDerivAt.of_local_left_inverse
theorem PartialHomeomorph.hasStrictDerivAt_symm (f : PartialHomeomorph π π) {a f' : π}
(ha : a β f.target) (hf' : f' β 0) (htff' : HasStrictDerivAt f f' (f.symm a)) :
HasStrictDerivAt f.symm f'β»ΒΉ a :=
htff'.of_local_left_inverse (f.symm.continuousAt ha) hf' (f.eventually_right_inverse ha)
#align local_homeomorph.has_strict_deriv_at_symm PartialHomeomorph.hasStrictDerivAt_symm
theorem HasDerivAt.of_local_left_inverse {f g : π β π} {f' a : π} (hg : ContinuousAt g a)
(hf : HasDerivAt f f' (g a)) (hf' : f' β 0) (hfg : βαΆ y in π a, f (g y) = y) :
HasDerivAt g f'β»ΒΉ a :=
(hf.hasFDerivAt_equiv hf').of_local_left_inverse hg hfg
#align has_deriv_at.of_local_left_inverse HasDerivAt.of_local_left_inverse
theorem PartialHomeomorph.hasDerivAt_symm (f : PartialHomeomorph π π) {a f' : π} (ha : a β f.target)
(hf' : f' β 0) (htff' : HasDerivAt f f' (f.symm a)) : HasDerivAt f.symm f'β»ΒΉ a :=
htff'.of_local_left_inverse (f.symm.continuousAt ha) hf' (f.eventually_right_inverse ha)
#align local_homeomorph.has_deriv_at_symm PartialHomeomorph.hasDerivAt_symm
theorem HasDerivAt.eventually_ne (h : HasDerivAt f f' x) (hf' : f' β 0) :
βαΆ z in π[β ] x, f z β f x :=
(hasDerivAt_iff_hasFDerivAt.1 h).eventually_ne
β¨βf'ββ»ΒΉ, fun z => by field_simp [norm_smul, mt norm_eq_zero.1 hf']β©
#align has_deriv_at.eventually_ne HasDerivAt.eventually_ne
theorem HasDerivAt.tendsto_punctured_nhds (h : HasDerivAt f f' x) (hf' : f' β 0) :
Tendsto f (π[β ] x) (π[β ] f x) :=
tendsto_nhdsWithin_of_tendsto_nhds_of_eventually_within _ h.continuousAt.continuousWithinAt
(h.eventually_ne hf')
#align has_deriv_at.tendsto_punctured_nhds HasDerivAt.tendsto_punctured_nhds
| Mathlib/Analysis/Calculus/Deriv/Inverse.lean | 112 | 117 | theorem not_differentiableWithinAt_of_local_left_inverse_hasDerivWithinAt_zero {f g : π β π} {a : π}
{s t : Set π} (ha : a β s) (hsu : UniqueDiffWithinAt π s a) (hf : HasDerivWithinAt f 0 t (g a))
(hst : MapsTo g s t) (hfg : f β g =αΆ [π[s] a] id) : Β¬DifferentiableWithinAt π g s a := by |
intro hg
have := (hf.comp a hg.hasDerivWithinAt hst).congr_of_eventuallyEq_of_mem hfg.symm ha
simpa using hsu.eq_deriv _ this (hasDerivWithinAt_id _ _)
| 1,615 |
import Mathlib.Analysis.Calculus.Deriv.Comp
import Mathlib.Analysis.Calculus.FDeriv.Equiv
#align_import analysis.calculus.deriv.inverse from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Topology Filter ENNReal
open Filter Asymptotics Set
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L Lβ Lβ : Filter π}
theorem HasStrictDerivAt.hasStrictFDerivAt_equiv {f : π β π} {f' x : π}
(hf : HasStrictDerivAt f f' x) (hf' : f' β 0) :
HasStrictFDerivAt f (ContinuousLinearEquiv.unitsEquivAut π (Units.mk0 f' hf') : π βL[π] π) x :=
hf
#align has_strict_deriv_at.has_strict_fderiv_at_equiv HasStrictDerivAt.hasStrictFDerivAt_equiv
theorem HasDerivAt.hasFDerivAt_equiv {f : π β π} {f' x : π} (hf : HasDerivAt f f' x)
(hf' : f' β 0) :
HasFDerivAt f (ContinuousLinearEquiv.unitsEquivAut π (Units.mk0 f' hf') : π βL[π] π) x :=
hf
#align has_deriv_at.has_fderiv_at_equiv HasDerivAt.hasFDerivAt_equiv
theorem HasStrictDerivAt.of_local_left_inverse {f g : π β π} {f' a : π} (hg : ContinuousAt g a)
(hf : HasStrictDerivAt f f' (g a)) (hf' : f' β 0) (hfg : βαΆ y in π a, f (g y) = y) :
HasStrictDerivAt g f'β»ΒΉ a :=
(hf.hasStrictFDerivAt_equiv hf').of_local_left_inverse hg hfg
#align has_strict_deriv_at.of_local_left_inverse HasStrictDerivAt.of_local_left_inverse
theorem PartialHomeomorph.hasStrictDerivAt_symm (f : PartialHomeomorph π π) {a f' : π}
(ha : a β f.target) (hf' : f' β 0) (htff' : HasStrictDerivAt f f' (f.symm a)) :
HasStrictDerivAt f.symm f'β»ΒΉ a :=
htff'.of_local_left_inverse (f.symm.continuousAt ha) hf' (f.eventually_right_inverse ha)
#align local_homeomorph.has_strict_deriv_at_symm PartialHomeomorph.hasStrictDerivAt_symm
theorem HasDerivAt.of_local_left_inverse {f g : π β π} {f' a : π} (hg : ContinuousAt g a)
(hf : HasDerivAt f f' (g a)) (hf' : f' β 0) (hfg : βαΆ y in π a, f (g y) = y) :
HasDerivAt g f'β»ΒΉ a :=
(hf.hasFDerivAt_equiv hf').of_local_left_inverse hg hfg
#align has_deriv_at.of_local_left_inverse HasDerivAt.of_local_left_inverse
theorem PartialHomeomorph.hasDerivAt_symm (f : PartialHomeomorph π π) {a f' : π} (ha : a β f.target)
(hf' : f' β 0) (htff' : HasDerivAt f f' (f.symm a)) : HasDerivAt f.symm f'β»ΒΉ a :=
htff'.of_local_left_inverse (f.symm.continuousAt ha) hf' (f.eventually_right_inverse ha)
#align local_homeomorph.has_deriv_at_symm PartialHomeomorph.hasDerivAt_symm
theorem HasDerivAt.eventually_ne (h : HasDerivAt f f' x) (hf' : f' β 0) :
βαΆ z in π[β ] x, f z β f x :=
(hasDerivAt_iff_hasFDerivAt.1 h).eventually_ne
β¨βf'ββ»ΒΉ, fun z => by field_simp [norm_smul, mt norm_eq_zero.1 hf']β©
#align has_deriv_at.eventually_ne HasDerivAt.eventually_ne
theorem HasDerivAt.tendsto_punctured_nhds (h : HasDerivAt f f' x) (hf' : f' β 0) :
Tendsto f (π[β ] x) (π[β ] f x) :=
tendsto_nhdsWithin_of_tendsto_nhds_of_eventually_within _ h.continuousAt.continuousWithinAt
(h.eventually_ne hf')
#align has_deriv_at.tendsto_punctured_nhds HasDerivAt.tendsto_punctured_nhds
theorem not_differentiableWithinAt_of_local_left_inverse_hasDerivWithinAt_zero {f g : π β π} {a : π}
{s t : Set π} (ha : a β s) (hsu : UniqueDiffWithinAt π s a) (hf : HasDerivWithinAt f 0 t (g a))
(hst : MapsTo g s t) (hfg : f β g =αΆ [π[s] a] id) : Β¬DifferentiableWithinAt π g s a := by
intro hg
have := (hf.comp a hg.hasDerivWithinAt hst).congr_of_eventuallyEq_of_mem hfg.symm ha
simpa using hsu.eq_deriv _ this (hasDerivWithinAt_id _ _)
#align not_differentiable_within_at_of_local_left_inverse_has_deriv_within_at_zero not_differentiableWithinAt_of_local_left_inverse_hasDerivWithinAt_zero
| Mathlib/Analysis/Calculus/Deriv/Inverse.lean | 120 | 124 | theorem not_differentiableAt_of_local_left_inverse_hasDerivAt_zero {f g : π β π} {a : π}
(hf : HasDerivAt f 0 (g a)) (hfg : f β g =αΆ [π a] id) : Β¬DifferentiableAt π g a := by |
intro hg
have := (hf.comp a hg.hasDerivAt).congr_of_eventuallyEq hfg.symm
simpa using this.unique (hasDerivAt_id a)
| 1,615 |
import Mathlib.Analysis.Calculus.ContDiff.Defs
import Mathlib.Analysis.Calculus.FDeriv.Add
import Mathlib.Analysis.Calculus.FDeriv.Mul
import Mathlib.Analysis.Calculus.Deriv.Inverse
#align_import analysis.calculus.cont_diff from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
noncomputable section
open scoped Classical NNReal Nat
local notation "β" => (β€ : ββ)
universe u v w uD uE uF uG
attribute [local instance 1001]
NormedAddCommGroup.toAddCommGroup NormedSpace.toModule' AddCommGroup.toAddCommMonoid
open Set Fin Filter Function
open scoped Topology
variable {π : Type*} [NontriviallyNormedField π] {D : Type uD} [NormedAddCommGroup D]
[NormedSpace π D] {E : Type uE} [NormedAddCommGroup E] [NormedSpace π E] {F : Type uF}
[NormedAddCommGroup F] [NormedSpace π F] {G : Type uG} [NormedAddCommGroup G] [NormedSpace π G]
{X : Type*} [NormedAddCommGroup X] [NormedSpace π X] {s sβ t u : Set E} {f fβ : E β F}
{g : F β G} {x xβ : E} {c : F} {b : E Γ F β G} {m n : ββ} {p : E β FormalMultilinearSeries π E F}
@[simp]
| Mathlib/Analysis/Calculus/ContDiff/Basic.lean | 62 | 70 | theorem iteratedFDerivWithin_zero_fun (hs : UniqueDiffOn π s) (hx : x β s) {i : β} :
iteratedFDerivWithin π i (fun _ : E β¦ (0 : F)) s x = 0 := by |
induction i generalizing x with
| zero => ext; simp
| succ i IH =>
ext m
rw [iteratedFDerivWithin_succ_apply_left, fderivWithin_congr (fun _ β¦ IH) (IH hx)]
rw [fderivWithin_const_apply _ (hs x hx)]
rfl
| 1,616 |
import Mathlib.Analysis.Calculus.ContDiff.Defs
import Mathlib.Analysis.Calculus.FDeriv.Add
import Mathlib.Analysis.Calculus.FDeriv.Mul
import Mathlib.Analysis.Calculus.Deriv.Inverse
#align_import analysis.calculus.cont_diff from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
noncomputable section
open scoped Classical NNReal Nat
local notation "β" => (β€ : ββ)
universe u v w uD uE uF uG
attribute [local instance 1001]
NormedAddCommGroup.toAddCommGroup NormedSpace.toModule' AddCommGroup.toAddCommMonoid
open Set Fin Filter Function
open scoped Topology
variable {π : Type*} [NontriviallyNormedField π] {D : Type uD} [NormedAddCommGroup D]
[NormedSpace π D] {E : Type uE} [NormedAddCommGroup E] [NormedSpace π E] {F : Type uF}
[NormedAddCommGroup F] [NormedSpace π F] {G : Type uG} [NormedAddCommGroup G] [NormedSpace π G]
{X : Type*} [NormedAddCommGroup X] [NormedSpace π X] {s sβ t u : Set E} {f fβ : E β F}
{g : F β G} {x xβ : E} {c : F} {b : E Γ F β G} {m n : ββ} {p : E β FormalMultilinearSeries π E F}
@[simp]
theorem iteratedFDerivWithin_zero_fun (hs : UniqueDiffOn π s) (hx : x β s) {i : β} :
iteratedFDerivWithin π i (fun _ : E β¦ (0 : F)) s x = 0 := by
induction i generalizing x with
| zero => ext; simp
| succ i IH =>
ext m
rw [iteratedFDerivWithin_succ_apply_left, fderivWithin_congr (fun _ β¦ IH) (IH hx)]
rw [fderivWithin_const_apply _ (hs x hx)]
rfl
@[simp]
theorem iteratedFDeriv_zero_fun {n : β} : (iteratedFDeriv π n fun _ : E β¦ (0 : F)) = 0 :=
funext fun x β¦ by simpa [β iteratedFDerivWithin_univ] using
iteratedFDerivWithin_zero_fun uniqueDiffOn_univ (mem_univ x)
#align iterated_fderiv_zero_fun iteratedFDeriv_zero_fun
theorem contDiff_zero_fun : ContDiff π n fun _ : E => (0 : F) :=
contDiff_of_differentiable_iteratedFDeriv fun m _ => by
rw [iteratedFDeriv_zero_fun]
exact differentiable_const (0 : E[Γm]βL[π] F)
#align cont_diff_zero_fun contDiff_zero_fun
| Mathlib/Analysis/Calculus/ContDiff/Basic.lean | 86 | 91 | theorem contDiff_const {c : F} : ContDiff π n fun _ : E => c := by |
suffices h : ContDiff π β fun _ : E => c from h.of_le le_top
rw [contDiff_top_iff_fderiv]
refine β¨differentiable_const c, ?_β©
rw [fderiv_const]
exact contDiff_zero_fun
| 1,616 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.