text
stringlengths 0
3.34M
|
|---|
module Calc
%default total
public export
addInts : Int -> Int -> Int
addInts x y = x + y
public export
subInts : Int -> Int -> Int
subInts x y = x - y
public export
mulInts : Int -> Int -> Int
mulInts x y = x * y
public export
divInts : Int -> Int -> Int
divInts x y = x `div` y
|
module Fix
%access public export
data Fix : (f : Type -> Type) -> Type where
In : f (Fix f) -> Fix f
Show (f (Fix f)) => Show (Fix f) where
show x = "In " ++ show x
inop : Fix f -> f (Fix f)
inop (In x) = x
cata : Functor f => (f a -> a) -> Fix f -> a
cata alg = alg . map (cata alg) . inop
|
open import Prelude
open import dynamics-core
module lemmas-matching where
-- arrow matching produces unique answers
▸arr-unicity : ∀{τ τ2 τ3} →
τ ▸arr τ2 →
τ ▸arr τ3 →
τ2 == τ3
▸arr-unicity MAHole MAHole = refl
▸arr-unicity MAArr MAArr = refl
-- only consistent types arrow match
▸arr-consist : ∀{τ1 τ2} →
τ1 ▸arr τ2 →
(τ1 ~ τ2)
▸arr-consist MAHole = TCHole2
▸arr-consist MAArr = TCRefl
-- if an arrow matches, then it's consistent with the
-- least restrictive function type
▸arr-consist-hole : ∀{t t'} →
t ▸arr t' →
t ~ (⦇-⦈ ==> ⦇-⦈)
▸arr-consist-hole MAHole = TCHole2
▸arr-consist-hole MAArr = TCArr TCHole1 TCHole1
-- sum matching produces unique answers
▸sum-unicity : ∀{τ τ2 τ3} →
τ ▸sum τ2 →
τ ▸sum τ3 →
τ2 == τ3
▸sum-unicity MSHole MSHole = refl
▸sum-unicity MSSum MSSum = refl
-- only consistent types sum match
▸sum-consist : ∀{τ1 τ2} →
τ1 ▸sum τ2 →
(τ1 ~ τ2)
▸sum-consist MSHole = TCHole2
▸sum-consist MSSum = TCRefl
-- if a sum matches, then it's consistent with the
-- least restrictive function type
▸sum-consist-hole : ∀{t t'} →
t ▸sum t' →
t ~ (⦇-⦈ ⊕ ⦇-⦈)
▸sum-consist-hole MSHole = TCHole2
▸sum-consist-hole MSSum = TCSum TCHole1 TCHole1
-- product matching produces unique answers
▸prod-unicity : ∀{τ τ2 τ3} →
τ ▸prod τ2 →
τ ▸prod τ3 →
τ2 == τ3
▸prod-unicity MPHole MPHole = refl
▸prod-unicity MPProd MPProd = refl
-- only consistent types product match
▸prod-consist : ∀{τ1 τ2} →
τ1 ▸prod τ2 →
(τ1 ~ τ2)
▸prod-consist MPHole = TCHole2
▸prod-consist MPProd = TCRefl
-- if a sum matches, then it's consistent with the
-- least restrictive function type
▸prod-consist-hole : ∀{t t'} →
t ▸prod t' →
t ~ (⦇-⦈ ⊠ ⦇-⦈)
▸prod-consist-hole MPHole = TCHole2
▸prod-consist-hole MPProd = TCProd TCHole1 TCHole1
|
% **********************************************************************
% Author: Ajahn Chah
% Translator:
% Title: A Message from Thailand
% First published: Seeing The Way Vol 1.
% Comment: The following message by Venerable Ajahn Chah was sent to his disciples in England whilst he was resident at a branch monastery called `The Cave of Diamond Light,' just prior to the serious decline in his health during the rainy season retreat (vassa) of 1981.
% Copyright: Permission granted by Wat Pah Nanachat to reprint for free distribution
% **********************************************************************
% Notes on the text:
% This letter was previously published in `Seeing the Way'
% **********************************************************************
\chapter{A Message from Thailand}
\index[general]{Sa\.ngha!Western}
\index[general]{Chithurst}
\dropcaps{I}{ have come up} to Wat Tham Saeng Pet for the rains retreat this year -- mostly for a change of air as my health has not been so good. With me are a few Western monks: Santa, Pabhakaro, Pamutto, Michael and S\=ama\d{n}era Guy; also some Thai monks and a small number of laypeople who are keen to practise. This is a pleasant and fortunate time for us. At the moment my sickness has subsided, so I feel well enough to record this message for you all.
\index[general]{Sumedho, Ajahn}
Because of this ill-health I cannot visit England, so hearing news of you, from some of your supporters who are staying here, has made me very happy and relieved. The thing that pleases me most is that Sumedho is now able to ordain monks; this shows that your efforts to establish Buddhism in England have been quite successful.
It is also pleasing to see the names of the monks and nuns whom I know, who are living with Sumedho at Chithurst: Anando, Viradhammo, Sucitto, Uppanno, Kittisaro, and Amaro. Also Mae Chees Rocana and Candasiri. I hope you are all in good health and living harmoniously together, co-operating and proceeding well in Dhamma practice.
There are supporters, both in England and here in Thailand, who help keep me up to date with your developments. I gather from them that the building work at Chithurst is complete, and that it is now a much more comfortable place to live. I often enquire about this, as I remember my stay of seven days there was quite difficult! (Laughter). I hear that the shrine-room and the other main areas are now all finished. With less building work to be carried out, the community will be able to apply itself more fully to formal practice.
I understand also that some of the senior monks have been moved off to start branch monasteries. This is normal practice, but it can lead to a predominance of junior monks at the main monastery; this has been the case in the past at Wat Pah Pong. This can bring difficulties in the teaching and training of monks, so it is very important in these situations that we help one another.
I trust that Sumedho is not allowing these sort of things to burden him! These are small matters, quite normal, they are not a problem at all. Certainly there are responsibilities -- but it can also be seen that there are none.
\index[general]{abbot!of a monastery}
\index[similes]{rubbish bin!being an abbot}
To be the abbot of a monastery can be compared to being a rubbish bin: those who are disturbed by the presence of rubbish make a bin, in the hope that people will put their rubbish in there. In actual fact what happens is that the person who makes the bin ends up being the rubbish collector as well. This is how things are -- it's the same at Wat Pah Pong; it was the same at the time of the Buddha. No-one else puts the rubbish into it so we have to do it ourselves, and everything gets chucked into the abbot's bin! One in such a position must therefore be far-sighted, have depth, and remain unshaken in the midst of all things; they must be consistent and able to persevere. Of all the qualities we develop in our lives, patient endurance is the most important.
\index[general]{monasteries!easy to build, difficult to maintain}
It is true that the establishment of a suitable dwelling place at Chithurst has been completed; the construction of a building is not difficult, a couple of years and it is done. What has not been completed, though, is the work of upkeep and maintenance -- the sweeping, washing and so forth have to go on forever. It is not difficult to build a monastery, but it is difficult to maintain it; likewise, it is not difficult to ordain someone, but to train them fully in the monastic life is hard. This should not be taken as a problem, though, for to do that which is hard is very beneficial; doing only that which is easy does not have much use. Therefore, in order to nurture and maintain the seed of Buddhism which has been planted at Chithurst, you must now all be prepared to put forth your energies and help.
I hope that what I have said today has conveyed feelings of warmth and support to you. Whenever I meet Thai people who have connections in England, I ask if they have been to visit Chithurst. It seems, from them, that there is a great deal of interest in a branch monastery being there. Also, foreigners who come here will frequently have visited Wat Nanachat and have news of you in England as well. It makes me very happy to see that there is such a close and co-operative relationship between Wat Pah Pong, Wat Nanachat and Wat Chithurst.
That is all I have to say, except that my feelings of loving-kindness are with you all. May you be well and happy, abiding in harmony, co-operation and togetherness. May the blessings of the Buddha, the Dhamma and the Sa\.ngha always be firmly established in your hearts -- may you be well.
|
##################################################
# Innovation Laboratory
# Center For Molecular Oncology
# Memorial Sloan Kettering Cancer Research Center
# Maintainer: Ian Johnson ([email protected])
##################################################
library(grid)
library(yaml)
library(tidyr)
library(scales)
library(gridBase)
library(gridExtra)
library(lattice)
library(ggplot2)
library(reshape2)
library(data.table)
suppressMessages(library(dplyr))
#' Util function to sort data by arbitrary list
#' @param df The data.frame to be sorted
#' @param sort_column String - column to sort on
#' @param sort_list optional Vector of strings ordered in desired sort order for @df
sort_df = function(df, sort_column, sort_list) {
if (!missing(sort_list)) {
sort_list = unique(unlist(sort_list))
sort_list = as.factor(sort_list)
df[[sort_column]] <- factor(df[[sort_column]], levels=sort_list)
} else {
df[[sort_column]] <- factor(df[[sort_column]])
}
df = df[order(df[[sort_column]]),]
return(df)
}
#' Function to read inputs from argv
#' @return object with parsed arguments
read_inputs = function() {
spec = matrix(c(
'tables_output_dir', 'i', 1, 'character',
'title_file_path', 't', 1, 'character',
'inputs_yaml_path', 'y', 1, 'character',
'family_types_A_path', 'f', 1, 'character',
'family_types_B_path', 'g', 1, 'character',
'family_sizes_path', 'h', 1, 'character'
), byrow=TRUE, ncol=4);
opts = getopt(spec);
return(opts)
}
#' Util function to merge various computed tables with original experiment title file
#' @param data data.frame to be used
#' @param title_df The title file as a data.frame
merge_in_title_file_data = function(data, title_df) {
merged = merge(
data,
title_df,
by=paste(SAMPLE_ID_COLUMN))
return(merged)
}
#' Extract actual sample names from full filenames
#'
#' @param data data.frame of sample manifest with proper CMO_SAMPLE_ID column
#' @param sample_names String[] with proper Sample IDs to be found
#'
#' Ex: sample_names = c('test_sample_T', 'test_sample_N')
#' test_sample_T_001_aln_srt_MD_IR_FX_BR -> test_sample_T
cleanup_sample_names = function(data, sample_names) {
# Need to reverse sort to get longer matches first - not necessary if '^' is used to indicate start of sample names
sample_names = sample_names[order(nchar(sample_names), sample_names, decreasing = TRUE)]
find.string = paste(paste0("^", unlist(sample_names)), collapse = '|')
find.string = paste0('.*(', find.string, ').*', collapse='', sep='')
data[, SAMPLE_ID_COLUMN] = gsub(find.string, '\\1', data[, SAMPLE_ID_COLUMN])
return(data)
}
|
[STATEMENT]
lemma [simp]: "ack \<in> SYN"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. ack \<in> SYN
[PROOF STEP]
by(auto simp: SYN_def) |
data Vect : Nat -> Type -> Type where
Nil : Vect Z a
(::) : a -> Vect k a -> Vect (S k) a
%name Vect xs, ys, zs
replicate : {m : Nat} -> a -> Vect m a
transpose : {m : Nat} -> Vect n (Vect m a) -> Vect m (Vect n a)
transpose [] = ?transpose_rhs_1
transpose (x :: xs) = ?transpose_rhs_2
|
using Interpolations
"""
Does a cubic spline interpolation and then takes a derivative across
the row for each column
"""
function numerical_derivative(dat, ts)
# Take the approximate derivative in the row direction
interp = []
dat_grad = zeros(size(dat))
if ts isa Array
# Breaks the interpolation function if 'ts' is an array
dt = ts[2]-ts[1]
ts = ts[1]:dt:ts[end]
end
for i in 1:size(dat,1)
push!(interp,CubicSplineInterpolation(ts, dat[i,:]))
for (i2, t) in enumerate(ts)
dat_grad[i,i2] = Array(Interpolations.gradient(interp[i], t))[1]
end
end
return dat_grad
end
export numerical_derivative
|
In addition to acting in films , Fernandez has supported charitable organisations and a number of causes . In 2011 , on the behalf of People for the Ethical Treatment of Animals ( PETA ) , she sent a letter to the Mumbai Municipal Commissioner asking for an end to horse @-@ drawn carriage rides in Mumbai . In early 2013 , she asked the consulate general of the Philippines , William John T Perera in Colombo , to hasten the transfer of an elephant from its inadequate housing at the Manila Zoo to a humane sanctuary . Later that year , she auctioned a breakfast in Mayfair , London , where she raised around £ 4000 for the Pratham NGO , which helps children 's primary education . In 2014 , Fernandez was named " Woman Of The Year " by PETA ( India ) for advocating the protection of animals . The following year , she auctioned her outfits on an online portal for a philanthropic cause . Some of her outfits included the ones she wore in the song " Party On My Mind " ( from Race 2 ) and " Hangover " ( from Kick ) . In March 2016 , she was part of " Jacqueline Builds " campaign that raised funds for the victims of the 2015 South Indian floods .
|
Formal statement is: lemma convex_halfspace_Re_ge: "convex {x. Re x \<ge> b}" Informal statement is: The set of complex numbers with real part greater than or equal to $b$ is convex. |
If $x$ and $y$ are in the same connected component of $S$, and $y$ and $z$ are in the same connected component of $S$, then $x$ and $z$ are in the same connected component of $S$. |
%% igviridis
% Below is a demonstration of the features of the |igviridis| function
%%
clear; close all; clc;
%% Syntax
% |[cMap]=igviridis(varargin);|
%% Description
% UNDOCUMENTED
%% Examples
%
%%
%
% <<gibbVerySmall.gif>>
%
% _*GIBBON*_
% <www.gibboncode.org>
%
% _Kevin Mattheus Moerman_, <[email protected]>
%%
% _*GIBBON footer text*_
%
% License: <https://github.com/gibbonCode/GIBBON/blob/master/LICENSE>
%
% GIBBON: The Geometry and Image-based Bioengineering add-On. A toolbox for
% image segmentation, image-based modeling, meshing, and finite element
% analysis.
%
% Copyright (C) 2006-2022 Kevin Mattheus Moerman and the GIBBON contributors
%
% This program is free software: you can redistribute it and/or modify
% it under the terms of the GNU General Public License as published by
% the Free Software Foundation, either version 3 of the License, or
% (at your option) any later version.
%
% This program is distributed in the hope that it will be useful,
% but WITHOUT ANY WARRANTY; without even the implied warranty of
% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
% GNU General Public License for more details.
%
% You should have received a copy of the GNU General Public License
% along with this program. If not, see <http://www.gnu.org/licenses/>.
|
SUBROUTINE GDMMRK ( marker, kx, ky, ix1, iy1, ix2, iy2, ixinc,
+ istag, iyinc, iret )
C************************************************************************
C* GDMMRK *
C* *
C* This subroutine plots markers for GDMAP. *
C* *
C* GDMMRK ( MARKER, KX, KY, IX1, IY1, IX2, IY2, IXINC, ISTAG, IYINC, *
C* IRET ) *
C* *
C* Input parameters: *
C* MARKER CHAR* Input for MARKER *
C* KX INTEGER Number of points in x dir *
C* KY INTEGER Number of points in y dir *
C* IX1 INTEGER Initial x point *
C* IY1 INTEGER Initial y point *
C* IX2 INTEGER Last x point *
C* IY2 INTEGER Last y point *
C* IXINC INTEGER X increment *
C* ISTAG INTEGER Stagger increment *
C* IYINC INTEGER Y increment *
C* *
C* Output parameters: *
C* IRET INTEGER Return code *
C* 0 = normal return *
C** *
C* Log: *
C* M. desJardins/GSFC 4/85 *
C* M. desJardins/GSFC 8/88 Cleaned up *
C* G. Huffman/GSC 1/89 No plotting for color .lt. 1 *
C* S. Jacobs/NMC 9/94 Added staggered plotting *
C************************************************************************
CHARACTER*(*) marker
C------------------------------------------------------------------------
iret = 0
C
C* Translate marker input.
C
CALL IN_MARK ( marker, imcolr, ier )
C
C* If color number .lt. 1, don't plot.
C
IF ( imcolr .gt. 0 ) THEN
C
C* Set marker color.
C
CALL GSCOLR ( imcolr, ier )
C
C* Plot markers.
C
ixstrt = ix1
DO j = iy1, iy2, iyinc
fj = FLOAT (j)
DO i = ixstrt, ix2, ixinc
fi = FLOAT (i)
CALL GMARK ( 'G', 1, fi, fj, ier )
END DO
IF ( ixstrt .eq. ix1 ) THEN
ixstrt = ixstrt + istag
ELSE
ixstrt = ix1
END IF
END DO
END IF
C*
RETURN
END
|
module Graphics.Rendering.Gl.Buffers
%include C "gl_idris.h"
%link C "gl_idris.o"
%access public export
free : Ptr -> IO ()
free ptr = foreign FFI_C "free" (Ptr -> IO ()) ptr
-- ----------------------------------------------------------------- [ Double Buffers ]
private
setDouble : Ptr -> (idx: Nat) -> Double -> IO ()
setDouble ptr idx d = foreign FFI_C "idr_buffers_set_double" (Ptr -> Int -> Double -> IO ()) ptr (cast idx) d
||| allocates a C-Array for n doubles
||| @n the number of doubles to store
doubleBuffer : (n: Int) -> IO Ptr
doubleBuffer n = foreign FFI_C "idr_buffers_double_buffer" (Int -> IO Ptr) n
||| convert a List of doubles to a C-Array
doublesToBuffer : List Double -> IO Ptr
doublesToBuffer xs =
do ptr <- doubleBuffer $ toIntNat $ length xs
writeDoubleBuffer' ptr Z xs
pure ptr
where writeDoubleBuffer' : Ptr -> Nat -> List Double -> IO ()
writeDoubleBuffer' ptr i [] = pure ()
writeDoubleBuffer' ptr i (d :: ds) = do setDouble ptr i d
writeDoubleBuffer' ptr (S i) ds
||| the size of a C-double
sizeofDouble : IO Int
sizeofDouble = foreign FFI_C "idr_buffers_double_size" (IO Int)
-- ----------------------------------------------------------------- [ Float Buffers ]
private
setFloat : Ptr -> (idx: Nat) -> Double -> IO ()
setFloat ptr idx d = foreign FFI_C "idr_buffers_set_float" (Ptr -> Int -> Double -> IO ()) ptr (cast idx) d
||| allocates a C-Array of floats for n doubles
||| @n the number of doubles to store
floatBuffer : (n: Int) -> IO Ptr
floatBuffer n = foreign FFI_C "idr_buffers_float_buffer" (Int -> IO Ptr) n
||| converts n Doubles to a C-Array containing n floats
floatsToBuffer : List Double -> IO Ptr
floatsToBuffer xs =
do ptr <- floatBuffer $ toIntNat $ length xs
writeFloatBuffer' ptr Z xs
pure ptr
where writeFloatBuffer' : Ptr -> Nat -> List Double -> IO ()
writeFloatBuffer' ptr i [] = pure ()
writeFloatBuffer' ptr i (d :: ds) = do setFloat ptr i d
writeFloatBuffer' ptr (S i) ds
||| the size of a C-float
sizeofFloat : IO Int
sizeofFloat = foreign FFI_C "idr_buffers_float_size" (IO Int)
-- ----------------------------------------------------------------- [ String Buffers ]
private
setString : Ptr -> (idx: Nat) -> String -> IO ()
setString ptr idx str = foreign FFI_C "idr_buffers_set_string" (Ptr -> Int -> String -> IO ()) ptr (cast idx) str
stringBuffer : (n: Int) -> IO Ptr
stringBuffer n = foreign FFI_C "idr_buffers_string_buffer" (Int -> IO Ptr) n
||| convers n Strings to a C-Array
stringsToBuffer : List String -> IO Ptr
stringsToBuffer xs =
do ptr <- stringBuffer $ toIntNat $ length xs
writeStringBuffer' ptr Z xs
pure ptr
where writeStringBuffer' : Ptr -> Nat -> List String -> IO ()
writeStringBuffer' ptr i [] = pure ()
writeStringBuffer' ptr i (d :: ds) = do setString ptr i d
writeStringBuffer' ptr (S i) ds
freeStringBuffer : Ptr -> (n: Int) -> IO ()
freeStringBuffer ptr n = foreign FFI_C "idr_buffers_free_string_buffer" (Ptr -> Int -> IO ()) ptr n
-- ----------------------------------------------------------------- [ Int Buffers ]
private
setInt : Ptr -> (idx: Nat) -> Int -> IO ()
setInt ptr idx i = foreign FFI_C "idr_buffers_set_int" (Ptr -> Int -> Int -> IO ()) ptr (cast idx) i
private
readInt : Ptr -> (idx: Nat) -> IO Int
readInt ptr idx = foreign FFI_C "idr_buffers_read_int" (Ptr -> Int -> IO Int) ptr (cast idx)
||| allocates a C-Array for n ints
||| @n the number of ints to store
intBuffer : (n: Int) -> IO Ptr
intBuffer n = foreign FFI_C "idr_buffers_int_buffer" (Int -> IO Ptr) n
||| convers n Strings to a C-Array
intsToBuffer : List Int -> IO Ptr
intsToBuffer xs =
do ptr <- intBuffer $ toIntNat $ length xs
writeIntBuffer' ptr Z xs
pure ptr
where writeIntBuffer' : Ptr -> Nat -> List Int -> IO ()
writeIntBuffer' ptr i [] = pure ()
writeIntBuffer' ptr i (d :: ds) = do setInt ptr i d
writeIntBuffer' ptr (S i) ds
||| convert a C-Array of ints to a List
||| @ n how many ints to read from the buffer
intBufferToList : Ptr -> (n: Int) -> IO (List Int)
intBufferToList ptr n = readIntBuffer' ptr [] (cast n)
where readIntBuffer' : Ptr -> List Int -> Nat -> IO (List Int)
readIntBuffer' ptr xs Z = pure xs
readIntBuffer' ptr xs (S k) = do x <- readInt ptr k
readIntBuffer' ptr (x :: xs) k
||| the size of a C-int
sizeofInt : IO Int
sizeofInt = foreign FFI_C "idr_buffers_int_size" (IO Int)
|
[STATEMENT]
lemma all_restr: "\<^bold>\<forall>\<^sup>R(\<delta>)\<pi> = \<^bold>\<forall>[\<pi>|\<delta>]\<^sup>P"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<^bold>\<forall>\<^sup>R\<delta>\<pi> = \<^bold>\<forall>\<^sup>R\<delta>\<pi>
[PROOF STEP]
by simp |
/-
Copyright (c) 2021 Andrew Yang. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Andrew Yang
-/
import algebraic_geometry.presheafed_space.has_colimits
import category_theory.limits.shapes.binary_products
import category_theory.limits.preserves.shapes.pullbacks
import topology.sheaves.functors
import algebraic_geometry.Scheme
import category_theory.limits.shapes.strict_initial
import category_theory.limits.shapes.comm_sq
import algebra.category.Ring.instances
import topology.local_at_target
/-!
# Open immersions of structured spaces
We say that a morphism of presheafed spaces `f : X ⟶ Y` is an open immersions if
the underlying map of spaces is an open embedding `f : X ⟶ U ⊆ Y`,
and the sheaf map `Y(V) ⟶ f _* X(V)` is an iso for each `V ⊆ U`.
Abbreviations are also provided for `SheafedSpace`, `LocallyRingedSpace` and `Scheme`.
## Main definitions
* `algebraic_geometry.PresheafedSpace.is_open_immersion`: the `Prop`-valued typeclass asserting
that a PresheafedSpace hom `f` is an open_immersion.
* `algebraic_geometry.is_open_immersion`: the `Prop`-valued typeclass asserting
that a Scheme morphism `f` is an open_immersion.
* `algebraic_geometry.PresheafedSpace.is_open_immersion.iso_restrict`: The source of an
open immersion is isomorphic to the restriction of the target onto the image.
* `algebraic_geometry.PresheafedSpace.is_open_immersion.lift`: Any morphism whose range is
contained in an open immersion factors though the open immersion.
* `algebraic_geometry.PresheafedSpace.is_open_immersion.to_SheafedSpace`: If `f : X ⟶ Y` is an
open immersion of presheafed spaces, and `Y` is a sheafed space, then `X` is also a sheafed
space. The morphism as morphisms of sheafed spaces is given by `to_SheafedSpace_hom`.
* `algebraic_geometry.PresheafedSpace.is_open_immersion.to_LocallyRingedSpace`: If `f : X ⟶ Y` is
an open immersion of presheafed spaces, and `Y` is a locally ringed space, then `X` is also a
locally ringed space. The morphism as morphisms of locally ringed spaces is given by
`to_LocallyRingedSpace_hom`.
## Main results
* `algebraic_geometry.PresheafedSpace.is_open_immersion.comp`: The composition of two open
immersions is an open immersion.
* `algebraic_geometry.PresheafedSpace.is_open_immersion.of_iso`: An iso is an open immersion.
* `algebraic_geometry.PresheafedSpace.is_open_immersion.to_iso`:
A surjective open immersion is an isomorphism.
* `algebraic_geometry.PresheafedSpace.is_open_immersion.stalk_iso`: An open immersion induces
an isomorphism on stalks.
* `algebraic_geometry.PresheafedSpace.is_open_immersion.has_pullback_of_left`: If `f` is an open
immersion, then the pullback `(f, g)` exists (and the forgetful functor to `Top` preserves it).
* `algebraic_geometry.PresheafedSpace.is_open_immersion.pullback_snd_of_left`: Open immersions
are stable under pullbacks.
* `algebraic_geometry.SheafedSpace.is_open_immersion.of_stalk_iso` An (topological) open embedding
between two sheafed spaces is an open immersion if all the stalk maps are isomorphisms.
-/
open topological_space category_theory opposite
open category_theory.limits
namespace algebraic_geometry
universes v v₁ v₂ u
variables {C : Type u} [category.{v} C]
/--
An open immersion of PresheafedSpaces is an open embedding `f : X ⟶ U ⊆ Y` of the underlying
spaces, such that the sheaf map `Y(V) ⟶ f _* X(V)` is an iso for each `V ⊆ U`.
-/
class PresheafedSpace.is_open_immersion {X Y : PresheafedSpace.{v} C} (f : X ⟶ Y) : Prop :=
(base_open : open_embedding f.base)
(c_iso : ∀ U : opens X, is_iso (f.c.app (op (base_open.is_open_map.functor.obj U))))
/--
A morphism of SheafedSpaces is an open immersion if it is an open immersion as a morphism
of PresheafedSpaces
-/
abbreviation SheafedSpace.is_open_immersion {X Y : SheafedSpace.{v} C} (f : X ⟶ Y) : Prop :=
PresheafedSpace.is_open_immersion f
/--
A morphism of LocallyRingedSpaces is an open immersion if it is an open immersion as a morphism
of SheafedSpaces
-/
abbreviation LocallyRingedSpace.is_open_immersion {X Y : LocallyRingedSpace} (f : X ⟶ Y) : Prop :=
SheafedSpace.is_open_immersion f.1
/--
A morphism of Schemes is an open immersion if it is an open immersion as a morphism
of LocallyRingedSpaces
-/
abbreviation is_open_immersion {X Y : Scheme} (f : X ⟶ Y) : Prop :=
LocallyRingedSpace.is_open_immersion f
namespace PresheafedSpace.is_open_immersion
open PresheafedSpace
local notation `is_open_immersion` := PresheafedSpace.is_open_immersion
attribute [instance] is_open_immersion.c_iso
section
variables {X Y : PresheafedSpace.{v} C} {f : X ⟶ Y} (H : is_open_immersion f)
/-- The functor `opens X ⥤ opens Y` associated with an open immersion `f : X ⟶ Y`. -/
abbreviation open_functor := H.base_open.is_open_map.functor
/-- An open immersion `f : X ⟶ Y` induces an isomorphism `X ≅ Y|_{f(X)}`. -/
@[simps hom_c_app] noncomputable
def iso_restrict : X ≅ Y.restrict H.base_open :=
PresheafedSpace.iso_of_components (iso.refl _)
begin
symmetry,
fapply nat_iso.of_components,
intro U,
refine as_iso (f.c.app (op (H.open_functor.obj (unop U)))) ≪≫ X.presheaf.map_iso (eq_to_iso _),
{ induction U using opposite.rec,
cases U,
dsimp only [is_open_map.functor, functor.op, opens.map],
congr' 2,
erw set.preimage_image_eq _ H.base_open.inj,
refl },
{ intros U V i,
simp only [category_theory.eq_to_iso.hom, Top.presheaf.pushforward_obj_map, category.assoc,
functor.op_map, iso.trans_hom, as_iso_hom, functor.map_iso_hom, ←X.presheaf.map_comp],
erw [f.c.naturality_assoc, ←X.presheaf.map_comp],
congr }
end
@[simp] lemma iso_restrict_hom_of_restrict : H.iso_restrict.hom ≫ Y.of_restrict _ = f :=
begin
ext,
{ simp only [comp_c_app, iso_restrict_hom_c_app, nat_trans.comp_app,
eq_to_hom_refl, of_restrict_c_app, category.assoc, whisker_right_id'],
erw [category.comp_id, f.c.naturality_assoc, ←X.presheaf.map_comp],
transitivity f.c.app x ≫ X.presheaf.map (𝟙 _),
{ congr },
{ erw [X.presheaf.map_id, category.comp_id] } },
{ refl, }
end
@[simp] lemma iso_restrict_inv_of_restrict : H.iso_restrict.inv ≫ f = Y.of_restrict _ :=
by { rw [iso.inv_comp_eq, iso_restrict_hom_of_restrict] }
instance mono [H : is_open_immersion f] : mono f :=
by { rw ← H.iso_restrict_hom_of_restrict, apply mono_comp }
/-- The composition of two open immersions is an open immersion. -/
instance comp {Z : PresheafedSpace C} (f : X ⟶ Y) [hf : is_open_immersion f] (g : Y ⟶ Z)
[hg : is_open_immersion g] :
is_open_immersion (f ≫ g) :=
{ base_open := hg.base_open.comp hf.base_open,
c_iso := λ U,
begin
generalize_proofs h,
dsimp only [algebraic_geometry.PresheafedSpace.comp_c_app, unop_op, functor.op, comp_base,
Top.presheaf.pushforward_obj_obj, opens.map_comp_obj],
apply_with is_iso.comp_is_iso { instances := ff },
swap,
{ have : (opens.map g.base).obj (h.functor.obj U) = hf.open_functor.obj U,
{ ext1,
dsimp only [opens.map_coe, is_open_map.functor_obj_coe, comp_base],
rw [coe_comp, ← set.image_image, set.preimage_image_eq _ hg.base_open.inj] },
rw this,
apply_instance },
{ have : h.functor.obj U = hg.open_functor.obj (hf.open_functor.obj U),
{ ext1,
dsimp only [is_open_map.functor_obj_coe],
rw [comp_base, coe_comp, ←set.image_image] },
rw this,
apply_instance }
end }
/-- For an open immersion `f : X ⟶ Y` and an open set `U ⊆ X`, we have the map `X(U) ⟶ Y(U)`. -/
noncomputable
def inv_app (U : opens X) : X.presheaf.obj (op U) ⟶ Y.presheaf.obj (op (H.open_functor.obj U)) :=
X.presheaf.map (eq_to_hom (by simp [opens.map, set.preimage_image_eq _ H.base_open.inj])) ≫
inv (f.c.app (op (H.open_functor.obj U)))
@[simp, reassoc] lemma inv_naturality {U V : (opens X)ᵒᵖ} (i : U ⟶ V) :
X.presheaf.map i ≫ H.inv_app (unop V) = H.inv_app (unop U) ≫
Y.presheaf.map (H.open_functor.op.map i) :=
begin
simp only [inv_app, ←category.assoc],
rw [is_iso.comp_inv_eq],
simp only [category.assoc, f.c.naturality, is_iso.inv_hom_id_assoc, ← X.presheaf.map_comp],
erw ← X.presheaf.map_comp,
congr
end
instance (U : opens X) : is_iso (H.inv_app U) := by { delta inv_app, apply_instance }
lemma inv_inv_app (U : opens X) :
inv (H.inv_app U) = f.c.app (op (H.open_functor.obj U)) ≫
X.presheaf.map (eq_to_hom (by simp [opens.map, set.preimage_image_eq _ H.base_open.inj])) :=
begin
rw ← cancel_epi (H.inv_app U),
rw is_iso.hom_inv_id,
delta inv_app,
simp [← functor.map_comp]
end
@[simp, reassoc, elementwise] lemma inv_app_app (U : opens X) :
H.inv_app U ≫ f.c.app (op (H.open_functor.obj U)) =
X.presheaf.map (eq_to_hom (by simp [opens.map, set.preimage_image_eq _ H.base_open.inj])) :=
by rw [inv_app, category.assoc, is_iso.inv_hom_id, category.comp_id]
@[simp, reassoc] lemma app_inv_app (U : opens Y) :
f.c.app (op U) ≫ H.inv_app ((opens.map f.base).obj U) =
Y.presheaf.map ((hom_of_le (by exact set.image_preimage_subset f.base U)).op :
op U ⟶ op (H.open_functor.obj ((opens.map f.base).obj U))) :=
by { erw ← category.assoc, rw [is_iso.comp_inv_eq, f.c.naturality], congr }
/-- A variant of `app_inv_app` that gives an `eq_to_hom` instead of `hom_of_le`. -/
@[reassoc] lemma app_inv_app' (U : opens Y) (hU : (U : set Y) ⊆ set.range f.base) :
f.c.app (op U) ≫ H.inv_app ((opens.map f.base).obj U) =
Y.presheaf.map (eq_to_hom (by
{ apply le_antisymm,
{ exact set.image_preimage_subset f.base U.1 },
{ rw [← set_like.coe_subset_coe],
refine has_le.le.trans_eq _ (@set.image_preimage_eq_inter_range _ _ f.base U.1).symm,
exact set.subset_inter_iff.mpr ⟨λ _ h, h, hU⟩ } })).op :=
by { erw ← category.assoc, rw [is_iso.comp_inv_eq, f.c.naturality], congr }
/-- An isomorphism is an open immersion. -/
instance of_iso {X Y : PresheafedSpace.{v} C} (H : X ≅ Y) : is_open_immersion H.hom :=
{ base_open := (Top.homeo_of_iso ((forget C).map_iso H)).open_embedding,
c_iso := λ _, infer_instance }
@[priority 100]
instance of_is_iso {X Y : PresheafedSpace.{v} C} (f : X ⟶ Y) [is_iso f] : is_open_immersion f :=
algebraic_geometry.PresheafedSpace.is_open_immersion.of_iso (as_iso f)
instance of_restrict {X : Top} (Y : PresheafedSpace C) {f : X ⟶ Y.carrier}
(hf : open_embedding f) : is_open_immersion (Y.of_restrict hf) :=
{ base_open := hf,
c_iso := λ U,
begin
dsimp,
have : (opens.map f).obj (hf.is_open_map.functor.obj U) = U,
{ ext1,
exact set.preimage_image_eq _ hf.inj },
convert (show is_iso (Y.presheaf.map (𝟙 _)), from infer_instance),
{ apply subsingleton.helim,
rw this },
{ rw Y.presheaf.map_id,
apply_instance }
end }
@[elementwise, simp]
lemma of_restrict_inv_app {C : Type*} [category C] (X : PresheafedSpace C) {Y : Top}
{f : Y ⟶ Top.of X.carrier}
(h : open_embedding f) (U : opens (X.restrict h).carrier) :
(PresheafedSpace.is_open_immersion.of_restrict X h).inv_app U = 𝟙 _ :=
begin
delta PresheafedSpace.is_open_immersion.inv_app,
rw [is_iso.comp_inv_eq, category.id_comp],
change X.presheaf.map _ = X.presheaf.map _,
congr
end
/-- An open immersion is an iso if the underlying continuous map is epi. -/
lemma to_iso (f : X ⟶ Y) [h : is_open_immersion f] [h' : epi f.base] : is_iso f :=
begin
apply_with is_iso_of_components { instances := ff },
{ let : X ≃ₜ Y := (homeomorph.of_embedding _ h.base_open.to_embedding).trans
{ to_fun := subtype.val, inv_fun := λ x, ⟨x,
by { rw set.range_iff_surjective.mpr ((Top.epi_iff_surjective _).mp h'), trivial }⟩,
left_inv := λ ⟨_,_⟩, rfl, right_inv := λ _, rfl },
convert is_iso.of_iso (Top.iso_of_homeo this),
{ ext, refl } },
{ apply_with nat_iso.is_iso_of_is_iso_app { instances := ff },
intro U,
have : U = op (h.open_functor.obj ((opens.map f.base).obj (unop U))),
{ induction U using opposite.rec,
cases U,
dsimp only [functor.op, opens.map],
congr,
exact (set.image_preimage_eq _ ((Top.epi_iff_surjective _).mp h')).symm },
convert @@is_open_immersion.c_iso _ h ((opens.map f.base).obj (unop U)) }
end
instance stalk_iso [has_colimits C] [H : is_open_immersion f] (x : X) : is_iso (stalk_map f x) :=
begin
rw ← H.iso_restrict_hom_of_restrict,
rw PresheafedSpace.stalk_map.comp,
apply_instance
end
end
section pullback
noncomputable theory
variables {X Y Z : PresheafedSpace.{v} C} (f : X ⟶ Z) [hf : is_open_immersion f] (g : Y ⟶ Z)
include hf
/--
(Implementation.) The projection map when constructing the pullback along an open immersion.
-/
def pullback_cone_of_left_fst :
Y.restrict (Top.snd_open_embedding_of_left_open_embedding hf.base_open g.base) ⟶ X :=
{ base := pullback.fst,
c :=
{ app := λ U, hf.inv_app (unop U) ≫
g.c.app (op (hf.base_open.is_open_map.functor.obj (unop U))) ≫
Y.presheaf.map (eq_to_hom
(begin
simp only [is_open_map.functor, subtype.mk_eq_mk, unop_op, op_inj_iff, opens.map,
subtype.coe_mk, functor.op_obj, subtype.val_eq_coe],
apply has_le.le.antisymm,
{ rintros _ ⟨_, h₁, h₂⟩,
use (Top.pullback_iso_prod_subtype _ _).inv ⟨⟨_, _⟩, h₂⟩,
simpa using h₁ },
{ rintros _ ⟨x, h₁, rfl⟩,
exact ⟨_, h₁, concrete_category.congr_hom pullback.condition x⟩ }
end)),
naturality' :=
begin
intros U V i,
induction U using opposite.rec,
induction V using opposite.rec,
simp only [quiver.hom.unop_op, Top.presheaf.pushforward_obj_map, category.assoc,
nat_trans.naturality_assoc, functor.op_map, inv_naturality_assoc, ← Y.presheaf.map_comp],
erw ← Y.presheaf.map_comp,
congr
end } }
lemma pullback_cone_of_left_condition :
pullback_cone_of_left_fst f g ≫ f = Y.of_restrict _ ≫ g :=
begin
ext U,
{ induction U using opposite.rec,
dsimp only [comp_c_app, nat_trans.comp_app, unop_op,
whisker_right_app, pullback_cone_of_left_fst],
simp only [quiver.hom.unop_op, Top.presheaf.pushforward_obj_map, app_inv_app_assoc,
eq_to_hom_app, eq_to_hom_unop, category.assoc, nat_trans.naturality_assoc, functor.op_map],
erw [← Y.presheaf.map_comp, ← Y.presheaf.map_comp],
congr },
{ simpa using pullback.condition }
end
/--
We construct the pullback along an open immersion via restricting along the pullback of the
maps of underlying spaces (which is also an open embedding).
-/
def pullback_cone_of_left : pullback_cone f g :=
pullback_cone.mk (pullback_cone_of_left_fst f g) (Y.of_restrict _)
(pullback_cone_of_left_condition f g)
variable (s : pullback_cone f g)
/--
(Implementation.) Any cone over `cospan f g` indeed factors through the constructed cone.
-/
def pullback_cone_of_left_lift : s.X ⟶ (pullback_cone_of_left f g).X :=
{ base := pullback.lift s.fst.base s.snd.base
(congr_arg (λ x, PresheafedSpace.hom.base x) s.condition),
c :=
{ app := λ U, s.snd.c.app _ ≫ s.X.presheaf.map (eq_to_hom (begin
dsimp only [opens.map, is_open_map.functor, functor.op],
congr' 2,
let s' : pullback_cone f.base g.base := pullback_cone.mk s.fst.base s.snd.base _,
have : _ = s.snd.base := limit.lift_π s' walking_cospan.right,
conv_lhs { erw ← this, rw coe_comp, erw ← set.preimage_preimage },
erw set.preimage_image_eq _
(Top.snd_open_embedding_of_left_open_embedding hf.base_open g.base).inj,
end)),
naturality' := λ U V i,
begin
erw s.snd.c.naturality_assoc,
rw category.assoc,
erw [← s.X.presheaf.map_comp, ← s.X.presheaf.map_comp],
congr
end } }
-- this lemma is not a `simp` lemma, because it is an implementation detail
lemma pullback_cone_of_left_lift_fst :
pullback_cone_of_left_lift f g s ≫ (pullback_cone_of_left f g).fst = s.fst :=
begin
ext x,
{ induction x using opposite.rec,
change ((_ ≫ _) ≫ _ ≫ _) ≫ _ = _,
simp_rw [category.assoc],
erw ← s.X.presheaf.map_comp,
erw s.snd.c.naturality_assoc,
have := congr_app s.condition (op (hf.open_functor.obj x)),
dsimp only [comp_c_app, unop_op] at this,
rw ← is_iso.comp_inv_eq at this,
reassoc! this,
erw [← this, hf.inv_app_app_assoc, s.fst.c.naturality_assoc],
simpa [eq_to_hom_map], },
{ change pullback.lift _ _ _ ≫ pullback.fst = _,
simp }
end
-- this lemma is not a `simp` lemma, because it is an implementation detail
lemma pullback_cone_of_left_lift_snd :
pullback_cone_of_left_lift f g s ≫ (pullback_cone_of_left f g).snd = s.snd :=
begin
ext x,
{ change (_ ≫ _ ≫ _) ≫ _ = _,
simp_rw category.assoc,
erw s.snd.c.naturality_assoc,
erw [← s.X.presheaf.map_comp, ← s.X.presheaf.map_comp],
transitivity s.snd.c.app x ≫ s.X.presheaf.map (𝟙 _),
{ congr },
{ rw s.X.presheaf.map_id, erw category.comp_id } },
{ change pullback.lift _ _ _ ≫ pullback.snd = _,
simp }
end
instance pullback_cone_snd_is_open_immersion :
is_open_immersion (pullback_cone_of_left f g).snd :=
begin
erw category_theory.limits.pullback_cone.mk_snd,
apply_instance
end
/-- The constructed pullback cone is indeed the pullback. -/
def pullback_cone_of_left_is_limit :
is_limit (pullback_cone_of_left f g) :=
begin
apply pullback_cone.is_limit_aux',
intro s,
use pullback_cone_of_left_lift f g s,
use pullback_cone_of_left_lift_fst f g s,
use pullback_cone_of_left_lift_snd f g s,
intros m h₁ h₂,
rw ← cancel_mono (pullback_cone_of_left f g).snd,
exact (h₂.trans (pullback_cone_of_left_lift_snd f g s).symm)
end
instance has_pullback_of_left :
has_pullback f g :=
⟨⟨⟨_, pullback_cone_of_left_is_limit f g⟩⟩⟩
instance has_pullback_of_right :
has_pullback g f := has_pullback_symmetry f g
/-- Open immersions are stable under base-change. -/
instance pullback_snd_of_left :
is_open_immersion (pullback.snd : pullback f g ⟶ _) :=
begin
delta pullback.snd,
rw ← limit.iso_limit_cone_hom_π ⟨_, pullback_cone_of_left_is_limit f g⟩ walking_cospan.right,
apply_instance
end
/-- Open immersions are stable under base-change. -/
instance pullback_fst_of_right :
is_open_immersion (pullback.fst : pullback g f ⟶ _) :=
begin
rw ← pullback_symmetry_hom_comp_snd,
apply_instance
end
instance pullback_to_base_is_open_immersion [is_open_immersion g] :
is_open_immersion (limit.π (cospan f g) walking_cospan.one) :=
begin
rw [←limit.w (cospan f g) walking_cospan.hom.inl, cospan_map_inl],
apply_instance
end
instance forget_preserves_limits_of_left : preserves_limit (cospan f g) (forget C) :=
preserves_limit_of_preserves_limit_cone (pullback_cone_of_left_is_limit f g)
begin
apply (is_limit.postcompose_hom_equiv (diagram_iso_cospan.{v} _) _).to_fun,
refine (is_limit.equiv_iso_limit _).to_fun (limit.is_limit (cospan f.base g.base)),
fapply cones.ext,
exact (iso.refl _),
change ∀ j, _ = 𝟙 _ ≫ _ ≫ _,
simp_rw category.id_comp,
rintros (_|_|_); symmetry,
{ erw category.comp_id,
exact limit.w (cospan f.base g.base) walking_cospan.hom.inl },
{ exact category.comp_id _ },
{ exact category.comp_id _ },
end
instance forget_preserves_limits_of_right : preserves_limit (cospan g f) (forget C) :=
preserves_pullback_symmetry (forget C) f g
lemma pullback_snd_is_iso_of_range_subset (H : set.range g.base ⊆ set.range f.base) :
is_iso (pullback.snd : pullback f g ⟶ _) :=
begin
haveI := Top.snd_iso_of_left_embedding_range_subset hf.base_open.to_embedding g.base H,
haveI : is_iso (pullback.snd : pullback f g ⟶ _).base,
{ delta pullback.snd,
rw ← limit.iso_limit_cone_hom_π ⟨_, pullback_cone_of_left_is_limit f g⟩ walking_cospan.right,
change is_iso (_ ≫ pullback.snd),
apply_instance },
apply to_iso
end
/--
The universal property of open immersions:
For an open immersion `f : X ⟶ Z`, given any morphism of schemes `g : Y ⟶ Z` whose topological
image is contained in the image of `f`, we can lift this morphism to a unique `Y ⟶ X` that
commutes with these maps.
-/
def lift (H : set.range g.base ⊆ set.range f.base) : Y ⟶ X :=
begin
haveI := pullback_snd_is_iso_of_range_subset f g H,
exact inv (pullback.snd : pullback f g ⟶ _) ≫ pullback.fst,
end
@[simp, reassoc] lemma lift_fac (H : set.range g.base ⊆ set.range f.base) :
lift f g H ≫ f = g :=
by { erw category.assoc, rw is_iso.inv_comp_eq, exact pullback.condition }
lemma lift_uniq (H : set.range g.base ⊆ set.range f.base) (l : Y ⟶ X)
(hl : l ≫ f = g) : l = lift f g H :=
by rw [← cancel_mono f, hl, lift_fac]
/-- Two open immersions with equal range is isomorphic. -/
@[simps] def iso_of_range_eq [is_open_immersion g] (e : set.range f.base = set.range g.base) :
X ≅ Y :=
{ hom := lift g f (le_of_eq e),
inv := lift f g (le_of_eq e.symm),
hom_inv_id' := by { rw ← cancel_mono f, simp },
inv_hom_id' := by { rw ← cancel_mono g, simp } }
end pullback
open category_theory.limits.walking_cospan
section to_SheafedSpace
variables {X : PresheafedSpace.{v} C} (Y : SheafedSpace C)
variables (f : X ⟶ Y.to_PresheafedSpace) [H : is_open_immersion f]
include H
/-- If `X ⟶ Y` is an open immersion, and `Y` is a SheafedSpace, then so is `X`. -/
def to_SheafedSpace : SheafedSpace C :=
{ is_sheaf :=
begin
apply Top.presheaf.is_sheaf_of_iso (sheaf_iso_of_iso H.iso_restrict.symm).symm,
apply Top.sheaf.pushforward_sheaf_of_sheaf,
exact (Y.restrict H.base_open).is_sheaf
end,
to_PresheafedSpace := X }
@[simp] lemma to_SheafedSpace_to_PresheafedSpace : (to_SheafedSpace Y f).to_PresheafedSpace = X :=
rfl
/--
If `X ⟶ Y` is an open immersion of PresheafedSpaces, and `Y` is a SheafedSpace, we can
upgrade it into a morphism of SheafedSpaces.
-/
def to_SheafedSpace_hom : to_SheafedSpace Y f ⟶ Y := f
@[simp] lemma to_SheafedSpace_hom_base : (to_SheafedSpace_hom Y f).base = f.base := rfl
@[simp] lemma to_SheafedSpace_hom_c : (to_SheafedSpace_hom Y f).c = f.c := rfl
instance to_SheafedSpace_is_open_immersion :
SheafedSpace.is_open_immersion (to_SheafedSpace_hom Y f) := H
omit H
@[simp] lemma SheafedSpace_to_SheafedSpace {X Y : SheafedSpace.{v} C} (f : X ⟶ Y)
[is_open_immersion f] : to_SheafedSpace Y f = X := by unfreezingI { cases X, refl }
end to_SheafedSpace
section to_LocallyRingedSpace
variables {X : PresheafedSpace.{u} CommRing.{u}} (Y : LocallyRingedSpace.{u})
variables (f : X ⟶ Y.to_PresheafedSpace) [H : is_open_immersion f]
include H
/-- If `X ⟶ Y` is an open immersion, and `Y` is a LocallyRingedSpace, then so is `X`. -/
def to_LocallyRingedSpace : LocallyRingedSpace :=
{ to_SheafedSpace := to_SheafedSpace Y.to_SheafedSpace f,
local_ring := λ x, begin
haveI : local_ring (Y.to_SheafedSpace.to_PresheafedSpace.stalk (f.base x)) := Y.local_ring _,
exact (as_iso (stalk_map f x)).CommRing_iso_to_ring_equiv.local_ring
end }
@[simp] lemma to_LocallyRingedSpace_to_SheafedSpace :
(to_LocallyRingedSpace Y f).to_SheafedSpace = (to_SheafedSpace Y.1 f) := rfl
/--
If `X ⟶ Y` is an open immersion of PresheafedSpaces, and `Y` is a LocallyRingedSpace, we can
upgrade it into a morphism of LocallyRingedSpace.
-/
def to_LocallyRingedSpace_hom : to_LocallyRingedSpace Y f ⟶ Y := ⟨f, λ x, infer_instance⟩
@[simp] lemma to_LocallyRingedSpace_hom_val :
(to_LocallyRingedSpace_hom Y f).val = f := rfl
instance to_LocallyRingedSpace_is_open_immersion :
LocallyRingedSpace.is_open_immersion (to_LocallyRingedSpace_hom Y f) := H
omit H
@[simp] lemma LocallyRingedSpace_to_LocallyRingedSpace {X Y : LocallyRingedSpace} (f : X ⟶ Y)
[LocallyRingedSpace.is_open_immersion f] :
to_LocallyRingedSpace Y f.1 = X :=
by unfreezingI { cases X, delta to_LocallyRingedSpace, simp }
end to_LocallyRingedSpace
lemma is_iso_of_subset {X Y : PresheafedSpace.{v} C} (f : X ⟶ Y)
[H : PresheafedSpace.is_open_immersion f] (U : opens Y.carrier)
(hU : (U : set Y.carrier) ⊆ set.range f.base) : is_iso (f.c.app $ op U) :=
begin
have : U = H.base_open.is_open_map.functor.obj ((opens.map f.base).obj U),
{ ext1,
exact (set.inter_eq_left_iff_subset.mpr hU).symm.trans set.image_preimage_eq_inter_range.symm },
convert PresheafedSpace.is_open_immersion.c_iso ((opens.map f.base).obj U),
end
end PresheafedSpace.is_open_immersion
namespace SheafedSpace.is_open_immersion
@[priority 100]
instance of_is_iso {X Y : SheafedSpace.{v} C} (f : X ⟶ Y) [is_iso f] :
SheafedSpace.is_open_immersion f :=
@@PresheafedSpace.is_open_immersion.of_is_iso _ f
(SheafedSpace.forget_to_PresheafedSpace.map_is_iso _)
instance comp {X Y Z : SheafedSpace C} (f : X ⟶ Y) (g : Y ⟶ Z)
[SheafedSpace.is_open_immersion f] [SheafedSpace.is_open_immersion g] :
SheafedSpace.is_open_immersion (f ≫ g) := PresheafedSpace.is_open_immersion.comp f g
section pullback
variables {X Y Z : SheafedSpace C} (f : X ⟶ Z) (g : Y ⟶ Z)
variable [H : SheafedSpace.is_open_immersion f]
include H
local notation `forget` := SheafedSpace.forget_to_PresheafedSpace
open category_theory.limits.walking_cospan
instance : mono f :=
forget .mono_of_mono_map (show @mono (PresheafedSpace C) _ _ _ f, by apply_instance)
instance forget_map_is_open_immersion :
PresheafedSpace.is_open_immersion (forget .map f) := ⟨H.base_open, H.c_iso⟩
instance has_limit_cospan_forget_of_left : has_limit (cospan f g ⋙ forget) :=
begin
apply has_limit_of_iso (diagram_iso_cospan.{v} _).symm,
change has_limit (cospan (forget .map f) (forget .map g)),
apply_instance
end
instance has_limit_cospan_forget_of_left' : has_limit (cospan ((cospan f g ⋙ forget).map hom.inl)
((cospan f g ⋙ forget).map hom.inr)) :=
show has_limit (cospan (forget .map f) (forget .map g)), from infer_instance
instance has_limit_cospan_forget_of_right : has_limit (cospan g f ⋙ forget) :=
begin
apply has_limit_of_iso (diagram_iso_cospan.{v} _).symm,
change has_limit (cospan (forget .map g) (forget .map f)),
apply_instance
end
instance has_limit_cospan_forget_of_right' : has_limit (cospan ((cospan g f ⋙ forget).map hom.inl)
((cospan g f ⋙ forget).map hom.inr)) :=
show has_limit (cospan (forget .map g) (forget .map f)), from infer_instance
instance forget_creates_pullback_of_left : creates_limit (cospan f g) forget :=
creates_limit_of_fully_faithful_of_iso
(PresheafedSpace.is_open_immersion.to_SheafedSpace Y
(@pullback.snd (PresheafedSpace C) _ _ _ _ f g _))
(eq_to_iso (show pullback _ _ = pullback _ _, by congr)
≪≫ has_limit.iso_of_nat_iso (diagram_iso_cospan _).symm)
instance forget_creates_pullback_of_right : creates_limit (cospan g f) forget :=
creates_limit_of_fully_faithful_of_iso
(PresheafedSpace.is_open_immersion.to_SheafedSpace Y
(@pullback.fst (PresheafedSpace C) _ _ _ _ g f _))
(eq_to_iso (show pullback _ _ = pullback _ _, by congr)
≪≫ has_limit.iso_of_nat_iso (diagram_iso_cospan _).symm)
instance SheafedSpace_forget_preserves_of_left :
preserves_limit (cospan f g) (SheafedSpace.forget C) :=
@@limits.comp_preserves_limit _ _ _ _ forget (PresheafedSpace.forget C) _
begin
apply_with (preserves_limit_of_iso_diagram _ (diagram_iso_cospan.{v} _).symm) { instances := tt },
dsimp,
apply_instance
end
instance SheafedSpace_forget_preserves_of_right :
preserves_limit (cospan g f) (SheafedSpace.forget C) :=
preserves_pullback_symmetry _ _ _
instance SheafedSpace_has_pullback_of_left : has_pullback f g :=
has_limit_of_created (cospan f g) forget
instance SheafedSpace_has_pullback_of_right : has_pullback g f :=
has_limit_of_created (cospan g f) forget
/-- Open immersions are stable under base-change. -/
instance SheafedSpace_pullback_snd_of_left :
SheafedSpace.is_open_immersion (pullback.snd : pullback f g ⟶ _) :=
begin
delta pullback.snd,
have : _ = limit.π (cospan f g) right := preserves_limits_iso_hom_π
forget (cospan f g) right,
rw ← this,
have := has_limit.iso_of_nat_iso_hom_π
(diagram_iso_cospan.{v} (cospan f g ⋙ forget))
right,
erw category.comp_id at this,
rw ← this,
dsimp,
apply_instance
end
instance SheafedSpace_pullback_fst_of_right :
SheafedSpace.is_open_immersion (pullback.fst : pullback g f ⟶ _) :=
begin
delta pullback.fst,
have : _ = limit.π (cospan g f) left := preserves_limits_iso_hom_π
forget (cospan g f) left,
rw ← this,
have := has_limit.iso_of_nat_iso_hom_π
(diagram_iso_cospan.{v} (cospan g f ⋙ forget)) left,
erw category.comp_id at this,
rw ← this,
dsimp,
apply_instance
end
instance SheafedSpace_pullback_to_base_is_open_immersion [SheafedSpace.is_open_immersion g] :
SheafedSpace.is_open_immersion (limit.π (cospan f g) one : pullback f g ⟶ Z) :=
begin
rw [←limit.w (cospan f g) hom.inl, cospan_map_inl],
apply_instance
end
end pullback
section of_stalk_iso
variables [has_limits C] [has_colimits C] [concrete_category.{v} C]
variables [reflects_isomorphisms (forget C)] [preserves_limits (forget C)]
variables [preserves_filtered_colimits (forget C)]
/--
Suppose `X Y : SheafedSpace C`, where `C` is a concrete category,
whose forgetful functor reflects isomorphisms, preserves limits and filtered colimits.
Then a morphism `X ⟶ Y` that is a topological open embedding
is an open immersion iff every stalk map is an iso.
-/
lemma of_stalk_iso {X Y : SheafedSpace C} (f : X ⟶ Y)
(hf : open_embedding f.base) [H : ∀ x : X, is_iso (PresheafedSpace.stalk_map f x)] :
SheafedSpace.is_open_immersion f :=
{ base_open := hf,
c_iso := λ U, begin
apply_with (Top.presheaf.app_is_iso_of_stalk_functor_map_iso
(show Y.sheaf ⟶ (Top.sheaf.pushforward f.base).obj X.sheaf, from ⟨f.c⟩)) { instances := ff },
rintros ⟨_, y, hy, rfl⟩,
specialize H y,
delta PresheafedSpace.stalk_map at H,
haveI H' := Top.presheaf.stalk_pushforward.stalk_pushforward_iso_of_open_embedding
C hf X.presheaf y,
have := @@is_iso.comp_is_iso _ H (@@is_iso.inv_is_iso _ H'),
rw [category.assoc, is_iso.hom_inv_id, category.comp_id] at this,
exact this
end }
end of_stalk_iso
section prod
variables [has_limits C] {ι : Type v} (F : discrete ι ⥤ SheafedSpace C) [has_colimit F]
(i : discrete ι)
lemma sigma_ι_open_embedding : open_embedding (colimit.ι F i).base :=
begin
rw ← (show _ = (colimit.ι F i).base,
from ι_preserves_colimits_iso_inv (SheafedSpace.forget C) F i),
have : _ = _ ≫ colimit.ι (discrete.functor ((F ⋙ SheafedSpace.forget C).obj ∘ discrete.mk)) i :=
has_colimit.iso_of_nat_iso_ι_hom discrete.nat_iso_functor i,
rw ← iso.eq_comp_inv at this,
rw this,
have : colimit.ι _ _ ≫ _ = _ :=
Top.sigma_iso_sigma_hom_ι.{v v} ((F ⋙ SheafedSpace.forget C).obj ∘ discrete.mk) i.as,
rw ← iso.eq_comp_inv at this,
cases i,
rw this,
simp_rw [← category.assoc, Top.open_embedding_iff_comp_is_iso,
Top.open_embedding_iff_is_iso_comp],
dsimp,
exact open_embedding_sigma_mk
end
lemma image_preimage_is_empty (j : discrete ι) (h : i ≠ j) (U : opens (F.obj i)) :
(opens.map (colimit.ι (F ⋙ SheafedSpace.forget_to_PresheafedSpace) j).base).obj
((opens.map (preserves_colimit_iso SheafedSpace.forget_to_PresheafedSpace F).inv.base).obj
((sigma_ι_open_embedding F i).is_open_map.functor.obj U)) = ⊥ :=
begin
ext,
apply iff_false_intro,
rintro ⟨y, hy, eq⟩,
replace eq := concrete_category.congr_arg
(preserves_colimit_iso (SheafedSpace.forget C) F ≪≫
has_colimit.iso_of_nat_iso discrete.nat_iso_functor ≪≫ Top.sigma_iso_sigma.{v} _).hom eq,
simp_rw [category_theory.iso.trans_hom, ← Top.comp_app, ← PresheafedSpace.comp_base] at eq,
rw ι_preserves_colimits_iso_inv at eq,
change ((SheafedSpace.forget C).map (colimit.ι F i) ≫ _) y =
((SheafedSpace.forget C).map (colimit.ι F j) ≫ _) x at eq,
cases i, cases j,
rw [ι_preserves_colimits_iso_hom_assoc, ι_preserves_colimits_iso_hom_assoc,
has_colimit.iso_of_nat_iso_ι_hom_assoc, has_colimit.iso_of_nat_iso_ι_hom_assoc,
Top.sigma_iso_sigma_hom_ι.{v}, Top.sigma_iso_sigma_hom_ι.{v}] at eq,
exact h (congr_arg discrete.mk (congr_arg sigma.fst eq)),
end
instance sigma_ι_is_open_immersion [has_strict_terminal_objects C] :
SheafedSpace.is_open_immersion (colimit.ι F i) :=
{ base_open := sigma_ι_open_embedding F i,
c_iso := λ U, begin
have e : colimit.ι F i = _ :=
(ι_preserves_colimits_iso_inv SheafedSpace.forget_to_PresheafedSpace F i).symm,
have H : open_embedding (colimit.ι (F ⋙ SheafedSpace.forget_to_PresheafedSpace) i ≫
(preserves_colimit_iso SheafedSpace.forget_to_PresheafedSpace F).inv).base :=
e ▸ sigma_ι_open_embedding F i,
suffices : is_iso ((colimit.ι (F ⋙ SheafedSpace.forget_to_PresheafedSpace) i ≫
(preserves_colimit_iso SheafedSpace.forget_to_PresheafedSpace F).inv).c.app
(op (H.is_open_map.functor.obj U))),
{ convert this },
rw [PresheafedSpace.comp_c_app,
← PresheafedSpace.colimit_presheaf_obj_iso_componentwise_limit_hom_π],
rsufficesI : is_iso (limit.π (PresheafedSpace.componentwise_diagram
(F ⋙ SheafedSpace.forget_to_PresheafedSpace)
((opens.map (preserves_colimit_iso SheafedSpace.forget_to_PresheafedSpace F).inv.base).obj
(unop $ op $ H.is_open_map.functor.obj U))) (op i)),
{ apply_instance },
apply limit_π_is_iso_of_is_strict_terminal,
intros j hj,
induction j using opposite.rec,
dsimp,
convert (F.obj j).sheaf.is_terminal_of_empty,
convert image_preimage_is_empty F i j (λ h, hj (congr_arg op h.symm)) U,
exact (congr_arg PresheafedSpace.hom.base e).symm
end }
end prod
end SheafedSpace.is_open_immersion
namespace LocallyRingedSpace.is_open_immersion
section pullback
variables {X Y Z : LocallyRingedSpace.{u}} (f : X ⟶ Z) (g : Y ⟶ Z)
variable [H : LocallyRingedSpace.is_open_immersion f]
@[priority 100]
instance of_is_iso [is_iso g] :
LocallyRingedSpace.is_open_immersion g :=
@@PresheafedSpace.is_open_immersion.of_is_iso _ g.1 ⟨⟨(inv g).1,
by { erw ← LocallyRingedSpace.comp_val, rw is_iso.hom_inv_id,
erw ← LocallyRingedSpace.comp_val, rw is_iso.inv_hom_id, split; simpa }⟩⟩
include H
instance comp (g : Z ⟶ Y) [LocallyRingedSpace.is_open_immersion g] :
LocallyRingedSpace.is_open_immersion (f ≫ g) := PresheafedSpace.is_open_immersion.comp f.1 g.1
instance mono : mono f :=
LocallyRingedSpace.forget_to_SheafedSpace.mono_of_mono_map (show mono f.1, by apply_instance)
instance : SheafedSpace.is_open_immersion (LocallyRingedSpace.forget_to_SheafedSpace.map f) := H
/-- An explicit pullback cone over `cospan f g` if `f` is an open immersion. -/
def pullback_cone_of_left : pullback_cone f g :=
begin
refine pullback_cone.mk _
(Y.of_restrict (Top.snd_open_embedding_of_left_open_embedding H.base_open g.1.base)) _,
{ use PresheafedSpace.is_open_immersion.pullback_cone_of_left_fst f.1 g.1,
intro x,
have := PresheafedSpace.stalk_map.congr_hom _ _
(PresheafedSpace.is_open_immersion.pullback_cone_of_left_condition f.1 g.1) x,
rw [PresheafedSpace.stalk_map.comp, PresheafedSpace.stalk_map.comp] at this,
rw ← is_iso.eq_inv_comp at this,
rw this,
apply_instance },
{ exact LocallyRingedSpace.hom.ext _ _
(PresheafedSpace.is_open_immersion.pullback_cone_of_left_condition _ _) },
end
instance : LocallyRingedSpace.is_open_immersion (pullback_cone_of_left f g).snd :=
show PresheafedSpace.is_open_immersion (Y.to_PresheafedSpace.of_restrict _), by apply_instance
/-- The constructed `pullback_cone_of_left` is indeed limiting. -/
def pullback_cone_of_left_is_limit : is_limit (pullback_cone_of_left f g) :=
pullback_cone.is_limit_aux' _ $ λ s,
begin
use PresheafedSpace.is_open_immersion.pullback_cone_of_left_lift f.1 g.1
(pullback_cone.mk s.fst.1 s.snd.1 (congr_arg LocallyRingedSpace.hom.val s.condition)),
{ intro x,
have := PresheafedSpace.stalk_map.congr_hom _ _
(PresheafedSpace.is_open_immersion.pullback_cone_of_left_lift_snd f.1 g.1
(pullback_cone.mk s.fst.1 s.snd.1 (congr_arg LocallyRingedSpace.hom.val s.condition))) x,
change _ = _ ≫ PresheafedSpace.stalk_map s.snd.1 x at this,
rw [PresheafedSpace.stalk_map.comp, ← is_iso.eq_inv_comp] at this,
rw this,
apply_instance },
split,
{ exact LocallyRingedSpace.hom.ext _ _
(PresheafedSpace.is_open_immersion.pullback_cone_of_left_lift_fst f.1 g.1 _) },
split,
{ exact LocallyRingedSpace.hom.ext _ _
(PresheafedSpace.is_open_immersion.pullback_cone_of_left_lift_snd f.1 g.1 _) },
intros m h₁ h₂,
rw ← cancel_mono (pullback_cone_of_left f g).snd,
exact (h₂.trans (LocallyRingedSpace.hom.ext _ _
(PresheafedSpace.is_open_immersion.pullback_cone_of_left_lift_snd f.1 g.1
(pullback_cone.mk s.fst.1 s.snd.1 (congr_arg LocallyRingedSpace.hom.val s.condition))).symm))
end
instance has_pullback_of_left :
has_pullback f g :=
⟨⟨⟨_, pullback_cone_of_left_is_limit f g⟩⟩⟩
instance has_pullback_of_right :
has_pullback g f := has_pullback_symmetry f g
/-- Open immersions are stable under base-change. -/
instance pullback_snd_of_left :
LocallyRingedSpace.is_open_immersion (pullback.snd : pullback f g ⟶ _) :=
begin
delta pullback.snd,
rw ← limit.iso_limit_cone_hom_π ⟨_, pullback_cone_of_left_is_limit f g⟩ walking_cospan.right,
apply_instance
end
/-- Open immersions are stable under base-change. -/
instance pullback_fst_of_right :
LocallyRingedSpace.is_open_immersion (pullback.fst : pullback g f ⟶ _) :=
begin
rw ← pullback_symmetry_hom_comp_snd,
apply_instance
end
instance pullback_to_base_is_open_immersion [LocallyRingedSpace.is_open_immersion g] :
LocallyRingedSpace.is_open_immersion (limit.π (cospan f g) walking_cospan.one) :=
begin
rw [←limit.w (cospan f g) walking_cospan.hom.inl, cospan_map_inl],
apply_instance
end
instance forget_preserves_pullback_of_left :
preserves_limit (cospan f g) LocallyRingedSpace.forget_to_SheafedSpace :=
preserves_limit_of_preserves_limit_cone (pullback_cone_of_left_is_limit f g)
begin
apply (is_limit_map_cone_pullback_cone_equiv _ _).symm.to_fun,
apply is_limit_of_is_limit_pullback_cone_map SheafedSpace.forget_to_PresheafedSpace,
exact PresheafedSpace.is_open_immersion.pullback_cone_of_left_is_limit f.1 g.1
end
instance forget_to_PresheafedSpace_preserves_pullback_of_left :
preserves_limit (cospan f g)
(LocallyRingedSpace.forget_to_SheafedSpace ⋙ SheafedSpace.forget_to_PresheafedSpace) :=
preserves_limit_of_preserves_limit_cone (pullback_cone_of_left_is_limit f g)
begin
apply (is_limit_map_cone_pullback_cone_equiv _ _).symm.to_fun,
exact PresheafedSpace.is_open_immersion.pullback_cone_of_left_is_limit f.1 g.1
end
instance forget_to_PresheafedSpace_preserves_open_immersion :
PresheafedSpace.is_open_immersion ((LocallyRingedSpace.forget_to_SheafedSpace ⋙
SheafedSpace.forget_to_PresheafedSpace).map f) := H
instance forget_to_Top_preserves_pullback_of_left :
preserves_limit (cospan f g)
(LocallyRingedSpace.forget_to_SheafedSpace ⋙ SheafedSpace.forget _) :=
begin
change preserves_limit _
((LocallyRingedSpace.forget_to_SheafedSpace ⋙ SheafedSpace.forget_to_PresheafedSpace)
⋙ PresheafedSpace.forget _),
apply_with limits.comp_preserves_limit { instances := ff },
apply_instance,
apply preserves_limit_of_iso_diagram _ (diagram_iso_cospan.{u} _).symm,
dsimp [SheafedSpace.forget_to_PresheafedSpace],
apply_instance,
end
instance forget_reflects_pullback_of_left :
reflects_limit (cospan f g) LocallyRingedSpace.forget_to_SheafedSpace :=
reflects_limit_of_reflects_isomorphisms _ _
instance forget_preserves_pullback_of_right :
preserves_limit (cospan g f) LocallyRingedSpace.forget_to_SheafedSpace :=
preserves_pullback_symmetry _ _ _
instance forget_to_PresheafedSpace_preserves_pullback_of_right :
preserves_limit (cospan g f) (LocallyRingedSpace.forget_to_SheafedSpace ⋙
SheafedSpace.forget_to_PresheafedSpace) :=
preserves_pullback_symmetry _ _ _
instance forget_reflects_pullback_of_right :
reflects_limit (cospan g f) LocallyRingedSpace.forget_to_SheafedSpace :=
reflects_limit_of_reflects_isomorphisms _ _
instance forget_to_PresheafedSpace_reflects_pullback_of_left :
reflects_limit (cospan f g)
(LocallyRingedSpace.forget_to_SheafedSpace ⋙ SheafedSpace.forget_to_PresheafedSpace) :=
reflects_limit_of_reflects_isomorphisms _ _
instance forget_to_PresheafedSpace_reflects_pullback_of_right :
reflects_limit (cospan g f)
(LocallyRingedSpace.forget_to_SheafedSpace ⋙ SheafedSpace.forget_to_PresheafedSpace) :=
reflects_limit_of_reflects_isomorphisms _ _
lemma pullback_snd_is_iso_of_range_subset (H' : set.range g.1.base ⊆ set.range f.1.base) :
is_iso (pullback.snd : pullback f g ⟶ _) :=
begin
apply_with (reflects_isomorphisms.reflects LocallyRingedSpace.forget_to_SheafedSpace)
{ instances := ff },
apply_with (reflects_isomorphisms.reflects SheafedSpace.forget_to_PresheafedSpace)
{ instances := ff },
erw ← preserves_pullback.iso_hom_snd
(LocallyRingedSpace.forget_to_SheafedSpace ⋙ SheafedSpace.forget_to_PresheafedSpace) f g,
haveI := PresheafedSpace.is_open_immersion.pullback_snd_is_iso_of_range_subset _ _ H',
apply_instance,
apply_instance
end
/--
The universal property of open immersions:
For an open immersion `f : X ⟶ Z`, given any morphism of schemes `g : Y ⟶ Z` whose topological
image is contained in the image of `f`, we can lift this morphism to a unique `Y ⟶ X` that
commutes with these maps.
-/
def lift (H' : set.range g.1.base ⊆ set.range f.1.base) : Y ⟶ X :=
begin
haveI := pullback_snd_is_iso_of_range_subset f g H',
exact inv (pullback.snd : pullback f g ⟶ _) ≫ pullback.fst,
end
@[simp, reassoc] lemma lift_fac (H' : set.range g.1.base ⊆ set.range f.1.base) :
lift f g H' ≫ f = g :=
by { erw category.assoc, rw is_iso.inv_comp_eq, exact pullback.condition }
lemma lift_uniq (H' : set.range g.1.base ⊆ set.range f.1.base) (l : Y ⟶ X)
(hl : l ≫ f = g) : l = lift f g H' :=
by rw [← cancel_mono f, hl, lift_fac]
lemma lift_range (H' : set.range g.1.base ⊆ set.range f.1.base) :
set.range (lift f g H').1.base = f.1.base ⁻¹' (set.range g.1.base) :=
begin
haveI := pullback_snd_is_iso_of_range_subset f g H',
dsimp only [lift],
have : _ = (pullback.fst : pullback f g ⟶ _).val.base := preserves_pullback.iso_hom_fst
(LocallyRingedSpace.forget_to_SheafedSpace ⋙ SheafedSpace.forget _) f g,
rw [LocallyRingedSpace.comp_val, SheafedSpace.comp_base, ← this, ← category.assoc, coe_comp],
rw [set.range_comp, set.range_iff_surjective.mpr, set.image_univ, Top.pullback_fst_range],
ext,
split,
{ rintros ⟨y, eq⟩, exact ⟨y, eq.symm⟩ },
{ rintros ⟨y, eq⟩, exact ⟨y, eq.symm⟩ },
{ rw ← Top.epi_iff_surjective,
rw (show (inv (pullback.snd : pullback f g ⟶ _)).val.base = _, from
(LocallyRingedSpace.forget_to_SheafedSpace ⋙ SheafedSpace.forget _).map_inv _),
apply_instance }
end
end pullback
/-- An open immersion is isomorphic to the induced open subscheme on its image. -/
def iso_restrict {X Y : LocallyRingedSpace} {f : X ⟶ Y}
(H : LocallyRingedSpace.is_open_immersion f) : X ≅ Y.restrict H.base_open :=
begin
apply LocallyRingedSpace.iso_of_SheafedSpace_iso,
refine SheafedSpace.forget_to_PresheafedSpace.preimage_iso _,
exact H.iso_restrict
end
/-- To show that a locally ringed space is a scheme, it suffices to show that it has a jointly
surjective family of open immersions from affine schemes. -/
protected def Scheme (X : LocallyRingedSpace)
(h : ∀ (x : X), ∃ (R : CommRing) (f : Spec.to_LocallyRingedSpace.obj (op R) ⟶ X),
(x ∈ set.range f.1.base : _) ∧ LocallyRingedSpace.is_open_immersion f) : Scheme :=
{ to_LocallyRingedSpace := X,
local_affine :=
begin
intro x,
obtain ⟨R, f, h₁, h₂⟩ := h x,
refine ⟨⟨⟨_, h₂.base_open.open_range⟩, h₁⟩, R, ⟨_⟩⟩,
apply LocallyRingedSpace.iso_of_SheafedSpace_iso,
refine SheafedSpace.forget_to_PresheafedSpace.preimage_iso _,
resetI,
apply PresheafedSpace.is_open_immersion.iso_of_range_eq (PresheafedSpace.of_restrict _ _) f.1,
{ exact subtype.range_coe_subtype },
{ apply_instance }
end }
end LocallyRingedSpace.is_open_immersion
lemma is_open_immersion.open_range {X Y : Scheme} (f : X ⟶ Y) [H : is_open_immersion f] :
is_open (set.range f.1.base) := H.base_open.open_range
section open_cover
namespace Scheme
/-- An open cover of `X` consists of a family of open immersions into `X`,
and for each `x : X` an open immersion (indexed by `f x`) that covers `x`.
This is merely a coverage in the Zariski pretopology, and it would be optimal
if we could reuse the existing API about pretopologies, However, the definitions of sieves and
grothendieck topologies uses `Prop`s, so that the actual open sets and immersions are hard to
obtain. Also, since such a coverage in the pretopology usually contains a proper class of
immersions, it is quite hard to glue them, reason about finite covers, etc.
-/
-- TODO: provide API to and from a presieve.
structure open_cover (X : Scheme.{u}) :=
(J : Type v)
(obj : Π (j : J), Scheme)
(map : Π (j : J), obj j ⟶ X)
(f : X.carrier → J)
(covers : ∀ x, x ∈ set.range ((map (f x)).1.base))
(is_open : ∀ x, is_open_immersion (map x) . tactic.apply_instance)
attribute [instance] open_cover.is_open
variables {X Y Z : Scheme.{u}} (𝒰 : open_cover X) (f : X ⟶ Z) (g : Y ⟶ Z)
variables [∀ x, has_pullback (𝒰.map x ≫ f) g]
/-- The affine cover of a scheme. -/
def affine_cover (X : Scheme) : open_cover X :=
{ J := X.carrier,
obj := λ x, Spec.obj $ opposite.op (X.local_affine x).some_spec.some,
map := λ x, ((X.local_affine x).some_spec.some_spec.some.inv ≫
X.to_LocallyRingedSpace.of_restrict _ : _),
f := λ x, x,
is_open := λ x, begin
apply_with PresheafedSpace.is_open_immersion.comp { instances := ff },
apply_instance,
apply PresheafedSpace.is_open_immersion.of_restrict,
end,
covers :=
begin
intro x,
erw coe_comp,
rw [set.range_comp, set.range_iff_surjective.mpr, set.image_univ],
erw subtype.range_coe_subtype,
exact (X.local_affine x).some.2,
rw ← Top.epi_iff_surjective,
change epi ((SheafedSpace.forget _).map (LocallyRingedSpace.forget_to_SheafedSpace.map _)),
apply_instance
end }
instance : inhabited X.open_cover := ⟨X.affine_cover⟩
/-- Given an open cover `{ Uᵢ }` of `X`, and for each `Uᵢ` an open cover, we may combine these
open covers to form an open cover of `X`. -/
@[simps J obj map]
def open_cover.bind (f : Π (x : 𝒰.J), open_cover (𝒰.obj x)) : open_cover X :=
{ J := Σ (i : 𝒰.J), (f i).J,
obj := λ x, (f x.1).obj x.2,
map := λ x, (f x.1).map x.2 ≫ 𝒰.map x.1,
f := λ x, ⟨_, (f _).f (𝒰.covers x).some⟩,
covers := λ x,
begin
let y := (𝒰.covers x).some,
have hy : (𝒰.map (𝒰.f x)).val.base y = x := (𝒰.covers x).some_spec,
rcases (f (𝒰.f x)).covers y with ⟨z, hz⟩,
change x ∈ set.range (((f (𝒰.f x)).map ((f (𝒰.f x)).f y) ≫ 𝒰.map (𝒰.f x)).1.base),
use z,
erw comp_apply,
rw [hz, hy],
end }
/-- An isomorphism `X ⟶ Y` is an open cover of `Y`. -/
@[simps J obj map]
def open_cover_of_is_iso {X Y : Scheme.{u}} (f : X ⟶ Y) [is_iso f] :
open_cover Y :=
{ J := punit.{v+1},
obj := λ _, X,
map := λ _, f,
f := λ _, punit.star,
covers := λ x, by { rw set.range_iff_surjective.mpr, { trivial }, rw ← Top.epi_iff_surjective,
apply_instance } }
/-- We construct an open cover from another, by providing the needed fields and showing that the
provided fields are isomorphic with the original open cover. -/
@[simps J obj map]
def open_cover.copy {X : Scheme} (𝒰 : open_cover X)
(J : Type*) (obj : J → Scheme) (map : ∀ i, obj i ⟶ X)
(e₁ : J ≃ 𝒰.J) (e₂ : ∀ i, obj i ≅ 𝒰.obj (e₁ i))
(e₂ : ∀ i, map i = (e₂ i).hom ≫ 𝒰.map (e₁ i)) : open_cover X :=
{ J := J,
obj := obj,
map := map,
f := λ x, e₁.symm (𝒰.f x),
covers := λ x, begin
rw [e₂, Scheme.comp_val_base, coe_comp, set.range_comp, set.range_iff_surjective.mpr,
set.image_univ, e₁.right_inverse_symm],
{ exact 𝒰.covers x },
{ rw ← Top.epi_iff_surjective, apply_instance }
end,
is_open := λ i, by { rw e₂, apply_instance } }
/-- The pushforward of an open cover along an isomorphism. -/
@[simps J obj map]
def open_cover.pushforward_iso {X Y : Scheme} (𝒰 : open_cover X)
(f : X ⟶ Y) [is_iso f] :
open_cover Y :=
((open_cover_of_is_iso f).bind (λ _, 𝒰)).copy 𝒰.J _ _
((equiv.punit_prod _).symm.trans (equiv.sigma_equiv_prod punit 𝒰.J).symm)
(λ _, iso.refl _)
(λ _, (category.id_comp _).symm)
/-- Adding an open immersion into an open cover gives another open cover. -/
@[simps]
def open_cover.add {X : Scheme} (𝒰 : X.open_cover) {Y : Scheme} (f : Y ⟶ X)
[is_open_immersion f] : X.open_cover :=
{ J := option 𝒰.J,
obj := λ i, option.rec Y 𝒰.obj i,
map := λ i, option.rec f 𝒰.map i,
f := λ x, some (𝒰.f x),
covers := 𝒰.covers,
is_open := by rintro (_|_); dsimp; apply_instance }
-- Related result : `open_cover.pullback_cover`, where we pullback an open cover on `X` along a
-- morphism `W ⟶ X`. This is provided at the end of the file since it needs some more results
-- about open immersion (which in turn needs the open cover API).
local attribute [reducible] CommRing.of CommRing.of_hom
instance val_base_is_iso {X Y : Scheme} (f : X ⟶ Y) [is_iso f] : is_iso f.1.base :=
Scheme.forget_to_Top.map_is_iso f
instance basic_open_is_open_immersion {R : CommRing} (f : R) :
algebraic_geometry.is_open_immersion (Scheme.Spec.map (CommRing.of_hom
(algebra_map R (localization.away f))).op) :=
begin
apply_with SheafedSpace.is_open_immersion.of_stalk_iso { instances := ff },
any_goals { apply_instance },
any_goals { apply_instance },
exact (prime_spectrum.localization_away_open_embedding (localization.away f) f : _),
intro x,
exact Spec_map_localization_is_iso R (submonoid.powers f) x,
end
/-- The basic open sets form an affine open cover of `Spec R`. -/
def affine_basis_cover_of_affine (R : CommRing) : open_cover (Spec.obj (opposite.op R)) :=
{ J := R,
obj := λ r, Spec.obj (opposite.op $ CommRing.of $ localization.away r),
map := λ r, Spec.map (quiver.hom.op (algebra_map R (localization.away r) : _)),
f := λ x, 1,
covers := λ r,
begin
rw set.range_iff_surjective.mpr ((Top.epi_iff_surjective _).mp _),
{ exact trivial },
{ apply_instance }
end,
is_open := λ x, algebraic_geometry.Scheme.basic_open_is_open_immersion x }
/-- We may bind the basic open sets of an open affine cover to form a affine cover that is also
a basis. -/
def affine_basis_cover (X : Scheme) : open_cover X :=
X.affine_cover.bind (λ x, affine_basis_cover_of_affine _)
/-- The coordinate ring of a component in the `affine_basis_cover`. -/
def affine_basis_cover_ring (X : Scheme) (i : X.affine_basis_cover.J) : CommRing :=
CommRing.of $ @localization.away (X.local_affine i.1).some_spec.some _ i.2
lemma affine_basis_cover_obj (X : Scheme) (i : X.affine_basis_cover.J) :
X.affine_basis_cover.obj i = Spec.obj (op $ X.affine_basis_cover_ring i) := rfl
lemma affine_basis_cover_map_range (X : Scheme)
(x : X.carrier) (r : (X.local_affine x).some_spec.some) :
set.range (X.affine_basis_cover.map ⟨x, r⟩).1.base =
(X.affine_cover.map x).1.base '' (prime_spectrum.basic_open r).1 :=
begin
erw [coe_comp, set.range_comp],
congr,
exact (prime_spectrum.localization_away_comap_range (localization.away r) r : _)
end
lemma affine_basis_cover_is_basis (X : Scheme) :
topological_space.is_topological_basis
{ x : set X.carrier | ∃ a : X.affine_basis_cover.J, x =
set.range ((X.affine_basis_cover.map a).1.base) } :=
begin
apply topological_space.is_topological_basis_of_open_of_nhds,
{ rintros _ ⟨a, rfl⟩,
exact is_open_immersion.open_range (X.affine_basis_cover.map a) },
{ rintros a U haU hU,
rcases X.affine_cover.covers a with ⟨x, e⟩,
let U' := (X.affine_cover.map (X.affine_cover.f a)).1.base ⁻¹' U,
have hxU' : x ∈ U' := by { rw ← e at haU, exact haU },
rcases prime_spectrum.is_basis_basic_opens.exists_subset_of_mem_open hxU'
((X.affine_cover.map (X.affine_cover.f a)).1.base.continuous_to_fun.is_open_preimage _ hU)
with ⟨_,⟨_,⟨s,rfl⟩,rfl⟩,hxV,hVU⟩,
refine ⟨_,⟨⟨_,s⟩,rfl⟩,_,_⟩; erw affine_basis_cover_map_range,
{ exact ⟨x,hxV,e⟩ },
{ rw set.image_subset_iff, exact hVU } }
end
/--
Every open cover of a quasi-compact scheme can be refined into a finite subcover.
-/
@[simps obj map]
def open_cover.finite_subcover {X : Scheme} (𝒰 : open_cover X) [H : compact_space X.carrier] :
open_cover X :=
begin
have := @@compact_space.elim_nhds_subcover _ H
(λ (x : X.carrier), set.range ((𝒰.map (𝒰.f x)).1.base))
(λ x, (is_open_immersion.open_range (𝒰.map (𝒰.f x))).mem_nhds (𝒰.covers x)),
let t := this.some,
have h : ∀ (x : X.carrier), ∃ (y : t), x ∈ set.range ((𝒰.map (𝒰.f y)).1.base),
{ intro x,
have h' : x ∈ (⊤ : set X.carrier) := trivial,
rw [← classical.some_spec this, set.mem_Union] at h',
rcases h' with ⟨y,_,⟨hy,rfl⟩,hy'⟩,
exact ⟨⟨y,hy⟩,hy'⟩ },
exact
{ J := t,
obj := λ x, 𝒰.obj (𝒰.f x.1),
map := λ x, 𝒰.map (𝒰.f x.1),
f := λ x, (h x).some,
covers := λ x, (h x).some_spec }
end
instance [H : compact_space X.carrier] : fintype 𝒰.finite_subcover.J :=
by { delta open_cover.finite_subcover, apply_instance }
end Scheme
end open_cover
namespace PresheafedSpace.is_open_immersion
section to_Scheme
variables {X : PresheafedSpace.{u} CommRing.{u}} (Y : Scheme.{u})
variables (f : X ⟶ Y.to_PresheafedSpace) [H : PresheafedSpace.is_open_immersion f]
include H
/-- If `X ⟶ Y` is an open immersion, and `Y` is a scheme, then so is `X`. -/
def to_Scheme : Scheme :=
begin
apply LocallyRingedSpace.is_open_immersion.Scheme (to_LocallyRingedSpace _ f),
intro x,
obtain ⟨_,⟨i,rfl⟩,hx,hi⟩ := Y.affine_basis_cover_is_basis.exists_subset_of_mem_open
(set.mem_range_self x) H.base_open.open_range,
use Y.affine_basis_cover_ring i,
use LocallyRingedSpace.is_open_immersion.lift (to_LocallyRingedSpace_hom _ f) _ hi,
split,
{ rw LocallyRingedSpace.is_open_immersion.lift_range, exact hx },
{ delta LocallyRingedSpace.is_open_immersion.lift, apply_instance }
end
@[simp] lemma to_Scheme_to_LocallyRingedSpace :
(to_Scheme Y f).to_LocallyRingedSpace = (to_LocallyRingedSpace Y.1 f) := rfl
/--
If `X ⟶ Y` is an open immersion of PresheafedSpaces, and `Y` is a Scheme, we can
upgrade it into a morphism of Schemes.
-/
def to_Scheme_hom : to_Scheme Y f ⟶ Y := to_LocallyRingedSpace_hom _ f
@[simp]
instance to_Scheme_hom_is_open_immersion :
is_open_immersion (to_Scheme_hom Y f) := H
omit H
lemma Scheme_eq_of_LocallyRingedSpace_eq {X Y : Scheme}
(H : X.to_LocallyRingedSpace = Y.to_LocallyRingedSpace) : X = Y :=
by { cases X, cases Y, congr, exact H }
lemma Scheme_to_Scheme {X Y : Scheme} (f : X ⟶ Y) [is_open_immersion f] :
to_Scheme Y f.1 = X :=
begin
apply Scheme_eq_of_LocallyRingedSpace_eq,
exact LocallyRingedSpace_to_LocallyRingedSpace f
end
end to_Scheme
end PresheafedSpace.is_open_immersion
/-- The restriction of a Scheme along an open embedding. -/
@[simps]
def Scheme.restrict {U : Top} (X : Scheme) {f : U ⟶ Top.of X.carrier} (h : open_embedding f) :
Scheme :=
{ to_PresheafedSpace := X.to_PresheafedSpace.restrict h,
..(PresheafedSpace.is_open_immersion.to_Scheme X (X.to_PresheafedSpace.of_restrict h)) }
/-- The canonical map from the restriction to the supspace. -/
@[simps]
def Scheme.of_restrict {U : Top} (X : Scheme) {f : U ⟶ Top.of X.carrier} (h : open_embedding f) :
X.restrict h ⟶ X :=
X.to_LocallyRingedSpace.of_restrict h
instance is_open_immersion.of_restrict {U : Top} (X : Scheme) {f : U ⟶ Top.of X.carrier}
(h : open_embedding f) : is_open_immersion (X.of_restrict h) :=
show PresheafedSpace.is_open_immersion (X.to_PresheafedSpace.of_restrict h), by apply_instance
namespace is_open_immersion
variables {X Y Z : Scheme.{u}} (f : X ⟶ Z) (g : Y ⟶ Z)
variable [H : is_open_immersion f]
@[priority 100]
instance of_is_iso [is_iso g] :
is_open_immersion g := @@LocallyRingedSpace.is_open_immersion.of_is_iso _
(show is_iso ((induced_functor _).map g), by apply_instance)
lemma to_iso {X Y : Scheme} (f : X ⟶ Y) [h : is_open_immersion f]
[epi f.1.base] : is_iso f :=
@@is_iso_of_reflects_iso _ _ f (Scheme.forget_to_LocallyRingedSpace ⋙
LocallyRingedSpace.forget_to_SheafedSpace ⋙ SheafedSpace.forget_to_PresheafedSpace)
(@@PresheafedSpace.is_open_immersion.to_iso _ f.1 h _) _
lemma of_stalk_iso {X Y : Scheme} (f : X ⟶ Y) (hf : open_embedding f.1.base)
[∀ x, is_iso (PresheafedSpace.stalk_map f.1 x)] : is_open_immersion f :=
SheafedSpace.is_open_immersion.of_stalk_iso f.1 hf
lemma iff_stalk_iso {X Y : Scheme} (f : X ⟶ Y) :
is_open_immersion f ↔ open_embedding f.1.base ∧ ∀ x, is_iso (PresheafedSpace.stalk_map f.1 x) :=
⟨λ H, ⟨H.1, by exactI infer_instance⟩, λ ⟨h₁, h₂⟩, @@is_open_immersion.of_stalk_iso f h₁ h₂⟩
lemma _root_.algebraic_geometry.is_iso_iff_is_open_immersion {X Y : Scheme} (f : X ⟶ Y) :
is_iso f ↔ is_open_immersion f ∧ epi f.1.base :=
⟨λ H, by exactI ⟨infer_instance, infer_instance⟩, λ ⟨h₁, h₂⟩, @@is_open_immersion.to_iso f h₁ h₂⟩
lemma _root_.algebraic_geometry.is_iso_iff_stalk_iso {X Y : Scheme} (f : X ⟶ Y) :
is_iso f ↔ is_iso f.1.base ∧ ∀ x, is_iso (PresheafedSpace.stalk_map f.1 x) :=
begin
rw [is_iso_iff_is_open_immersion, is_open_immersion.iff_stalk_iso, and_comm, ← and_assoc],
refine and_congr ⟨_, _⟩ iff.rfl,
{ rintro ⟨h₁, h₂⟩,
convert_to is_iso (Top.iso_of_homeo (homeomorph.homeomorph_of_continuous_open
(equiv.of_bijective _ ⟨h₂.inj, (Top.epi_iff_surjective _).mp h₁⟩)
h₂.continuous h₂.is_open_map)).hom,
{ ext, refl },
{ apply_instance } },
{ intro H, exactI ⟨infer_instance, (Top.homeo_of_iso (as_iso f.1.base)).open_embedding⟩ }
end
/-- A open immersion induces an isomorphism from the domain onto the image -/
def iso_restrict : X ≅ (Z.restrict H.base_open : _) :=
⟨H.iso_restrict.hom, H.iso_restrict.inv, H.iso_restrict.hom_inv_id, H.iso_restrict.inv_hom_id⟩
include H
local notation `forget` := Scheme.forget_to_LocallyRingedSpace
instance mono : mono f :=
(induced_functor _).mono_of_mono_map (show @mono LocallyRingedSpace _ _ _ f, by apply_instance)
instance forget_map_is_open_immersion : LocallyRingedSpace.is_open_immersion (forget .map f) :=
⟨H.base_open, H.c_iso⟩
instance has_limit_cospan_forget_of_left :
has_limit (cospan f g ⋙ Scheme.forget_to_LocallyRingedSpace) :=
begin
apply has_limit_of_iso (diagram_iso_cospan.{u} _).symm,
change has_limit (cospan (forget .map f) (forget .map g)),
apply_instance
end
open category_theory.limits.walking_cospan
instance has_limit_cospan_forget_of_left' :
has_limit (cospan ((cospan f g ⋙ forget).map hom.inl)
((cospan f g ⋙ forget).map hom.inr)) :=
show has_limit (cospan (forget .map f) (forget .map g)), from infer_instance
instance has_limit_cospan_forget_of_right : has_limit (cospan g f ⋙ forget) :=
begin
apply has_limit_of_iso (diagram_iso_cospan.{u} _).symm,
change has_limit (cospan (forget .map g) (forget .map f)),
apply_instance
end
instance has_limit_cospan_forget_of_right' :
has_limit (cospan ((cospan g f ⋙ forget).map hom.inl)
((cospan g f ⋙ forget).map hom.inr)) :=
show has_limit (cospan (forget .map g) (forget .map f)), from infer_instance
instance forget_creates_pullback_of_left : creates_limit (cospan f g) forget :=
creates_limit_of_fully_faithful_of_iso
(PresheafedSpace.is_open_immersion.to_Scheme Y
(@pullback.snd LocallyRingedSpace _ _ _ _ f g _).1)
(eq_to_iso (by simp) ≪≫ has_limit.iso_of_nat_iso (diagram_iso_cospan _).symm)
instance forget_creates_pullback_of_right : creates_limit (cospan g f) forget :=
creates_limit_of_fully_faithful_of_iso
(PresheafedSpace.is_open_immersion.to_Scheme Y
(@pullback.fst LocallyRingedSpace _ _ _ _ g f _).1)
(eq_to_iso (by simp) ≪≫ has_limit.iso_of_nat_iso (diagram_iso_cospan _).symm)
instance forget_preserves_of_left : preserves_limit (cospan f g) forget :=
category_theory.preserves_limit_of_creates_limit_and_has_limit _ _
instance forget_preserves_of_right : preserves_limit (cospan g f) forget :=
preserves_pullback_symmetry _ _ _
instance has_pullback_of_left : has_pullback f g :=
has_limit_of_created (cospan f g) forget
instance has_pullback_of_right : has_pullback g f :=
has_limit_of_created (cospan g f) forget
instance pullback_snd_of_left : is_open_immersion (pullback.snd : pullback f g ⟶ _) :=
begin
have := preserves_pullback.iso_hom_snd forget f g,
dsimp only [Scheme.forget_to_LocallyRingedSpace, induced_functor_map] at this,
rw ← this,
change LocallyRingedSpace.is_open_immersion _,
apply_instance
end
instance pullback_fst_of_right : is_open_immersion (pullback.fst : pullback g f ⟶ _) :=
begin
rw ← pullback_symmetry_hom_comp_snd,
apply_instance
end
instance pullback_to_base [is_open_immersion g] :
is_open_immersion (limit.π (cospan f g) walking_cospan.one) :=
begin
rw ← limit.w (cospan f g) walking_cospan.hom.inl,
change is_open_immersion (_ ≫ f),
apply_instance
end
instance forget_to_Top_preserves_of_left :
preserves_limit (cospan f g) Scheme.forget_to_Top :=
begin
apply_with limits.comp_preserves_limit { instances := ff },
apply_instance,
apply preserves_limit_of_iso_diagram _ (diagram_iso_cospan.{u} _).symm,
dsimp [LocallyRingedSpace.forget_to_Top],
apply_instance
end
instance forget_to_Top_preserves_of_right :
preserves_limit (cospan g f) Scheme.forget_to_Top := preserves_pullback_symmetry _ _ _
lemma range_pullback_snd_of_left :
set.range (pullback.snd : pullback f g ⟶ Y).1.base =
(opens.map g.1.base).obj ⟨set.range f.1.base, H.base_open.open_range⟩ :=
begin
rw [← (show _ = (pullback.snd : pullback f g ⟶ _).1.base,
from preserves_pullback.iso_hom_snd Scheme.forget_to_Top f g), coe_comp, set.range_comp,
set.range_iff_surjective.mpr,
← @set.preimage_univ _ _ (pullback.fst : pullback f.1.base g.1.base ⟶ _),
Top.pullback_snd_image_fst_preimage, set.image_univ],
refl,
rw ← Top.epi_iff_surjective,
apply_instance
end
lemma range_pullback_fst_of_right :
set.range (pullback.fst : pullback g f ⟶ Y).1.base =
(opens.map g.1.base).obj ⟨set.range f.1.base, H.base_open.open_range⟩ :=
begin
rw [← (show _ = (pullback.fst : pullback g f ⟶ _).1.base,
from preserves_pullback.iso_hom_fst Scheme.forget_to_Top g f), coe_comp, set.range_comp,
set.range_iff_surjective.mpr,
← @set.preimage_univ _ _ (pullback.snd : pullback g.1.base f.1.base ⟶ _),
Top.pullback_fst_image_snd_preimage, set.image_univ],
refl,
rw ← Top.epi_iff_surjective,
apply_instance
end
lemma range_pullback_to_base_of_left :
set.range (pullback.fst ≫ f : pullback f g ⟶ Z).1.base =
set.range f.1.base ∩ set.range g.1.base :=
begin
rw [pullback.condition, Scheme.comp_val_base, coe_comp, set.range_comp,
range_pullback_snd_of_left, opens.map_obj, opens.coe_mk, set.image_preimage_eq_inter_range,
set.inter_comm],
end
lemma range_pullback_to_base_of_right :
set.range (pullback.fst ≫ g : pullback g f ⟶ Z).1.base =
set.range g.1.base ∩ set.range f.1.base :=
begin
rw [Scheme.comp_val_base, coe_comp, set.range_comp, range_pullback_fst_of_right, opens.map_obj,
opens.coe_mk, set.image_preimage_eq_inter_range, set.inter_comm],
end
/--
The universal property of open immersions:
For an open immersion `f : X ⟶ Z`, given any morphism of schemes `g : Y ⟶ Z` whose topological
image is contained in the image of `f`, we can lift this morphism to a unique `Y ⟶ X` that
commutes with these maps.
-/
def lift (H' : set.range g.1.base ⊆ set.range f.1.base) : Y ⟶ X :=
LocallyRingedSpace.is_open_immersion.lift f g H'
@[simp, reassoc] lemma lift_fac (H' : set.range g.1.base ⊆ set.range f.1.base) :
lift f g H' ≫ f = g :=
LocallyRingedSpace.is_open_immersion.lift_fac f g H'
lemma lift_uniq (H' : set.range g.1.base ⊆ set.range f.1.base) (l : Y ⟶ X)
(hl : l ≫ f = g) : l = lift f g H' :=
LocallyRingedSpace.is_open_immersion.lift_uniq f g H' l hl
/-- Two open immersions with equal range are isomorphic. -/
@[simps] def iso_of_range_eq [is_open_immersion g] (e : set.range f.1.base = set.range g.1.base) :
X ≅ Y :=
{ hom := lift g f (le_of_eq e),
inv := lift f g (le_of_eq e.symm),
hom_inv_id' := by { rw ← cancel_mono f, simp },
inv_hom_id' := by { rw ← cancel_mono g, simp } }
/-- The functor `opens X ⥤ opens Y` associated with an open immersion `f : X ⟶ Y`. -/
abbreviation _root_.algebraic_geometry.Scheme.hom.opens_functor {X Y : Scheme} (f : X ⟶ Y)
[H : is_open_immersion f] :
opens X.carrier ⥤ opens Y.carrier :=
H.open_functor
/-- The isomorphism `Γ(X, U) ⟶ Γ(Y, f(U))` induced by an open immersion `f : X ⟶ Y`. -/
def _root_.algebraic_geometry.Scheme.hom.inv_app {X Y : Scheme} (f : X ⟶ Y)
[H : is_open_immersion f] (U) :
X.presheaf.obj (op U) ⟶ Y.presheaf.obj (op (f.opens_functor.obj U)) :=
H.inv_app U
lemma app_eq_inv_app_app_of_comp_eq_aux {X Y U : Scheme} (f : Y ⟶ U) (g : U ⟶ X)
(fg : Y ⟶ X) (H : fg = f ≫ g) [h : is_open_immersion g] (V : opens U.carrier) :
(opens.map f.1.base).obj V = (opens.map fg.1.base).obj (g.opens_functor.obj V) :=
begin
subst H,
rw [Scheme.comp_val_base, opens.map_comp_obj],
congr' 1,
ext1,
exact (set.preimage_image_eq _ h.base_open.inj).symm
end
/-- The `fg` argument is to avoid nasty stuff about dependent types. -/
lemma app_eq_inv_app_app_of_comp_eq {X Y U : Scheme} (f : Y ⟶ U) (g : U ⟶ X)
(fg : Y ⟶ X) (H : fg = f ≫ g) [h : is_open_immersion g] (V : opens U.carrier) :
f.1.c.app (op V) = g.inv_app _ ≫ fg.1.c.app _ ≫ Y.presheaf.map (eq_to_hom $
is_open_immersion.app_eq_inv_app_app_of_comp_eq_aux f g fg H V).op :=
begin
subst H,
rw [Scheme.comp_val_c_app, category.assoc, Scheme.hom.inv_app,
PresheafedSpace.is_open_immersion.inv_app_app_assoc,
f.val.c.naturality_assoc, Top.presheaf.pushforward_obj_map, ← functor.map_comp],
convert (category.comp_id _).symm,
convert Y.presheaf.map_id _,
end
lemma lift_app {X Y U : Scheme} (f : U ⟶ Y) (g : X ⟶ Y)
[h : is_open_immersion f] (H) (V : opens U.carrier) :
(is_open_immersion.lift f g H).1.c.app (op V) = f.inv_app _ ≫ g.1.c.app _ ≫
X.presheaf.map (eq_to_hom $ is_open_immersion.app_eq_inv_app_app_of_comp_eq_aux _ _ _
(is_open_immersion.lift_fac f g H).symm V).op :=
is_open_immersion.app_eq_inv_app_app_of_comp_eq _ _ _ _ _
end is_open_immersion
namespace Scheme
lemma image_basic_open {X Y : Scheme} (f : X ⟶ Y) [H : is_open_immersion f]
{U : opens X.carrier} (r : X.presheaf.obj (op U)) :
f.opens_functor.obj (X.basic_open r) = Y.basic_open (f.inv_app U r) :=
begin
have e := Scheme.preimage_basic_open f (f.inv_app U r),
rw [Scheme.hom.inv_app, PresheafedSpace.is_open_immersion.inv_app_app_apply,
Scheme.basic_open_res, inf_eq_right.mpr _] at e,
rw ← e,
ext1,
refine set.image_preimage_eq_inter_range.trans _,
erw set.inter_eq_left_iff_subset,
refine set.subset.trans (Scheme.basic_open_le _ _) (set.image_subset_range _ _),
refine le_trans (Scheme.basic_open_le _ _) (le_of_eq _),
ext1,
exact (set.preimage_image_eq _ H.base_open.inj).symm
end
/-- The image of an open immersion as an open set. -/
@[simps]
def hom.opens_range {X Y : Scheme} (f : X ⟶ Y) [H : is_open_immersion f] : opens Y.carrier :=
⟨_, H.base_open.open_range⟩
end Scheme
section
variable (X : Scheme)
/-- The functor taking open subsets of `X` to open subschemes of `X`. -/
@[simps obj_left obj_hom map_left]
def Scheme.restrict_functor : opens X.carrier ⥤ over X :=
{ obj := λ U, over.mk (X.of_restrict U.open_embedding),
map := λ U V i, over.hom_mk (is_open_immersion.lift (X.of_restrict _) (X.of_restrict _)
(by { change set.range coe ⊆ set.range coe, simp_rw [subtype.range_coe], exact i.le }))
(is_open_immersion.lift_fac _ _ _),
map_id' := λ U, by begin
ext1,
dsimp only [over.hom_mk_left, over.id_left],
rw [← cancel_mono (X.of_restrict U.open_embedding), category.id_comp,
is_open_immersion.lift_fac],
end,
map_comp' := λ U V W i j, begin
ext1,
dsimp only [over.hom_mk_left, over.comp_left],
rw [← cancel_mono (X.of_restrict W.open_embedding), category.assoc],
iterate 3 { rw [is_open_immersion.lift_fac] }
end }
@[reassoc]
lemma Scheme.restrict_functor_map_of_restrict {U V : opens X.carrier} (i : U ⟶ V) :
(X.restrict_functor.map i).1 ≫ X.of_restrict _ = X.of_restrict _ :=
is_open_immersion.lift_fac _ _ _
lemma Scheme.restrict_functor_map_base {U V : opens X.carrier} (i : U ⟶ V) :
(X.restrict_functor.map i).1.1.base = (opens.to_Top _).map i :=
begin
ext a,
exact (congr_arg (λ f : X.restrict U.open_embedding ⟶ X, by exact f.1.base a)
(X.restrict_functor_map_of_restrict i) : _),
end
lemma Scheme.restrict_functor_map_app_aux {U V : opens X.carrier} (i : U ⟶ V) (W : opens V) :
U.open_embedding.is_open_map.functor.obj
((opens.map (X.restrict_functor.map i).1.val.base).obj W) ≤
V.open_embedding.is_open_map.functor.obj W :=
begin
simp only [← set_like.coe_subset_coe, is_open_map.functor_obj_coe, set.image_subset_iff,
Scheme.restrict_functor_map_base, opens.map_coe, opens.inclusion_apply],
rintros _ h,
exact ⟨_, h, rfl⟩,
end
lemma Scheme.restrict_functor_map_app {U V : opens X.carrier} (i : U ⟶ V) (W : opens V) :
(X.restrict_functor.map i).1.1.c.app (op W) = X.presheaf.map
(hom_of_le $ X.restrict_functor_map_app_aux i W).op :=
begin
have e₁ := Scheme.congr_app (X.restrict_functor_map_of_restrict i)
(op $ V.open_embedding.is_open_map.functor.obj W),
rw Scheme.comp_val_c_app at e₁,
have e₂ := (X.restrict_functor.map i).1.val.c.naturality (eq_to_hom W.map_functor_eq).op,
rw ← is_iso.eq_inv_comp at e₂,
dsimp at e₁ e₂ ⊢,
rw [e₂, W.adjunction_counit_map_functor, ← is_iso.eq_inv_comp, is_iso.inv_comp_eq,
← is_iso.eq_comp_inv] at e₁,
simp_rw [eq_to_hom_map (opens.map _), eq_to_hom_map (is_open_map.functor _), ← functor.map_inv,
← functor.map_comp] at e₁,
rw e₁,
congr' 1,
end
/-- The functor that restricts to open subschemes and then takes global section is
isomorphic to the structure sheaf. -/
@[simps]
def Scheme.restrict_functor_Γ :
X.restrict_functor.op ⋙ (over.forget X).op ⋙ Scheme.Γ ≅ X.presheaf :=
nat_iso.of_components
(λ U, X.presheaf.map_iso ((eq_to_iso (unop U).open_embedding_obj_top).symm.op : _))
begin
intros U V i,
dsimp [-subtype.val_eq_coe, -Scheme.restrict_functor_map_left],
rw [X.restrict_functor_map_app, ← functor.map_comp, ← functor.map_comp],
congr' 1
end
end
/-- The restriction of an isomorphism onto an open set. -/
noncomputable
abbreviation Scheme.restrict_map_iso {X Y : Scheme} (f : X ⟶ Y) [is_iso f] (U : opens Y.carrier) :
X.restrict ((opens.map f.1.base).obj U).open_embedding ≅ Y.restrict U.open_embedding :=
begin
refine is_open_immersion.iso_of_range_eq (X.of_restrict _ ≫ f) (Y.of_restrict _) _,
dsimp [opens.inclusion],
rw [coe_comp, set.range_comp],
dsimp,
rw [subtype.range_coe, subtype.range_coe],
refine @set.image_preimage_eq _ _ f.1.base U.1 _,
rw ← Top.epi_iff_surjective,
apply_instance
end
/-- Given an open cover on `X`, we may pull them back along a morphism `W ⟶ X` to obtain
an open cover of `W`. -/
@[simps]
def Scheme.open_cover.pullback_cover {X : Scheme} (𝒰 : X.open_cover) {W : Scheme} (f : W ⟶ X) :
W.open_cover :=
{ J := 𝒰.J,
obj := λ x, pullback f (𝒰.map x),
map := λ x, pullback.fst,
f := λ x, 𝒰.f (f.1.base x),
covers := λ x, begin
rw ← (show _ = (pullback.fst : pullback f (𝒰.map (𝒰.f (f.1.base x))) ⟶ _).1.base,
from preserves_pullback.iso_hom_fst Scheme.forget_to_Top f
(𝒰.map (𝒰.f (f.1.base x)))),
rw [coe_comp, set.range_comp, set.range_iff_surjective.mpr, set.image_univ,
Top.pullback_fst_range],
obtain ⟨y, h⟩ := 𝒰.covers (f.1.base x),
exact ⟨y, h.symm⟩,
{ rw ← Top.epi_iff_surjective, apply_instance }
end }
lemma Scheme.open_cover.Union_range {X : Scheme} (𝒰 : X.open_cover) :
(⋃ i, set.range (𝒰.map i).1.base) = set.univ :=
begin
rw set.eq_univ_iff_forall,
intros x,
rw set.mem_Union,
exact ⟨𝒰.f x, 𝒰.covers x⟩
end
lemma Scheme.open_cover.supr_opens_range {X : Scheme} (𝒰 : X.open_cover) :
(⨆ i, (𝒰.map i).opens_range) = ⊤ :=
opens.ext $ by { rw opens.coe_supr, exact 𝒰.Union_range }
lemma Scheme.open_cover.compact_space {X : Scheme} (𝒰 : X.open_cover) [finite 𝒰.J]
[H : ∀ i, compact_space (𝒰.obj i).carrier] : compact_space X.carrier :=
begin
casesI nonempty_fintype 𝒰.J,
rw [← is_compact_univ_iff, ← 𝒰.Union_range],
apply is_compact_Union,
intro i,
rw is_compact_iff_compact_space,
exact @@homeomorph.compact_space _ _ (H i)
(Top.homeo_of_iso (as_iso (is_open_immersion.iso_of_range_eq (𝒰.map i)
(X.of_restrict (opens.open_embedding ⟨_, (𝒰.is_open i).base_open.open_range⟩))
subtype.range_coe.symm).hom.1.base))
end
/-- Given open covers `{ Uᵢ }` and `{ Uⱼ }`, we may form the open cover `{ Uᵢ ∩ Uⱼ }`. -/
def Scheme.open_cover.inter {X : Scheme.{u}} (𝒰₁ : Scheme.open_cover.{v₁} X)
(𝒰₂ : Scheme.open_cover.{v₂} X) : X.open_cover :=
{ J := 𝒰₁.J × 𝒰₂.J,
obj := λ ij, pullback (𝒰₁.map ij.1) (𝒰₂.map ij.2),
map := λ ij, pullback.fst ≫ 𝒰₁.map ij.1,
f := λ x, ⟨𝒰₁.f x, 𝒰₂.f x⟩,
covers := λ x, by { rw is_open_immersion.range_pullback_to_base_of_left,
exact ⟨𝒰₁.covers x, 𝒰₂.covers x⟩ } }
/-- If `U` is a family of open sets that covers `X`, then `X.restrict U` forms an `X.open_cover`. -/
@[simps J obj map]
def Scheme.open_cover_of_supr_eq_top {s : Type*} (X : Scheme) (U : s → opens X.carrier)
(hU : (⨆ i, U i) = ⊤) : X.open_cover :=
{ J := s,
obj := λ i, X.restrict (U i).open_embedding,
map := λ i, X.of_restrict (U i).open_embedding,
f := λ x, begin
have : x ∈ ⨆ i, U i := hU.symm ▸ (show x ∈ (⊤ : opens X.carrier), by triv),
exact (opens.mem_supr.mp this).some,
end,
covers := λ x, begin
erw subtype.range_coe,
have : x ∈ ⨆ i, U i := hU.symm ▸ (show x ∈ (⊤ : opens X.carrier), by triv),
exact (opens.mem_supr.mp this).some_spec,
end }
section morphism_restrict
/-- Given a morphism `f : X ⟶ Y` and an open set `U ⊆ Y`, we have `X ×[Y] U ≅ X |_{f ⁻¹ U}` -/
def pullback_restrict_iso_restrict {X Y : Scheme} (f : X ⟶ Y) (U : opens Y.carrier) :
pullback f (Y.of_restrict U.open_embedding) ≅
X.restrict ((opens.map f.1.base).obj U).open_embedding :=
begin
refine is_open_immersion.iso_of_range_eq pullback.fst (X.of_restrict _) _,
rw is_open_immersion.range_pullback_fst_of_right,
dsimp [opens.inclusion],
rw [subtype.range_coe, subtype.range_coe],
refl,
end
@[simp, reassoc]
lemma pullback_restrict_iso_restrict_inv_fst {X Y : Scheme} (f : X ⟶ Y) (U : opens Y.carrier) :
(pullback_restrict_iso_restrict f U).inv ≫ pullback.fst = X.of_restrict _ :=
by { delta pullback_restrict_iso_restrict, simp }
@[simp, reassoc]
lemma pullback_restrict_iso_restrict_hom_restrict {X Y : Scheme} (f : X ⟶ Y) (U : opens Y.carrier) :
(pullback_restrict_iso_restrict f U).hom ≫ X.of_restrict _ = pullback.fst :=
by { delta pullback_restrict_iso_restrict, simp }
/-- The restriction of a morphism `X ⟶ Y` onto `X |_{f ⁻¹ U} ⟶ Y |_ U`. -/
def morphism_restrict {X Y : Scheme} (f : X ⟶ Y) (U : opens Y.carrier) :
X.restrict ((opens.map f.1.base).obj U).open_embedding ⟶ Y.restrict U.open_embedding :=
(pullback_restrict_iso_restrict f U).inv ≫ pullback.snd
infix ` ∣_ `: 80 := morphism_restrict
@[simp, reassoc]
lemma pullback_restrict_iso_restrict_hom_morphism_restrict {X Y : Scheme} (f : X ⟶ Y)
(U : opens Y.carrier) :
(pullback_restrict_iso_restrict f U).hom ≫ f ∣_ U = pullback.snd :=
iso.hom_inv_id_assoc _ _
@[simp, reassoc]
lemma morphism_restrict_ι {X Y : Scheme} (f : X ⟶ Y) (U : opens Y.carrier) :
f ∣_ U ≫ Y.of_restrict U.open_embedding = X.of_restrict _ ≫ f :=
by { delta morphism_restrict,
rw [category.assoc, pullback.condition.symm, pullback_restrict_iso_restrict_inv_fst_assoc] }
lemma is_pullback_morphism_restrict {X Y : Scheme} (f : X ⟶ Y) (U : opens Y.carrier) :
is_pullback (f ∣_ U) (X.of_restrict _) (Y.of_restrict _) f :=
begin
delta morphism_restrict,
nth_rewrite 0 ← category.id_comp f,
refine (is_pullback.of_horiz_is_iso ⟨_⟩).paste_horiz
(is_pullback.of_has_pullback f (Y.of_restrict U.open_embedding)).flip,
rw [pullback_restrict_iso_restrict_inv_fst, category.comp_id],
end
lemma morphism_restrict_comp {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) (U : opens Z.carrier) :
(f ≫ g) ∣_ U = (f ∣_ ((opens.map g.val.base).obj U) ≫ g ∣_ U : _) :=
begin
delta morphism_restrict,
rw ← pullback_right_pullback_fst_iso_inv_snd_snd,
simp_rw ← category.assoc,
congr' 1,
rw ← cancel_mono pullback.fst,
simp_rw category.assoc,
rw [pullback_restrict_iso_restrict_inv_fst, pullback_right_pullback_fst_iso_inv_snd_fst,
← pullback.condition, pullback_restrict_iso_restrict_inv_fst_assoc,
pullback_restrict_iso_restrict_inv_fst_assoc],
refl,
apply_instance
end
instance {X Y : Scheme} (f : X ⟶ Y) [is_iso f] (U : opens Y.carrier) : is_iso (f ∣_ U) :=
by { delta morphism_restrict, apply_instance }
lemma morphism_restrict_base_coe {X Y : Scheme} (f : X ⟶ Y) (U : opens Y.carrier) (x) :
@coe U Y.carrier _ ((f ∣_ U).1.base x) = f.1.base x.1 :=
congr_arg (λ f, PresheafedSpace.hom.base (LocallyRingedSpace.hom.val f) x) (morphism_restrict_ι f U)
lemma morphism_restrict_val_base {X Y : Scheme} (f : X ⟶ Y) (U : opens Y.carrier) :
⇑(f ∣_ U).1.base = U.1.restrict_preimage f.1.base :=
funext (λ x, subtype.ext (morphism_restrict_base_coe f U x))
lemma image_morphism_restrict_preimage {X Y : Scheme} (f : X ⟶ Y) (U : opens Y.carrier)
(V : opens U) :
((opens.map f.val.base).obj U).open_embedding.is_open_map.functor.obj
((opens.map (f ∣_ U).val.base).obj V) =
(opens.map f.val.base).obj (U.open_embedding.is_open_map.functor.obj V) :=
begin
ext1,
ext x,
split,
{ rintro ⟨⟨x, hx⟩, (hx' : (f ∣_ U).1.base _ ∈ _), rfl⟩,
refine ⟨⟨_, hx⟩, _, rfl⟩,
convert hx',
ext1,
exact (morphism_restrict_base_coe f U ⟨x, hx⟩).symm },
{ rintro ⟨⟨x, hx⟩, hx', (rfl : x = _)⟩,
refine ⟨⟨_, hx⟩, (_: ((f ∣_ U).1.base ⟨x, hx⟩) ∈ V.1), rfl⟩,
convert hx',
ext1,
exact morphism_restrict_base_coe f U ⟨x, hx⟩ }
end
lemma morphism_restrict_c_app {X Y : Scheme} (f : X ⟶ Y) (U : opens Y.carrier) (V : opens U) :
(f ∣_ U).1.c.app (op V) = f.1.c.app (op (U.open_embedding.is_open_map.functor.obj V)) ≫
X.presheaf.map (eq_to_hom (image_morphism_restrict_preimage f U V)).op :=
begin
have := Scheme.congr_app (morphism_restrict_ι f U)
(op (U.open_embedding.is_open_map.functor.obj V)),
rw [Scheme.comp_val_c_app, Scheme.comp_val_c_app_assoc] at this,
have e : (opens.map U.inclusion).obj (U.open_embedding.is_open_map.functor.obj V) = V,
{ ext1, exact set.preimage_image_eq _ subtype.coe_injective },
have : _ ≫ X.presheaf.map _ = _ :=
(((f ∣_ U).1.c.naturality (eq_to_hom e).op).symm.trans _).trans this,
swap, { change Y.presheaf.map _ ≫ _ = Y.presheaf.map _ ≫ _, congr, },
rw [← is_iso.eq_comp_inv, ← functor.map_inv, category.assoc] at this,
rw this,
congr' 1,
erw [← X.presheaf.map_comp, ← X.presheaf.map_comp],
congr' 1,
end
lemma Γ_map_morphism_restrict {X Y : Scheme} (f : X ⟶ Y) (U : opens Y.carrier) :
Scheme.Γ.map (f ∣_ U).op = Y.presheaf.map (eq_to_hom $ U.open_embedding_obj_top.symm).op ≫
f.1.c.app (op U) ≫
X.presheaf.map (eq_to_hom $ ((opens.map f.val.base).obj U).open_embedding_obj_top).op :=
begin
rw [Scheme.Γ_map_op, morphism_restrict_c_app f U ⊤, f.val.c.naturality_assoc],
erw ← X.presheaf.map_comp,
congr,
end
/-- Restricting a morphism onto the the image of an open immersion is isomorphic to the base change
along the immersion. -/
def morphism_restrict_opens_range
{X Y U : Scheme} (f : X ⟶ Y) (g : U ⟶ Y) [hg : is_open_immersion g] :
arrow.mk (f ∣_ g.opens_range) ≅ arrow.mk (pullback.snd : pullback f g ⟶ _) :=
begin
let V : opens Y.carrier := g.opens_range,
let e := is_open_immersion.iso_of_range_eq g (Y.of_restrict V.open_embedding)
(by exact subtype.range_coe.symm),
let t : pullback f g ⟶ pullback f (Y.of_restrict V.open_embedding) :=
pullback.map _ _ _ _ (𝟙 _) e.hom (𝟙 _) (by rw [category.comp_id, category.id_comp])
(by rw [category.comp_id, is_open_immersion.iso_of_range_eq_hom, is_open_immersion.lift_fac]),
symmetry,
refine arrow.iso_mk (as_iso t ≪≫ pullback_restrict_iso_restrict f V) e _,
rw [iso.trans_hom, as_iso_hom, ← iso.comp_inv_eq, ← cancel_mono g, arrow.mk_hom, arrow.mk_hom,
is_open_immersion.iso_of_range_eq_inv, category.assoc, category.assoc, category.assoc,
is_open_immersion.lift_fac, ← pullback.condition, morphism_restrict_ι,
pullback_restrict_iso_restrict_hom_restrict_assoc, pullback.lift_fst_assoc, category.comp_id],
end
/-- The restrictions onto two equal open sets are isomorphic. This currently has bad defeqs when
unfolded, but it should not matter for now. Replace this definition if better defeqs are needed. -/
def morphism_restrict_eq {X Y : Scheme} (f : X ⟶ Y) {U V : opens Y.carrier} (e : U = V) :
arrow.mk (f ∣_ U) ≅ arrow.mk (f ∣_ V) := eq_to_iso (by subst e)
/-- Restricting a morphism twice is isomorpic to one restriction. -/
def morphism_restrict_restrict {X Y : Scheme} (f : X ⟶ Y) (U : opens Y.carrier) (V : opens U) :
arrow.mk (f ∣_ U ∣_ V) ≅ arrow.mk (f ∣_ (U.open_embedding.is_open_map.functor.obj V)) :=
begin
have : (f ∣_ U ∣_ V) ≫ (iso.refl _).hom =
(as_iso $ (pullback_restrict_iso_restrict (f ∣_ U) V).inv ≫ (pullback_symmetry _ _).hom ≫
pullback.map _ _ _ _ (𝟙 _)
((pullback_restrict_iso_restrict f U).inv ≫ (pullback_symmetry _ _).hom) (𝟙 _)
((category.comp_id _).trans (category.id_comp _).symm) (by simpa) ≫
(pullback_right_pullback_fst_iso _ _ _).hom ≫ (pullback_symmetry _ _).hom).hom ≫ pullback.snd,
{ simpa only [category.comp_id, pullback_right_pullback_fst_iso_hom_fst, iso.refl_hom,
category.assoc, pullback_symmetry_hom_comp_snd, as_iso_hom, pullback.lift_fst,
pullback_symmetry_hom_comp_fst] },
refine arrow.iso_mk' _ _ _ _ this.symm ≪≫ (morphism_restrict_opens_range _ _).symm ≪≫
morphism_restrict_eq _ _,
ext1,
dsimp,
rw [coe_comp, set.range_comp],
congr,
exact subtype.range_coe,
end
/-- Restricting a morphism twice onto a basic open set is isomorphic to one restriction. -/
def morphism_restrict_restrict_basic_open {X Y : Scheme} (f : X ⟶ Y) (U : opens Y.carrier)
(r : Y.presheaf.obj (op U)) :
arrow.mk (f ∣_ U ∣_ (Y.restrict _).basic_open
(Y.presheaf.map (eq_to_hom U.open_embedding_obj_top).op r)) ≅ arrow.mk (f ∣_ Y.basic_open r) :=
begin
refine morphism_restrict_restrict _ _ _ ≪≫ morphism_restrict_eq _ _,
have e := Scheme.preimage_basic_open (Y.of_restrict U.open_embedding) r,
erw [Scheme.of_restrict_val_c_app, opens.adjunction_counit_app_self, eq_to_hom_op] at e,
rw [← (Y.restrict U.open_embedding).basic_open_res_eq _
(eq_to_hom U.inclusion_map_eq_top).op, ← comp_apply],
erw ← Y.presheaf.map_comp,
rw [eq_to_hom_op, eq_to_hom_op, eq_to_hom_map, eq_to_hom_trans],
erw ← e,
ext1, dsimp [opens.map, opens.inclusion],
rw [set.image_preimage_eq_inter_range, set.inter_eq_left_iff_subset, subtype.range_coe],
exact Y.basic_open_le r
end
/--
The stalk map of a restriction of a morphism is isomorphic to the stalk map of the original map.
-/
def morphism_restrict_stalk_map {X Y : Scheme} (f : X ⟶ Y) (U : opens Y.carrier) (x) :
arrow.mk (PresheafedSpace.stalk_map (f ∣_ U).1 x) ≅
arrow.mk (PresheafedSpace.stalk_map f.1 x.1) :=
begin
fapply arrow.iso_mk',
{ refine Y.restrict_stalk_iso U.open_embedding ((f ∣_ U).1 x) ≪≫ Top.presheaf.stalk_congr _ _,
apply inseparable.of_eq,
exact morphism_restrict_base_coe f U x },
{ exact X.restrict_stalk_iso _ _ },
{ apply Top.presheaf.stalk_hom_ext,
intros V hxV,
simp only [Top.presheaf.stalk_congr_hom, category_theory.category.assoc,
category_theory.iso.trans_hom],
erw PresheafedSpace.restrict_stalk_iso_hom_eq_germ_assoc,
erw PresheafedSpace.stalk_map_germ_assoc _ _ ⟨_, _⟩,
rw [Top.presheaf.germ_stalk_specializes'_assoc],
erw PresheafedSpace.stalk_map_germ _ _ ⟨_, _⟩,
erw PresheafedSpace.restrict_stalk_iso_hom_eq_germ,
rw [morphism_restrict_c_app, category.assoc, Top.presheaf.germ_res],
refl }
end
instance {X Y : Scheme} (f : X ⟶ Y) (U : opens Y.carrier) [is_open_immersion f] :
is_open_immersion (f ∣_ U) :=
by { delta morphism_restrict, apply_instance }
end morphism_restrict
end algebraic_geometry
|
If $f$ is an orthogonal transformation, then $f$ maps the ball of radius $r$ centered at $x$ to the ball of radius $r$ centered at $f(x)$. |
State Before: α : Type u_1
β : Type ?u.248864
γ : Type ?u.248867
δ : Type ?u.248870
inst✝¹ : Monoid α
inst✝ : Unique αˣ
x y : α
⊢ x ~ᵤ y ↔ x = y State After: case mp
α : Type u_1
β : Type ?u.248864
γ : Type ?u.248867
δ : Type ?u.248870
inst✝¹ : Monoid α
inst✝ : Unique αˣ
x y : α
⊢ x ~ᵤ y → x = y
case mpr
α : Type u_1
β : Type ?u.248864
γ : Type ?u.248867
δ : Type ?u.248870
inst✝¹ : Monoid α
inst✝ : Unique αˣ
x y : α
⊢ x = y → x ~ᵤ y Tactic: constructor State Before: case mp
α : Type u_1
β : Type ?u.248864
γ : Type ?u.248867
δ : Type ?u.248870
inst✝¹ : Monoid α
inst✝ : Unique αˣ
x y : α
⊢ x ~ᵤ y → x = y State After: case mp.intro
α : Type u_1
β : Type ?u.248864
γ : Type ?u.248867
δ : Type ?u.248870
inst✝¹ : Monoid α
inst✝ : Unique αˣ
x : α
c : αˣ
⊢ x = x * ↑c Tactic: rintro ⟨c, rfl⟩ State Before: case mp.intro
α : Type u_1
β : Type ?u.248864
γ : Type ?u.248867
δ : Type ?u.248870
inst✝¹ : Monoid α
inst✝ : Unique αˣ
x : α
c : αˣ
⊢ x = x * ↑c State After: no goals Tactic: rw [units_eq_one c, Units.val_one, mul_one] State Before: case mpr
α : Type u_1
β : Type ?u.248864
γ : Type ?u.248867
δ : Type ?u.248870
inst✝¹ : Monoid α
inst✝ : Unique αˣ
x y : α
⊢ x = y → x ~ᵤ y State After: case mpr
α : Type u_1
β : Type ?u.248864
γ : Type ?u.248867
δ : Type ?u.248870
inst✝¹ : Monoid α
inst✝ : Unique αˣ
x : α
⊢ x ~ᵤ x Tactic: rintro rfl State Before: case mpr
α : Type u_1
β : Type ?u.248864
γ : Type ?u.248867
δ : Type ?u.248870
inst✝¹ : Monoid α
inst✝ : Unique αˣ
x : α
⊢ x ~ᵤ x State After: no goals Tactic: rfl |
\section{UTxO}
\label{sec:utxo}
\subsection{UTxO Transitions}
\label{sec:utxo-trans}
We have added the following helper functions, which are used in defining the
UTxO transition system, see Figure~\ref{fig:functions:insouts}. These include:
\begin{itemize}
\item the function $\fun{getOut}$ builds a UTxO-type output out of a
transaction output
\item the function $\fun{outs}$ builds the MC UTxO entries from the outputs
of a transaction
\end{itemize}
\begin{figure}[htb]
\begin{align*}
& \fun{getOut} \in \TxOut \to \UTxOOut \\
& \text{tx outputs transformed to UTxO outputs} \\
& \fun{getOut} ~{txout}~= (\fun{getAddr}~\var{txout}, \fun{getValue}~\var{txout})
\nextdef
& \fun{outs} \in \TxBody \to \UTxO \\
& \text{tx outputs as UTxO} \\
& \fun{outs} ~\var{txb} =
\left\{
(\fun{txid} ~ \var{txb}, \var{ix}) \mapsto \fun{getOut}~\var{txout} ~
\middle|~
\var{ix} \mapsto \var{txout} \in \txouts{txb}
\right\} \\
\end{align*}
\caption{Functions on Tx Inputs and Outputs}
\label{fig:functions:insouts}
\end{figure}
\textbf{Value Operations and Partial Order.}
Some of the UTxO update and precondition functions now operate on the $\Value$
type instead of $\Coin$ (sometimes on a combination of $\Value$ and $\Coin$).
To make this precise, we must define basic operations on $\Value$, which
include, most notably, addition and $\leq$ comparison.
The type $\Value$ has a partial order defined on it in (see~\cite{plutus_eutxo}).
The idea of this partial order, as well as operations like addition and subtraction
of terms of the $\Value$ type, is that a term $v \in \Value$ can be treated
as a total map that maps to the trivial element $\epsilon \in \Token \to \Quantity$
almost everywhere except for a several currency IDs that appear in $\dom~v$.
This way, when adding two terms of type value, $\{ cid1 \mapsto tkns1\}$ and
$\{ cid2 \mapsto tkns2\}$, the result is
\[ \{ cid1 \mapsto (tkns1 + \epsilon), cid2 \mapsto (\epsilon + tkns2)\} \]
which simplifies to
\[ \{ cid1 \mapsto tkns1, cid2 \mapsto tkns2\} \]
This definition of addition is also defined in Section~\ref{sec:notation-shelley}.
Similarly, if we compare these two tokens, we compare them as follows
(element-wise, with $\epsilon$ as the value associated to any currency ID
not present in on of the values),
\[ (\{ cid1 \mapsto tkns1\}~\leq~\{ cid2 \mapsto tkns2\}) \Leftrightarrow \\
(tkns1 \leq \epsilon~\wedge~ \epsilon \leq tkns2) \]
\textbf{UTxO Helper Functions.}
Figure~\ref{fig:functions:utxo} defines additional calculations needed for the
UTxO transition system with MC:
\begin{itemize}
\item $\fun{getCoin}$ adds up all the Ada in a given output and returns it as a
$\Coin$ value
\item $\fun{utxoAda}$ returns the set of all the outputs in a UTxO with only Ada
tokens (the other tokens are ignored). This is used in the stake distribution
calculation at the epoch boundary
\item
The $\fun{ubalance}$ function calculates the (aggregated by currency ID and
Token) sum total of all the value in a given UTxO.
\item The $\fun{consumed}$ calculation is still the sum of the reward address
value consumed, the values of the UTxO entries consumed,
and the value consumed from the deposit pot due
to the transaction collecting deposit refunds. There is an additional
summand in this calculation, the value forged by a transaction.
This calculation now returns a $\Value$.
\item The $\fun{produced}$ calculation sums up the same things
as the corresponding $\fun{produced}$ calculation in Shelley.
This calculation also returns a $\Value$.
\end{itemize}
\textbf{Produced and Consumed Calculations and Preservation of Value.}
Note that
the $\fun{consumed}$ and $\fun{produced}$ calculations both produce a $\Value$.
The reason for this is that the outputs of a transaction, as well as UTxO outputs,
are of the $\Value$ type. The administrative amounts (of the $\Coin$ type)
are converted into MC values for these summations.
While the preservation of value is a single
equality, it is really a comparison of token quantities aggregated by
$\Token$ and by $\CurrencyID$. In particular, ensuring that the produced
amount equals the consumed amount also implies that the total quantity of
Ada tokens is preserved.
\textbf{Forging and the Preservation of Value.}
What does it mean to preserve the value of non-Ada tokens, since they
are put in and taken out of circulation by the users themselves?
This is expressed by including the $\fun{forge}$ value of the transaction
in the preservation of value equation.
The \textit{produced} side of the equation adds up, among other things, the
values in the
outputs that will be added to the ledger UTxO by the transaction. These outputs are
where the
forged value is "put into of circulation", i.e. how it ends up in the UTxO.
Suppose a transaction $tx$ contains a single output $(a, cid \mapsto tkns)$. Suppose
also that it does not
have any inputs spending any UTxO outputs with currency ID $cid$.
A valid transaction $tx$ satisfies the preservation of value
condition by adding the value $cid \mapsto tkns$ to the \textit{consumed} side as well.
To do this, the $tx$ declares that it is forging the tokens $cid \mapsto tkns$
via the $\fun{forge}$ field, i.e. $tx$ must have
\[cid \mapsto tkns\in\fun{forge}~tx\]
The forge field value is then added to the consumed side. This approach
to balancing the POV equation extends
to cases where the transaction might also be consuming some existing $cid$ tokens,
or taking the out of circulation with negative quantities in the forge field.
The forge field value represents the change in total existing tokens of each given currency
as a result of processing the transaction. It is always added to the
\textit{consumed} side of the POV equation because of this side, the signs of the
quantities in the forge field match the signs of the change. That is,
when tokens are added into the UTxO, their quantities are positive, and when they are
taken out of circulation via the forge field, the signs are negative.
Note also that the UTXO rule only checks that the transaction is forging the
amount it has declared using the forge field (and that no Ada is forged).
The forging scripts themselves are not evaluated in this transition rule.
That step is part of witnessing, i.e. the UTXOW rule, see below.
\begin{figure}[htb]
\emph{Helper Functions}
\begin{align*}
& \fun{getCoin} \in \UTxOOut \to \Coin \\
& \fun{getCoin}~{\var{out}} ~=~\sum_{\mathsf{adaID} \mapsto tkns \in \fun{getValue}~out}
(\sum_{q \in \range~{tkns}} \fun{co}~q) \\
& \text{sum total of amount of Ada in an output}
\nextdef
& \fun{utxoAda} \in \UTxO \to \powerset{(\Addr \times \Coin)} \\
& \fun{utxoAda}~{\var{utxo}} ~=~\{~(\fun{getAddr}~\var{out},~\fun{getCoin}~{out})
~\vert~ \var{out} \in \range~\var{utxo} ~\} \\
& \text{returns the outputs in the UTxO with only the Ada coins} \\
\nextdef
& \fun{ubalance} \in \UTxO \to \Value \\
& \fun{ubalance} ~ utxo = \sum_{\wcard\mapsto\var{u}\in~\var{utxo}}
\fun{getValue}~\var{u} \\
& \text{UTxO balance} \\
\end{align*}
%
\emph{Produced and Consumed Calculations}
\begin{align*}
& \fun{consumed} \in \PParams \to \UTxO \to \StakeCreds \to \Wdrl \to \TxBody \to \Value \\
& \consumed{pp}{utxo}{stkCreds}{rewards}~{txb} = \\
& ~~\ubalance{(\txins{txb} \restrictdom \var{utxo})} + \\
&~~ \fun{coinToValue}(\fun{wbalance}~(\fun{txwdrls}~{txb})~\\
&~~+~ \keyRefunds{pp}{stkCreds}{txb}) +
~\fun{forge}~\var{txb} \\
& \text{value consumed} \\
\nextdef
& \fun{produced} \to \PParams \to \StakePools \to \TxBody \to \Value \\
& \fun{produced}~\var{pp}~\var{stpools}~\var{txb} = \\
&~~\ubalance{(\fun{outs}~{txb})} + \fun{coinToValue}(\txfee{txb} \\
&~~+ \deposits{pp}{stpools}~{(\txcerts{txb})})\\
& \text{value produced} \\
\end{align*}
\caption{UTxO Calculations}
\label{fig:functions:utxo}
\end{figure}
\clearpage
\textbf{The UTXO Transition Rule.}
In Figure \ref{fig:rules:utxo-shelley}, we give the UTXO transition rule,
updated for MC support. There are the following changes to the preconditions
of this rule as compared to the original Shelley UTXO rule:
\begin{itemize}
\item The transaction is not forging any Ada
\item All outputs of the transaction contain only non-negative quantities
(this is the $\Value$-type version to the corresponding rule about non-negative
$\Coin$ amounts in the Shelley ledger rules)
\item In the preservation of value calculation (which looks the same as in
Shelly), the value in the $\fun{forge}$ field is taken into account
\end{itemize}
Note that updating the $\UTxO$ with the inputs and the outputs of the transaction
looks the same as in the Shelley rule, however, there is a type-level difference.
Recall that the outputs of a transaction contain a $\Value$ term, rather than
$\Coin$. Moreover, the $\fun{outs}$ map converts $\TxOut$ terms into $\UTxOOut$.
\begin{figure}[htb]
\begin{equation}\label{eq:utxo-inductive-shelley}
\inference[UTxO-inductive]
{ \var{txb}\leteq\txbody{tx}
& \txttl txb \geq \var{slot}
\\ \txins{txb} \neq \emptyset
& \minfee{pp}{tx} \leq \txfee{txb}
& \txins{txb} \subseteq \dom \var{utxo}
\\
\consumed{pp}{utxo}{stkCreds}{rewards}~{txb} = \produced{pp}{stpools}~{txb}
\\
~
\\
{
\begin{array}{r}
\var{slot} \\
\var{pp} \\
\var{genDelegs} \\
\end{array}
}
\vdash \var{ups} \trans{\hyperref[fig:rules:update]{up}}{\fun{txup}~\var{tx}} \var{ups'}
\\
~
\\
\mathsf{adaID}~\notin \dom~{\fun{forge}~tx} \\
\forall txout \in \txouts{txb}, ~ \fun{getValue}~txout ~\geq ~ \epsilon \\~
\\
\fun{txsize}~{tx}\leq\fun{maxTxSize}~\var{pp}
\\
~
\\
\var{refunded} \leteq \keyRefunds{pp}{stkCreds}~{txb}
\\
\var{decayed} \leteq \decayedTx{pp}{stkCreds}~{txb}
\\
\var{depositChange} \leteq
\fun{totalDeposits}~{pp}{stpools}{(\txcerts{txb})} - (\var{refunded} + \var{decayed})
}
{
\begin{array}{r}
\var{slot}\\
\var{pp}\\
\var{stkCreds}\\
\var{stpools}\\
\var{genDelegs}\\
\end{array}
\vdash
\left(
\begin{array}{r}
\var{utxo} \\
\var{deposits} \\
\var{fees} \\
\var{ups}\\
\end{array}
\right)
\trans{utxo}{tx}
\left(
\begin{array}{r}
\varUpdate{(\txins{txb} \subtractdom \var{utxo}) \cup \fun{outs}{txb}} \\
\varUpdate{\var{deposits} + \var{depositChange}} \\
\varUpdate{\var{fees} + \txfee{txb} + \var{decayed}} \\
\varUpdate{ups'}\\
\end{array}
\right)
}
\end{equation}
\caption{UTxO inference rules}
\label{fig:rules:utxo-shelley}
\end{figure}
\clearpage
\textbf{Witnessing.}
We have changed the definition of the function
$\fun{scriptsNeeded}$, see Figure~\ref{fig:functions-witnesses}. There is
now an additional category of scripts that are needed for transaction validation,
the forging scripts.
Note that there are no restrictions on the use of forging scripts. Their hashes may
be used as credentials in UTxO entries, certificates, and withdrawals.
Non-MPS type scripts can also be used for forging, e.g. MSig scripts.
Note also that UTxO entries containing MC tokens, just like Shelley UTxO entries,
can be locked by a script. This script will add an additional set of
restrictions to the use of MC tokens (additional to the forging script
requirements, but enforced at spending time). This output-locking script can itself
also be a forging script.
\begin{figure}[htb]
\begin{align*}
& \hspace{-1cm}\fun{scriptsNeeded} \in \UTxO \to \Tx \to
\powerset{\ScriptHash}
& \text{required script hashes} \\
& \hspace{-1cm}\fun{scriptsNeeded}~\var{utxo}~\var{tx} = \\
& ~~\{ \fun{validatorHash}~a \mid i \mapsto (a, \wcard) \in \var{utxo},\\
& ~~~~~i\in\fun{txinsScript}~{(\fun{txins~\var{txb}})}~{utxo}\} \\
\cup & ~~\{ \fun{stakeCred_{r}}~\var{a} \mid a \in \dom (\AddrRWDScr
\restrictdom \fun{txwdrls}~\var{txb}) \} \\
\cup & ~~(\AddrScr \cap \fun{certWitsNeeded}~{txb}) \\
\cup & ~~\dom~(\fun{forge}~{txb}) \\
& \where \\
& ~~~~~~~ \var{txb}~=~\txbody{tx} \\
\end{align*}
\caption{Scripts Needed}
\label{fig:functions-witnesses}
\end{figure}
\clearpage
|
If $A$ is a measurable set in the completion of a measure space $M$, then there exists a measurable set $A'$ in $M$ such that $A \subseteq A'$, $A' - A$ is a null set in the completion of $M$, and the measure of $A$ in the completion of $M$ is equal to the measure of $A'$ in $M$. |
[STATEMENT]
lemma subst_compose_fv':
fixes \<theta> \<sigma>::"('a,'b) subst"
assumes "y \<in> fv ((\<theta> \<circ>\<^sub>s \<sigma>) x)"
shows "\<exists>z. z \<in> fv (\<theta> x)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. \<exists>z. z \<in> fv (\<theta> x)
[PROOF STEP]
using assms subst_compose_fv
[PROOF STATE]
proof (prove)
using this:
y \<in> fv ((\<theta> \<circ>\<^sub>s \<sigma>) x)
fv (?\<theta> ?x) = {} \<Longrightarrow> fv ((?\<theta> \<circ>\<^sub>s ?\<sigma>) ?x) = {}
goal (1 subgoal):
1. \<exists>z. z \<in> fv (\<theta> x)
[PROOF STEP]
by fast |
(* Property from Case-Analysis for Rippling and Inductive Proof,
Moa Johansson, Lucas Dixon and Alan Bundy, ITP 2010.
This Isabelle theory is produced using the TIP tool offered at the following website:
https://github.com/tip-org/tools
This file was originally provided as part of TIP benchmark at the following website:
https://github.com/tip-org/benchmarks
Yutaka Nagashima at CIIRC, CTU changed the TIP output theory file slightly
to make it compatible with Isabelle2017.*)
theory TIP_prop_28
imports "../../Test_Base"
begin
datatype 'a list = nil2 | cons2 "'a" "'a list"
datatype Nat = Z | S "Nat"
fun y :: "'a list => 'a list => 'a list" where
"y (nil2) y2 = y2"
| "y (cons2 z2 xs) y2 = cons2 z2 (y xs y2)"
fun x :: "Nat => Nat => bool" where
"x (Z) (Z) = True"
| "x (Z) (S z2) = False"
| "x (S x2) (Z) = False"
| "x (S x2) (S y22) = x x2 y22"
fun elem :: "Nat => Nat list => bool" where
"elem z (nil2) = False"
| "elem z (cons2 z2 xs) = (if x z z2 then True else elem z xs)"
theorem property0 :
"elem z (y xs (cons2 z (nil2)))"
oops
end
|
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2021, Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import LibraBFT.ImplShared.Consensus.Types
module LibraBFT.Impl.Crypto.Crypto.Hash where
postulate -- TODO-1: valueZero
valueZero : HashValue
|
subroutine cofrbc(j ,nmmaxj ,norow ,icx ,icy , &
& urf ,hu ,dpu ,umean ,vmean , &
& crbc ,ctbf ,ctbl ,ctif ,ctil , &
& ctrf ,ctrl ,stbf ,stbl ,stif , &
& stil ,cgdghf ,cgdghl ,zetabf ,zetabl , &
& zetaif ,zetail ,zmeanf ,zmeanl ,umeanf , &
& umeanl ,circ2d ,gvu ,wsu ,irocol , &
& timsec ,hdt ,gdp )
!----- GPL ---------------------------------------------------------------------
!
! Copyright (C) Stichting Deltares, 2011-2016.
!
! This program is free software: you can redistribute it and/or modify
! it under the terms of the GNU General Public License as published by
! the Free Software Foundation version 3.
!
! This program is distributed in the hope that it will be useful,
! but WITHOUT ANY WARRANTY; without even the implied warranty of
! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! GNU General Public License for more details.
!
! You should have received a copy of the GNU General Public License
! along with this program. If not, see <http://www.gnu.org/licenses/>.
!
! contact: [email protected]
! Stichting Deltares
! P.O. Box 177
! 2600 MH Delft, The Netherlands
!
! All indications and logos of, and references to, "Delft3D" and "Deltares"
! are registered trademarks of Stichting Deltares, and remain the property of
! Stichting Deltares. All rights reserved.
!
!-------------------------------------------------------------------------------
! $Id: cofrbc.f90 5717 2016-01-12 11:35:24Z mourits $
! $HeadURL: https://svn.oss.deltares.nl/repos/delft3d/tags/6686/src/engines_gpl/flow2d3d/packages/kernel/src/timedep/cofrbc.f90 $
!!--description-----------------------------------------------------------------
! NONE
!!--pseudo code and references--------------------------------------------------
! NONE
!!--declarations----------------------------------------------------------------
use precision
use mathconsts
use globaldata
!
implicit none
!
type(globdat),target :: gdp
!
! The following list of pointer parameters is used to point inside the gdp structure
!
integer , pointer :: nmskf
integer , pointer :: nmskl
integer , pointer :: mmskf
integer , pointer :: mmskl
real(fp) , pointer :: rhow
real(fp) , pointer :: ag
integer , pointer :: iro
!
! Global variables
!
integer :: icx
integer :: icy
integer :: j
integer :: nmmaxj ! Description and declaration in dimens.igs
integer :: norow ! Description and declaration in esm_alloc_int.f90
integer, dimension(5, norow) :: irocol ! Description and declaration in esm_alloc_int.f90
real(fp) :: hdt ! Description and declaration in esm_alloc_real.f90
real(fp) :: timsec ! Description and declaration in inttim.igs
real(fp) :: urf
real(fp), dimension(norow) :: cgdghf ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: cgdghl ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: ctbf ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: ctbl ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: ctif ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: ctil ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: ctrf ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: ctrl ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: stbf ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: stbl ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: stif ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: stil ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: umeanf ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: umeanl ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: zetabf ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: zetabl ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: zetaif ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: zetail ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: zmeanf ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(norow) :: zmeanl ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(4, norow) :: circ2d ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(12, norow) :: crbc ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(gdp%d%nmlb:gdp%d%nmub) :: dpu ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(gdp%d%nmlb:gdp%d%nmub) :: gvu ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(gdp%d%nmlb:gdp%d%nmub) :: hu ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(gdp%d%nmlb:gdp%d%nmub) :: umean ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(gdp%d%nmlb:gdp%d%nmub) :: vmean ! Description and declaration in esm_alloc_real.f90
real(fp), dimension(gdp%d%nmlb:gdp%d%nmub) :: wsu ! Description and declaration in esm_alloc_real.f90
!
! Local variables
!
integer :: ddb
integer :: ibf
integer :: ibl
integer :: ic
integer :: icxy
integer :: mf
integer :: ml
integer :: n
integer :: nmf
integer :: nmfu
integer :: nmfuu
integer :: nml
integer :: nmld
integer :: nmldd
real(fp):: alfas
real(fp):: ctr
real(fp):: ctr0
real(fp):: depth
real(fp):: dt
real(fp):: f
real(fp):: fdenom
real(fp):: rmux
real(fp):: sepu
real(fp):: tapf
real(fp):: tau
real(fp):: temp1
real(fp):: temp2
real(fp):: temp3
real(fp):: temp4
real(fp):: urfa
real(fp):: zbfic
real(fp):: zblic
!
!! executable statements -------------------------------------------------------
!
nmskf => gdp%gdbcdat%nmskf
nmskl => gdp%gdbcdat%nmskl
mmskf => gdp%gdbcdat%mmskf
mmskl => gdp%gdbcdat%mmskl
rhow => gdp%gdphysco%rhow
ag => gdp%gdphysco%ag
iro => gdp%gdphysco%iro
!
ctr0 = cos(8.0*pi/18.0)
dt = 2.0*hdt
!
! First smoothen the angles of the reflected outgoing waves
!
if (timsec<4*hdt) then
do ic = 1, norow
ctrf(ic) = 1.0
ctrl(ic) = 1.0
enddo
endif
if (norow<2) then
temp1 = 1.0
temp3 = 1.0
else
temp1 = 0.5*(ctrf(1) + ctrf(2))
temp3 = 0.5*(ctrl(1) + ctrl(2))
endif
do ic = 2, norow - 1
temp2 = 0.25*(ctrf(ic - 1) + 2.0*ctrf(ic) + ctrf(ic + 1))
temp4 = 0.25*(ctrl(ic - 1) + 2.0*ctrl(ic) + ctrl(ic + 1))
ctrf(ic - 1) = temp1
ctrl(ic - 1) = temp3
temp1 = temp2
temp3 = temp4
enddo
if (norow>1) then
ctrf(norow) = 0.5*(ctrf(norow - 1) + ctrf(norow))
ctrl(norow) = 0.5*(ctrl(norow - 1) + ctrl(norow))
ctrf(norow - 1) = temp1
ctrl(norow - 1) = temp3
endif
!
icxy = max(icx, icy)
ddb = gdp%d%ddbound
!
do ic = 1, norow
n = irocol(1, ic)
mf = irocol(2, ic) - 1
ml = irocol(3, ic)
ibf = irocol(4, ic)
ibl = irocol(5, ic)
nmf = (n + ddb)*icy + (mf + ddb)*icx - icxy
nmfu = nmf + icx
nmfuu = nmfu + icx
nml = (n + ddb)*icy + (ml + ddb)*icx - icxy
nmld = nml - icx
nmldd = nmld - icx
depth = hu(nmf)
if ((ibf==6 .or. ibf==2).and.depth>1.0e-6) then
!
! WEAKLY REFLECTIVE BOUNDARY CONDITION AT LEFT BOUNDARY
!
sepu = hu(nmf) - dpu(nmf)
urfa = urf
!
! reduction of locked incoming wave due to mask effects
! (nearly) equidistant grid assumed
!
zbfic = zetabf(ic)
!
! left BC
!
if (icy==1) then
if (mmskf>0) then
zbfic = 0.0
else
if (nmskf>0 .and. ic<nmskf) then
tau = real(nmskf - ic, fp)/real(nmskf, fp)
zbfic = zbfic*tapf(tau)
endif
if (nmskl>0 .and. ic>nmskl) then
tau = real(ic - nmskl, fp)/real(icx - nmskl, fp)
zbfic = zbfic*tapf(tau)
endif
endif
endif
!
! bottom BC
!
if (icx==1) then
if (nmskf>0) then
zbfic = 0.0
else
if (mmskf>0 .and. ic<mmskf) then
tau = real(mmskf - ic, fp)/real(mmskf, fp)
zbfic = zbfic*tapf(tau)
endif
if (mmskl>0 .and. ic>mmskl) then
tau = real(ic - mmskl, fp)/real(icy - mmskl, fp)
zbfic = zbfic*tapf(tau)
endif
endif
endif
!
alfas = sqrt(ag/depth)
fdenom = umean(nmf) - alfas*(sepu - zetaif(ic)*(1.0 - ctif(ic)) &
& - zbfic*(1.0 - cgdghf(ic)*ctbf(ic)))
if (abs(fdenom)>1.0E-4) then
f = (0.25*(3.0*vmean(nmfu) - vmean(nmfuu) + 3.0*vmean(nmfu - icy) &
& - vmean(nmfuu - icy)) - alfas*stif(ic)*zetaif(ic) &
& - alfas*cgdghf(ic)*stbf(ic)*zbfic)/fdenom
if (f*f<=1.0) then
ctr = (1.0 - f*f)/(1.0 + f*f)
else
ctr = 1.0
urfa = 0.0
endif
ctr = max(ctr0, ctr)
ctrf(ic) = ctrf(ic)*(1.0 - urfa) + urfa*ctr
endif
!
! In the case of tidal computations the mean waterlevel at
! the sea boundary can be prescribed through circ2d
!
if (ibf==2) then
zmeanf(ic) = circ2d(1, ic)
umeanf(ic) = 0.0
endif
crbc(1, ic) = 0.5*alfas*ctrf(ic)
crbc(2, ic) = 0.5*alfas*ctrf(ic)
crbc(3, ic) = umeanf(ic) + alfas*(zmeanf(ic)*ctrf(ic) &
& + zetaif(ic)*(ctrf(ic) + ctif(ic)) &
& + zbfic*(ctrf(ic) + cgdghf(ic)*ctbf(ic)))
!
! LAYER VELOCITIES ( VELOCITY PROFILE )
!
rmux = sqrt(ag*depth)*dt/gvu(nmf)
crbc(4, ic) = ctrf(ic) + rmux
crbc(5, ic) = ctrf(ic) - rmux
crbc(6, ic) = 2.0*zetaif(ic)*(ctrf(ic) + ctif(ic)) &
& + 2.0*zbfic*(ctrf(ic) + cgdghf(ic)*ctbf(ic)) &
& + 2.0*zmeanf(ic)*ctrf(ic) &
& - (2.0*(umean(nmf) - umeanf(ic)) + dt*wsu(nmf) &
& /rhow/depth)/alfas
endif
depth = hu(nml)
if ((ibl==6 .or. ibl==2) .and. depth>1.0e-6) then
!
! WEAKLY REFLECTIVE BOUNDARY CONDITION AT RIGHT BOUNDARY
!
sepu = hu(nml) - dpu(nml)
urfa = urf
!
! reduction of locked incoming wave due to mask strips
! (nearly) equidistant grid assumed
!
zblic = zetabl(ic)
!
! right BC
!
if (icy==1) then
if (mmskl>0) then
zblic = 0.0
else
if (nmskf>0 .and. ic<nmskf) then
tau = real(nmskf - ic, fp)/real(nmskf, fp)
zblic = zblic*tapf(tau)
endif
if (nmskl>0 .and. ic>nmskl) then
tau = real(ic - nmskl, fp)/real(icx - nmskl, fp)
zblic = zblic*tapf(tau)
endif
endif
endif
!
! top BC
!
if (icx==1) then
if (nmskl>0) then
zblic = 0.0
else
if (mmskf>0 .and. ic<mmskf) then
tau = real(mmskf - ic, fp)/real(mmskf, fp)
zblic = zblic*tapf(tau)
endif
if (mmskl>0 .and. ic>mmskl) then
tau = real(ic - mmskl, fp)/real(icy - mmskl, fp)
zblic = zblic*tapf(tau)
endif
endif
endif
!
alfas = sqrt(ag/depth)
fdenom = umean(nml) + alfas*(sepu - zetail(ic)*(1.0 - ctil(ic)) &
& - zblic*(1.0 - cgdghl(ic)*ctbl(ic)))
if (abs(fdenom)>1.0E-4) then
f = (0.25*(3.0*vmean(nml) - vmean(nmld) + 3.0*vmean(nml - icy) &
& - vmean(nmld - icy)) - alfas*stil(ic)*zetail(ic) &
& - alfas*cgdghl(ic)*stbl(ic)*zblic)/fdenom
if (f*f<=1.0) then
ctr = (1.0 - f*f)/(1.0 + f*f)
else
ctr = 1.0
urfa = 0.0
endif
ctr = max(ctr0, ctr)
ctrl(ic) = ctrl(ic)*(1.0 - urfa) + urfa*ctr
endif
!
! In the case of tidal computations the mean waterlevel at
! the sea boundary can be prescribed through circ2d
!
if (ibl==2) then
zmeanl(ic) = circ2d(2, ic)
umeanl(ic) = 0.0
endif
!
crbc(7, ic) = -0.5*alfas*ctrl(ic)
crbc(8, ic) = -0.5*alfas*ctrl(ic)
crbc(9, ic) = umeanl(ic) - alfas*(zmeanl(ic)*ctrl(ic) &
& + zetail(ic)*(ctrl(ic) + ctil(ic)) &
& + zblic*(ctrl(ic) + cgdghl(ic)*ctbl(ic)))
!
rmux = sqrt(ag*depth)*dt/gvu(nml)
crbc(10, ic) = ctrl(ic) - rmux
crbc(11, ic) = ctrl(ic) + rmux
crbc(12, ic) = 2.0*zetail(ic)*(ctrl(ic) + ctil(ic)) &
& + 2.0*zblic*(ctrl(ic) + cgdghl(ic)*ctbl(ic)) &
& + 2.0*zmeanl(ic)*ctrl(ic) &
& + (2.0*(umean(nml) - umeanl(ic)) + dt*wsu(nml) &
& /rhow/depth)/alfas
endif
enddo
end subroutine cofrbc
|
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
module Backprop.Learn.Regularize (
Regularizer
, Regularize(..)
, l1Reg
, l2Reg
, noReg
, l2RegMetric
, l1RegMetric
-- * Build instances
-- ** DerivingVia
, RegularizeMetric(..), NoRegularize(..)
-- ** Linear
, lassoLinear, ridgeLinear
-- ** Generics
, grnorm_1, grnorm_2
, glasso, gridge
-- * Manipulate regularizers
, addReg
, scaleReg
) where
import Control.Applicative
import Control.Monad.Trans.State
import Data.Ratio
import Data.Semigroup hiding (Any(..))
import Data.Type.Functor.Product
import Data.Type.Tuple
import Data.Vinyl
import GHC.Exts
import GHC.Generics
import GHC.TypeNats
import Generics.OneLiner
import Numeric.Backprop as B
import Numeric.LinearAlgebra.Static.Backprop ()
import Numeric.Opto.Update hiding ((<.>))
import qualified Data.Functor.Contravariant as Co
import qualified Data.Vector.Generic as VG
import qualified Data.Vector.Generic.Sized as SVG
import qualified Numeric.LinearAlgebra.Static as H
-- | A regularizer on parameters
type Regularizer p = forall s. Reifies s W => BVar s p -> BVar s Double
-- | A class for data types that support regularization during training.
--
-- This class is somewhat similar to @'Metric' 'Double'@, in that it
-- supports summing the components and summing squared components.
-- However, the main difference is that when summing components, we only
-- consider components that we want to regularize.
--
-- Often, this doesn't include bias terms (terms that "add" to inputs), and
-- only includes terms that "scale" inputs, like components in a weight
-- matrix of a feed-forward neural network layer.
--
-- However, if all of your components are to be regularized, you can use
-- 'norm_1', 'norm_2', 'lassoLinear', and 'ridgeLinear' as sensible
-- implementations, or use DerivingVia with 'RegularizeMetric':
--
-- @
-- data MyType = ...
-- deriving Regularize via (RegularizeMetric MyType)
-- @
--
-- You can also derive an instance where /no/ are regularized, using
-- 'NoRegularize':
--
-- @
-- data MyType = ...
-- deriving Regularize via (NoRegularize MyType)
-- @
--
-- The default implementations are based on 'Generics', and work for types
-- that are records of items that are all instances of 'Regularize'.
class Backprop p => Regularize p where
-- | Like 'norm_1': sums all of the weights in @p@, but only the
-- ones you want to regularize:
--
-- \[
-- \sum_w \lvert w \rvert
-- \]
--
-- Note that typically bias terms (terms that add to inputs) are not
-- regularized. Only "weight" terms that scale inputs are typically
-- regularized.
--
-- If @p@ is an instance of 'Metric', then you can set @'rnorm_1'
-- = 'norm_1'@. However, this would count /all/ terms in @p@, even
-- potential bias terms.
rnorm_1 :: p -> Double
default rnorm_1 :: (ADT p, Constraints p Regularize) => p -> Double
rnorm_1 = grnorm_1
-- | Like 'norm_2': sums all of the /squares/ of the weights
-- n @p@, but only the ones you want to regularize:
--
-- \[
-- \sum_w w^2
-- \]
--
-- Note that typically bias terms (terms that add to inputs) are not
-- regularized. Only "weight" terms that scale inputs are typically
-- regularized.
--
-- If @p@ is an instance of 'Metric', then you can set @'rnorm_2'
-- = 'norm_2'@. However, this would count /all/ terms in @p@, even
-- potential bias terms.
rnorm_2 :: p -> Double
default rnorm_2 :: (ADT p, Constraints p Regularize) => p -> Double
rnorm_2 = grnorm_2
-- | @'lasso' r p@ sets all regularized components (that is, components
-- summed by 'rnorm_1') in @p@ to be either @r@ if that component was
-- positive, or @-r@ if that component was negative. Behavior is not
-- defined if the component is exactly zero, but either @r@ or @-r@ are
-- sensible possibilities.
--
-- It must set all /non-regularized/ components (like bias terms, or
-- whatever items that 'rnorm_1' ignores) to zero.
--
-- If @p@ is an instance of @'Linear' 'Double'@ and 'Num', then you can set
-- @'lasso' = 'lassoLinear'@. However, this is only valid if 'rnorm_1'
-- counts /all/ terms in @p@, including potential bias terms.
lasso :: Double -> p -> p
default lasso :: (ADT p, Constraints p Regularize) => Double -> p -> p
lasso = glasso
-- | @'ridge' r p@ scales all regularized components (that is,
-- components summed by 'rnorm_2') in @p@ by @r@.
--
-- It must set all /non-regularized/ components (like bias terms, or
-- whatever items that 'rnorm_2' ignores) to zero.
--
-- If @p@ is an instance of @'Linear' 'Double'@ and 'Num', then you can set
-- @'ridge' = 'ridgeLinear'@. However, this is only valid if 'rnorm_2'
-- counts /all/ terms in @p@, including potential bias terms.
ridge :: Double -> p -> p
default ridge :: (ADT p, Constraints p Regularize) => Double -> p -> p
ridge = gridge
grnorm_1 :: (ADT p, Constraints p Regularize) => p -> Double
grnorm_1 = getSum . gfoldMap @Regularize (Sum . rnorm_1)
grnorm_2 :: (ADT p, Constraints p Regularize) => p -> Double
grnorm_2 = getSum . gfoldMap @Regularize (Sum . rnorm_2)
glasso :: (ADT p, Constraints p Regularize) => Double -> p -> p
glasso r = gmap @Regularize (lasso r)
gridge :: (ADT p, Constraints p Regularize) => Double -> p -> p
gridge r = gmap @Regularize (ridge r)
-- | Backpropagatable L1 regularization; also known as lasso
-- regularization.
--
-- \[
-- \sum_w \lvert w \rvert
-- \]
--
-- Note that typically bias terms (terms that add to inputs) are not
-- regularized. Only "weight" terms that scale inputs are typically
-- regularized.
l1Reg :: Regularize p => Double -> Regularizer p
l1Reg λ = liftOp1 . op1 $ \x ->
( λ * rnorm_1 x
, (`lasso` x) . (* λ)
)
-- | Backpropagatable L2 regularization; also known as ridge
-- regularization.
--
-- \[
-- \sum_w w^2
-- \]
--
-- Note that typically bias terms (terms that add to inputs) are not
-- regularized. Only "weight" terms that scale inputs are typically
-- regularized.
l2Reg :: Regularize p => Double -> Regularizer p
l2Reg λ = liftOp1 . op1 $ \x ->
( λ * rnorm_2 x
, (`ridge` x) . (* λ)
)
-- | No regularization
noReg :: Regularizer p
noReg _ = auto 0
-- | A default implementation of 'lasso' for instances of @'Linear'
-- 'Double'@ and 'Num'. However, this is only valid if the corresponding
-- 'rnorm_1' counts /all/ terms in @p@, including potential bias terms.
lassoLinear :: (Linear Double p, Num p) => Double -> p -> p
lassoLinear r = (r .*) . signum
-- | A default implementation of 'ridge' for instances of @'Linear'
-- 'Double'@. However, this is only valid if the corresponding
-- 'rnorm_2' counts /all/ terms in @p@, including potential bias terms.
ridgeLinear :: Linear Double p => Double -> p -> p
ridgeLinear = (.*)
-- | L2 regularization for instances of 'Metric'. This will count
-- all terms, including any potential bias terms.
--
-- You can always use this as a regularizer instead of 'l2Reg', if you want
-- to ignore the default behavior for a type, or if your type has no
-- instance.
--
-- This is what 'l2Reg' would be for a type @p@ if you declare an instance
-- of 'Regularize' with @'rnorm_2' = 'norm_2'@, and @'ridge'
-- = 'ridgeLinear'@.
l2RegMetric
:: (Metric Double p, Backprop p)
=> Double -- ^ scaling factor (often 0.5)
-> Regularizer p
l2RegMetric λ = liftOp1 . op1 $ \x ->
( λ * quadrance x, (.* x) . (* λ))
-- | L1 regularization for instances of 'Metric'. This will count
-- all terms, including any potential bias terms.
--
-- You can always use this as a regularizer instead of 'l2Reg', if you want
-- to ignore the default behavior for a type, or if your type has no
-- instance.
--
-- This is what 'l1Reg' would be for a type @p@ if you declare an instance
-- of 'Regularize' with @'rnorm_1' = 'norm_1'@, and @'lasso'
-- = 'lassoLinear'@.
l1RegMetric
:: (Num p, Metric Double p, Backprop p)
=> Double -- ^ scaling factor (often 0.5)
-> Regularizer p
l1RegMetric λ = liftOp1 . op1 $ \x ->
( λ * norm_1 x, (.* signum x) . (* λ)
)
-- | Add together two regularizers
addReg :: Regularizer p -> Regularizer p -> Regularizer p
addReg f g x = f x + g x
-- | Scale a regularizer's influence
scaleReg :: Double -> Regularizer p -> Regularizer p
scaleReg λ reg = (* auto λ) . reg
-- | Newtype wrapper (meant to be used with DerivingVia) to derive an
-- instance of 'Regularize' that uses its 'Metric' instance, and
-- regularizes every component of a data type, including any potential bias
-- terms.
newtype RegularizeMetric a = RegularizeMetric a
deriving (Show, Eq, Ord, Read, Generic, Functor, Backprop)
instance (Metric Double p, Num p, Backprop p) => Regularize (RegularizeMetric p) where
rnorm_1 = coerce $ norm_1 @_ @p
rnorm_2 = coerce $ norm_2 @_ @p
lasso = coerce $ lassoLinear @p
ridge = coerce $ ridgeLinear @p
-- | Newtype wrapper (meant to be used with DerivingVia) to derive an
-- instance of 'Regularize' that does not regularize any part of the type.
newtype NoRegularize a = NoRegularize a
deriving (Show, Eq, Ord, Read, Generic, Functor, Backprop)
instance Backprop a => Regularize (NoRegularize a) where
rnorm_1 _ = 0
rnorm_2 _ = 0
lasso _ = B.zero
ridge _ = B.zero
instance Regularize Double where
rnorm_1 = id
rnorm_2 = (** 2)
lasso r = (r *) . signum
ridge = (*)
instance Regularize Float where
rnorm_1 = realToFrac
rnorm_2 = (** 2) . realToFrac
lasso r = (realToFrac r *) . signum
ridge = (*) . realToFrac
instance Integral a => Regularize (Ratio a) where
rnorm_1 = realToFrac
rnorm_2 = (** 2) . realToFrac
lasso r = (realToFrac r *) . signum
ridge = (*) . realToFrac
instance Regularize () where
rnorm_1 _ = 0
rnorm_2 _ = 0
lasso _ _ = ()
ridge _ _ = ()
instance (Regularize a, Regularize b) => Regularize (a, b)
instance (Regularize a, Regularize b, Regularize c) => Regularize (a, b, c)
instance (Regularize a, Regularize b, Regularize c, Regularize d) => Regularize (a, b, c, d)
instance (Regularize a, Regularize b, Regularize c, Regularize d, Regularize e) => Regularize (a, b, c, d, e)
instance (Regularize a, Regularize b) => Regularize (a :# b)
instance Regularize a => Regularize (TF a)
instance (RPureConstrained Regularize as, ReifyConstraint Backprop TF as, RMap as, RApply as, RFoldMap as) => Regularize (Rec TF as) where
rnorm_1 = getSum
. rfoldMap getConst
. rzipWith coerce (rpureConstrained @Regularize (Co.Op rnorm_1))
rnorm_2 = getSum
. rfoldMap getConst
. rzipWith coerce (rpureConstrained @Regularize (Co.Op rnorm_2))
lasso r = rzipWith coerce (rpureConstrained @Regularize (Endo (lasso r)))
ridge r = rzipWith coerce (rpureConstrained @Regularize (Endo (ridge r)))
instance (PureProdC Maybe Backprop as, PureProdC Maybe Regularize as) => Regularize (PMaybe TF as) where
rnorm_1 = getSum
. foldMapProd getConst
. zipWithProd coerce (pureProdC @_ @Regularize (Co.Op rnorm_1))
rnorm_2 = getSum
. foldMapProd getConst
. zipWithProd coerce (pureProdC @_ @Regularize (Co.Op rnorm_2))
lasso r = zipWithProd coerce (pureProdC @_ @Regularize (Endo (lasso r)))
ridge r = zipWithProd coerce (pureProdC @_ @Regularize (Endo (ridge r)))
instance (VG.Vector v a, Regularize a, Backprop (SVG.Vector v n a)) => Regularize (SVG.Vector v n a) where
rnorm_1 = (`execState` 0) . SVG.mapM_ (modify . (+) . rnorm_1)
rnorm_2 = (`execState` 0) . SVG.mapM_ (modify . (+) . rnorm_2)
lasso r = SVG.map (lasso r)
ridge r = SVG.map (ridge r)
deriving via (RegularizeMetric (H.R n)) instance KnownNat n => Regularize (H.R n)
deriving via (RegularizeMetric (H.L n m)) instance (KnownNat n, KnownNat m) => Regularize (H.L n m)
|
State Before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ 1 < a⁻¹ ↔ a < 1 State After: no goals Tactic: rw [← mul_lt_mul_iff_left a, mul_inv_self, mul_one] |
lemma compact_diff: "\<lbrakk>compact S; open T\<rbrakk> \<Longrightarrow> compact(S - T)" |
! { dg-do compile }
!
! PR fortran/51448
!
! Contribued by François Willot
!
PROGRAM MAIN
IMPLICIT NONE
TYPE mytype
REAL b(2)
END TYPE mytype
TYPE(mytype) a
DOUBLE PRECISION, ALLOCATABLE :: x(:)
ALLOCATE(x(2))
a%b=0.0E0
x=a%b
END
|
module EquationalTheory where
open import Library
open import Syntax
open import RenamingAndSubstitution
-- Single collapsing substitution.
sub1 : ∀{Γ σ τ} → Tm Γ σ → Tm (Γ , σ) τ → Tm Γ τ
sub1 {Γ}{σ}{τ} u t = sub (subId , u) t
-- Typed β-η-equality.
data _≡βη_ {Γ : Cxt} : ∀{σ} → Tm Γ σ → Tm Γ σ → Set where
-- Axioms.
beta≡ : ∀{σ τ} {t : Tm (Γ , σ) τ} {u : Tm Γ σ} →
--------------------------
app (abs t) u ≡βη sub1 u t
eta≡ : ∀{σ τ} (t : Tm Γ (σ ⇒ τ)) →
-------------------------------------
abs (app (weak _ t) (var zero)) ≡βη t
-- Congruence rules.
var≡ : ∀{σ} (x : Var Γ σ) →
---------------
var x ≡βη var x
abs≡ : ∀{σ τ}{t t' : Tm (Γ , σ) τ} →
t ≡βη t' →
----------------
abs t ≡βη abs t'
app≡ : ∀{σ τ}{t t' : Tm Γ (σ ⇒ τ)}{u u' : Tm Γ σ} →
t ≡βη t' → u ≡βη u' →
---------------------
app t u ≡βη app t' u'
-- Equivalence rules.
refl≡ : ∀{a} (t {t'} : Tm Γ a) →
t ≡ t' →
-------
t ≡βη t'
sym≡ : ∀{a}{t t' : Tm Γ a}
(t'≡t : t' ≡βη t) →
-----------------
t ≡βη t'
trans≡ : ∀{a}{t₁ t₂ t₃ : Tm Γ a}
(t₁≡t₂ : t₁ ≡βη t₂) (t₂≡t₃ : t₂ ≡βη t₃) →
----------------------------------
t₁ ≡βη t₃
-- A calculation on renamings needed for renaming of eta≡.
ren-eta≡ : ∀ {Γ Δ a b} (t : Tm Γ (a ⇒ b)) (ρ : Ren Δ Γ) →
ren (wkr ρ , zero) (ren (wkr renId) t) ≡ ren (wkr {σ = a} renId) (ren ρ t)
ren-eta≡ t ρ = begin
ren (wkr ρ , zero) (ren (wkr renId) t) ≡⟨ sym (rencomp _ _ _) ⟩
ren (renComp (wkr ρ , zero) (wkr renId)) t ≡⟨ cong (λ ρ₁ → ren ρ₁ t) (lemrr _ _ _) ⟩
ren (renComp (wkr ρ) renId) t ≡⟨ cong (λ ρ₁ → ren ρ₁ t) (ridr _) ⟩
ren (wkr ρ) t ≡⟨ cong (λ ρ₁ → ren ρ₁ t) (cong wkr (sym (lidr _))) ⟩
ren (wkr (renComp renId ρ)) t ≡⟨ cong (λ ρ₁ → ren ρ₁ t) (sym (wkrcomp _ _)) ⟩
ren (renComp (wkr renId) ρ) t ≡⟨ rencomp _ _ _ ⟩
ren (wkr renId) (ren ρ t) ∎ where open ≡-Reasoning
-- Definitional equality is closed under renaming.
ren≡βη : ∀{Γ a} {t : Tm Γ a}{t' : Tm Γ a} → t ≡βη t' → ∀{Δ}(ρ : Ren Δ Γ) →
ren ρ t ≡βη ren ρ t'
ren≡βη (beta≡ {t = t}{u = u}) ρ = trans≡ beta≡ $ refl≡ _ $
trans (subren (subId , ren ρ u) (liftr ρ) t)
(trans (cong (λ xs → sub xs t)
(cong₂ Sub._,_
(trans (lemsr subId (ren ρ u) ρ)
(trans (sidl (ren2sub ρ)) (sym $ sidr (ren2sub ρ))))
(ren2subren ρ u)))
(sym $ rensub ρ (subId , u) t))
-- TODO: factor out reasoning about renamings and substitutions
ren≡βη (eta≡ {a} t) ρ rewrite ren-eta≡ t ρ = eta≡ (ren ρ t)
-- OLD:
-- ren≡βη (eta≡ t) ρ = trans≡
-- (abs≡ (app≡ (refl≡ _
-- (trans (sym $ rencomp (liftr ρ) (wkr renId) t)
-- (trans (cong (λ xs → ren xs t)
-- (trans (lemrr (wkr ρ) zero renId)
-- (trans (ridr (wkr ρ))
-- (trans (cong wkr (sym (lidr ρ)))
-- (sym (wkrcomp renId ρ))))))
-- (rencomp (wkr renId) ρ t))))
-- (refl≡ _)))
-- (eta≡ _)
ren≡βη (var≡ x) ρ = var≡ (lookr ρ x)
ren≡βη (abs≡ p) ρ = abs≡ (ren≡βη p (liftr ρ))
ren≡βη (app≡ p q) ρ = app≡ (ren≡βη p ρ) (ren≡βη q ρ)
ren≡βη (refl≡ _ refl) ρ = refl≡ _ refl
ren≡βη (sym≡ p) ρ = sym≡ (ren≡βη p ρ)
ren≡βη (trans≡ p q) ρ = trans≡ (ren≡βη p ρ) (ren≡βη q ρ)
|
! { dg-do compile }
!
! PR 71894: [OOP] ICE in gfc_add_component_ref, at fortran/class.c:227
!
! Contributed by Gerhard Steinmetz <[email protected]>
subroutine s1
type t
integer :: n
end type
type(t) :: x
class(t) :: y ! { dg-error "must be dummy, allocatable or pointer" }
x = y
end
subroutine s2
type t
end type
class(t) :: x ! { dg-error "must be dummy, allocatable or pointer" }
class(t), allocatable :: y
select type (y)
type is (t)
y = x
end select
end
|
Formal statement is: lemma isUCont_def: "isUCont f \<longleftrightarrow> (\<forall>r>0. \<exists>s>0. \<forall>x y. dist x y < s \<longrightarrow> dist (f x) (f y) < r)" Informal statement is: A function $f$ is uniformly continuous if and only if for every $\epsilon > 0$, there exists $\delta > 0$ such that for all $x, y \in \mathbb{R}$, if $|x - y| < \delta$, then $|f(x) - f(y)| < \epsilon$. |
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
inst✝³ : SMul M α
inst✝² : SMul M β
inst✝¹ : SMul N α
inst✝ : SMul N β
a : M
b : α
c : β
x : α ⊕ β
⊢ swap (a • x) = a • swap x
[PROOFSTEP]
cases x
[GOAL]
case inl
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
inst✝³ : SMul M α
inst✝² : SMul M β
inst✝¹ : SMul N α
inst✝ : SMul N β
a : M
b : α
c : β
val✝ : α
⊢ swap (a • inl val✝) = a • swap (inl val✝)
[PROOFSTEP]
rfl
[GOAL]
case inr
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
inst✝³ : SMul M α
inst✝² : SMul M β
inst✝¹ : SMul N α
inst✝ : SMul N β
a : M
b : α
c val✝ : β
⊢ swap (a • inr val✝) = a • swap (inr val✝)
[PROOFSTEP]
rfl
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
inst✝⁶ : SMul M α
inst✝⁵ : SMul M β
inst✝⁴ : SMul N α
inst✝³ : SMul N β
a✝ : M
b✝ : α
c : β
x✝ : α ⊕ β
inst✝² : SMul M N
inst✝¹ : IsScalarTower M N α
inst✝ : IsScalarTower M N β
a : M
b : N
x : α ⊕ β
⊢ (a • b) • x = a • b • x
[PROOFSTEP]
cases x
[GOAL]
case inl
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
inst✝⁶ : SMul M α
inst✝⁵ : SMul M β
inst✝⁴ : SMul N α
inst✝³ : SMul N β
a✝ : M
b✝ : α
c : β
x : α ⊕ β
inst✝² : SMul M N
inst✝¹ : IsScalarTower M N α
inst✝ : IsScalarTower M N β
a : M
b : N
val✝ : α
⊢ (a • b) • inl val✝ = a • b • inl val✝
case inr
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
inst✝⁶ : SMul M α
inst✝⁵ : SMul M β
inst✝⁴ : SMul N α
inst✝³ : SMul N β
a✝ : M
b✝ : α
c : β
x : α ⊕ β
inst✝² : SMul M N
inst✝¹ : IsScalarTower M N α
inst✝ : IsScalarTower M N β
a : M
b : N
val✝ : β
⊢ (a • b) • inr val✝ = a • b • inr val✝
[PROOFSTEP]
exacts [congr_arg inl (smul_assoc _ _ _), congr_arg inr (smul_assoc _ _ _)]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
inst✝⁵ : SMul M α
inst✝⁴ : SMul M β
inst✝³ : SMul N α
inst✝² : SMul N β
a✝ : M
b✝ : α
c : β
x✝ : α ⊕ β
inst✝¹ : SMulCommClass M N α
inst✝ : SMulCommClass M N β
a : M
b : N
x : α ⊕ β
⊢ a • b • x = b • a • x
[PROOFSTEP]
cases x
[GOAL]
case inl
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
inst✝⁵ : SMul M α
inst✝⁴ : SMul M β
inst✝³ : SMul N α
inst✝² : SMul N β
a✝ : M
b✝ : α
c : β
x : α ⊕ β
inst✝¹ : SMulCommClass M N α
inst✝ : SMulCommClass M N β
a : M
b : N
val✝ : α
⊢ a • b • inl val✝ = b • a • inl val✝
case inr
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
inst✝⁵ : SMul M α
inst✝⁴ : SMul M β
inst✝³ : SMul N α
inst✝² : SMul N β
a✝ : M
b✝ : α
c : β
x : α ⊕ β
inst✝¹ : SMulCommClass M N α
inst✝ : SMulCommClass M N β
a : M
b : N
val✝ : β
⊢ a • b • inr val✝ = b • a • inr val✝
[PROOFSTEP]
exacts [congr_arg inl (smul_comm _ _ _), congr_arg inr (smul_comm _ _ _)]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
inst✝⁷ : SMul M α
inst✝⁶ : SMul M β
inst✝⁵ : SMul N α
inst✝⁴ : SMul N β
a✝ : M
b : α
c : β
x✝ : α ⊕ β
inst✝³ : SMul Mᵐᵒᵖ α
inst✝² : SMul Mᵐᵒᵖ β
inst✝¹ : IsCentralScalar M α
inst✝ : IsCentralScalar M β
a : M
x : α ⊕ β
⊢ MulOpposite.op a • x = a • x
[PROOFSTEP]
cases x
[GOAL]
case inl
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
inst✝⁷ : SMul M α
inst✝⁶ : SMul M β
inst✝⁵ : SMul N α
inst✝⁴ : SMul N β
a✝ : M
b : α
c : β
x : α ⊕ β
inst✝³ : SMul Mᵐᵒᵖ α
inst✝² : SMul Mᵐᵒᵖ β
inst✝¹ : IsCentralScalar M α
inst✝ : IsCentralScalar M β
a : M
val✝ : α
⊢ MulOpposite.op a • inl val✝ = a • inl val✝
case inr
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
inst✝⁷ : SMul M α
inst✝⁶ : SMul M β
inst✝⁵ : SMul N α
inst✝⁴ : SMul N β
a✝ : M
b : α
c : β
x : α ⊕ β
inst✝³ : SMul Mᵐᵒᵖ α
inst✝² : SMul Mᵐᵒᵖ β
inst✝¹ : IsCentralScalar M α
inst✝ : IsCentralScalar M β
a : M
val✝ : β
⊢ MulOpposite.op a • inr val✝ = a • inr val✝
[PROOFSTEP]
exacts [congr_arg inl (op_smul_eq_smul _ _), congr_arg inr (op_smul_eq_smul _ _)]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
inst✝⁴ : SMul M α
inst✝³ : SMul M β
inst✝² : SMul N α
inst✝¹ : SMul N β
a✝ : M
b : α
c : β
x : α ⊕ β
inst✝ : FaithfulSMul M α
m₁✝ m₂✝ : M
h : ∀ (a : α ⊕ β), m₁✝ • a = m₂✝ • a
a : α
⊢ m₁✝ • a = m₂✝ • a
[PROOFSTEP]
injection h (inl a)
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
inst✝⁴ : SMul M α
inst✝³ : SMul M β
inst✝² : SMul N α
inst✝¹ : SMul N β
a : M
b✝ : α
c : β
x : α ⊕ β
inst✝ : FaithfulSMul M β
m₁✝ m₂✝ : M
h : ∀ (a : α ⊕ β), m₁✝ • a = m₂✝ • a
b : β
⊢ m₁✝ • b = m₂✝ • b
[PROOFSTEP]
injection h (inr b)
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
m : Monoid M
inst✝¹ : MulAction M α
inst✝ : MulAction M β
x : α ⊕ β
⊢ 1 • x = x
[PROOFSTEP]
cases x
[GOAL]
case inl
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
m : Monoid M
inst✝¹ : MulAction M α
inst✝ : MulAction M β
val✝ : α
⊢ 1 • inl val✝ = inl val✝
case inr
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
m : Monoid M
inst✝¹ : MulAction M α
inst✝ : MulAction M β
val✝ : β
⊢ 1 • inr val✝ = inr val✝
[PROOFSTEP]
exacts [congr_arg inl (one_smul _ _), congr_arg inr (one_smul _ _)]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
m : Monoid M
inst✝¹ : MulAction M α
inst✝ : MulAction M β
a b : M
x : α ⊕ β
⊢ (a * b) • x = a • b • x
[PROOFSTEP]
cases x
[GOAL]
case inl
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
m : Monoid M
inst✝¹ : MulAction M α
inst✝ : MulAction M β
a b : M
val✝ : α
⊢ (a * b) • inl val✝ = a • b • inl val✝
case inr
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
β : Type u_5
γ : Type u_6
m : Monoid M
inst✝¹ : MulAction M α
inst✝ : MulAction M β
a b : M
val✝ : β
⊢ (a * b) • inr val✝ = a • b • inr val✝
[PROOFSTEP]
exacts [congr_arg inl (mul_smul _ _ _), congr_arg inr (mul_smul _ _ _)]
|
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Data.HomotopyGroup where
open import Cubical.Data.HomotopyGroup.Base public
|
proposition frontier_subset_retraction: fixes S :: "'a::euclidean_space set" assumes "bounded S" and fros: "frontier S \<subseteq> T" and contf: "continuous_on (closure S) f" and fim: "f ` S \<subseteq> T" and fid: "\<And>x. x \<in> T \<Longrightarrow> f x = x" shows "S \<subseteq> T" |
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2001-2011 Hartmut Kaiser
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#include "expression.hpp"
#include "error_handler.hpp"
#include "annotation.hpp"
#include <boost/spirit/include/phoenix_function.hpp>
#include <boost/spirit/include/lex_plain_token.hpp>
namespace client { namespace parser
{
template <typename Iterator, typename Lexer>
expression<Iterator, Lexer>::expression(
error_handler<typename Lexer::base_iterator_type, Iterator>& error_handler
, Lexer const& l)
: expression::base_type(expr), lexer(l)
{
qi::_1_type _1;
qi::_2_type _2;
qi::_3_type _3;
qi::_4_type _4;
qi::_val_type _val;
qi::tokenid_mask_type tokenid_mask;
using qi::on_error;
using qi::on_success;
using qi::fail;
using boost::phoenix::function;
typedef client::error_handler<typename Lexer::base_iterator_type, Iterator>
error_handler_type;
typedef function<error_handler_type> error_handler_function;
typedef function<client::annotation<Iterator> > annotation_function;
///////////////////////////////////////////////////////////////////////
// Main expression grammar
expr =
unary_expr
>> *(tokenid_mask(token_ids::op_binary) > unary_expr)
;
unary_expr =
primary_expr
| (tokenid_mask(token_ids::op_unary) > unary_expr)
;
primary_expr =
lexer.lit_uint
| function_call
| identifier
| lexer.true_or_false
| '(' > expr > ')'
;
function_call =
(identifier >> '(')
> argument_list
> ')'
;
argument_list = -(expr % ',');
identifier = lexer.identifier;
///////////////////////////////////////////////////////////////////////
// Debugging and error handling and reporting support.
BOOST_SPIRIT_DEBUG_NODES(
(expr)
(unary_expr)
(primary_expr)
(function_call)
(argument_list)
(identifier)
);
///////////////////////////////////////////////////////////////////////
// Error handling: on error in expr, call error_handler.
on_error<fail>(expr,
error_handler_function(error_handler)(
"Error! Expecting ", _4, _3));
///////////////////////////////////////////////////////////////////////
// Annotation: on success in primary_expr, call annotation.
on_success(primary_expr,
annotation_function(error_handler.iters)(_val, _1));
}
}}
|
import Data.Vect
data Ty = TyInt | TyBool | TyFun Ty Ty
interpTy : Ty -> Type
interpTy TyInt = Integer
interpTy TyBool = Bool
interpTy (TyFun a t) = interpTy a -> interpTy t
data HasType : (i : Fin n) -> Vect n Ty -> Ty -> Type where
Stop : HasType FZ (t :: ctxt) t
Pop : HasType k ctxt t -> HasType (FS k) (u :: ctxt) t
data Expr : Vect n Ty -> Ty -> Type where
Var : HasType i ctxt t -> Expr ctxt t
Val : (x : Integer) -> Expr ctxt TyInt
Lam : Expr (a :: ctxt) t -> Expr ctxt (TyFun a t)
App : Expr ctxt (TyFun a t) -> Expr ctxt a -> Expr ctxt t
Op : (interpTy a -> interpTy b -> interpTy c) ->
Expr ctxt a -> Expr ctxt b -> Expr ctxt c
If : Expr ctxt TyBool ->
Lazy (Expr ctxt a) ->
Lazy (Expr ctxt a) -> Expr ctxt a
data Env : Vect n Ty -> Type where
Nil : Env Nil
(::) : interpTy a -> Env ctxt -> Env (a :: ctxt)
lookup : HasType i ctxt t -> Env ctxt -> interpTy t
lookup Stop (x :: xs) = x
lookup (Pop k) (x :: xs) = lookup k xs
interp : Env ctxt -> Expr ctxt t -> interpTy t
interp env (Var i) = lookup i env
interp env (Val x) = x
interp env (Lam sc) = \x => interp (x :: env) sc
interp env (App f s) = interp env f (interp env s)
interp env (Op op x y) = op (interp env x) (interp env y)
interp env (If x t e) = if interp env x then interp env t
else interp env e
add : Expr ctxt (TyFun TyInt (TyFun TyInt TyInt))
add = Lam (Lam (Op (+) (Var Stop) (Var (Pop Stop))))
fact : Expr ctxt (TyFun TyInt TyInt)
fact = Lam (If (Op (==) (Var Stop) (Val 0))
(Val 1)
(Op (*) (App fact (Op (-) (Var Stop) (Val 1)))
(Var Stop)))
main : IO ()
main = do putStr "Enter a number: "
x <- getLine
printLn (interp [] fact (cast x))
|
Formal statement is: lemma uniformly_continuous_imp_Cauchy_continuous: fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" shows "\<lbrakk>uniformly_continuous_on S f; Cauchy \<sigma>; \<And>n. (\<sigma> n) \<in> S\<rbrakk> \<Longrightarrow> Cauchy(f \<circ> \<sigma>)" Informal statement is: If $f$ is uniformly continuous on $S$ and $\sigma$ is a Cauchy sequence in $S$, then $f \circ \sigma$ is a Cauchy sequence. |
module Serializer.Bool where
open import Data.Bool
open import Data.Fin hiding (_+_)
open import Data.Nat
open import Relation.Binary
open import Relation.Binary.EqReasoning
open import Relation.Binary.PropositionalEquality using (_≡_ ; refl ; cong ; setoid )
import Relation.Binary.Indexed as I
open import Function.Equality using (_⟶_ ; _⟨$⟩_ ; Π )
open import Function.LeftInverse hiding (_∘_)
open import Function.Injection
open import Function.Surjection
open import Function.Bijection
open import Serializer
fromBool : Bool -> Fin 2
fromBool true = zero
fromBool false = suc zero
toBool : Fin 2 -> Bool
toBool zero = true
toBool (suc x) = false
bool-cong : Setoid._≈_ (setoid Bool) I.=[ fromBool ]⇒ Setoid._≈_ (setoid (Fin 2))
bool-cong refl = refl
bool-cong-inv : Setoid._≈_ (setoid (Fin 2)) I.=[ toBool ]⇒ Setoid._≈_ (setoid (Bool))
bool-cong-inv refl = refl
from-bool-preserves-eq : setoid Bool ⟶ setoid (Fin 2)
from-bool-preserves-eq = record { _⟨$⟩_ = fromBool ; cong = bool-cong }
from-bool-injective : Injective from-bool-preserves-eq
from-bool-injective {true} {true} refl = refl
from-bool-injective {true} {false} ()
from-bool-injective {false} {true} ()
from-bool-injective {false} {false} refl = refl
bool-preserves-eq-inv : setoid (Fin 2) ⟶ setoid Bool
bool-preserves-eq-inv = record { _⟨$⟩_ = toBool ; cong = bool-cong-inv }
bool-inv : bool-preserves-eq-inv RightInverseOf from-bool-preserves-eq
bool-inv zero = refl
bool-inv (suc zero) = refl
bool-inv (suc (suc ()))
from-bool-surjective : Surjective from-bool-preserves-eq
from-bool-surjective = record { from = bool-preserves-eq-inv ; right-inverse-of = bool-inv }
bool-bijection : Bijection (setoid Bool) (setoid (Fin 2))
bool-bijection = record { to = from-bool-preserves-eq ; bijective = record { injective = from-bool-injective ; surjective = from-bool-surjective } }
instance
serializerBool : Serializer Bool
serializerBool = record {
size = 2 ;
from = fromBool ;
to = toBool ;
bijection = bool-bijection }
|
! DART software - Copyright UCAR. This open source software is provided
! by UCAR, "as is", without charge, subject to all terms of use at
! http://www.image.ucar.edu/DAReS/DART/DART_download
!
! $Id$
module location_mod
! Implements location interfaces for a two dimensional cyclic region.
! The internal representation of the location is currently implemented
! as (x, y) from 0.0 to 1.0 in both dimensions.
use types_mod, only : r8, MISSING_R8
use utilities_mod, only : register_module, error_handler, E_ERR, ascii_file_format
use random_seq_mod, only : random_seq_type, init_random_seq, random_uniform
implicit none
private
public :: location_type, get_location, set_location, &
set_location_missing, is_location_in_region, get_maxdist, &
write_location, read_location, interactive_location, query_location, &
LocationDims, LocationName, LocationLName, get_close_obs, &
get_close_maxdist_init, get_close_obs_init, get_close_type, &
operator(==), operator(/=), get_dist, get_close_obs_destroy, &
vert_is_height, vert_is_pressure, vert_is_undef, vert_is_level, &
vert_is_surface, has_vertical_localization, &
set_vert, get_vert, set_which_vert
! version controlled file description for error handling, do not edit
character(len=256), parameter :: source = &
"$URL$"
character(len=32 ), parameter :: revision = "$Revision$"
character(len=128), parameter :: revdate = "$Date$"
type location_type
private
real(r8) :: x, y
end type location_type
! Needed as stub but not used in this low-order model
type get_close_type
private
integer :: num
real(r8) :: maxdist
end type get_close_type
type(random_seq_type) :: ran_seq
logical :: ran_seq_init = .false.
logical, save :: module_initialized = .false.
integer, parameter :: LocationDims = 2
character(len = 129), parameter :: LocationName = "loc2D"
character(len = 129), parameter :: LocationLName = "twod cyclic locations: x, y"
character(len = 129) :: errstring
interface operator(==); module procedure loc_eq; end interface
interface operator(/=); module procedure loc_ne; end interface
interface set_location
module procedure set_location_single
module procedure set_location_array
end interface set_location
contains
!----------------------------------------------------------------------------
subroutine initialize_module
if (module_initialized) return
call register_module(source, revision, revdate)
module_initialized = .true.
end subroutine initialize_module
!----------------------------------------------------------------------------
function get_dist(loc1, loc2, type1, kind2)
! Return the distance between 2 locations. Since this is a periodic
! domain, the shortest distance may wrap around.
type(location_type), intent(in) :: loc1, loc2
integer, optional, intent(in) :: type1, kind2
real(r8) :: get_dist
real(r8) :: x_dif, y_dif
if ( .not. module_initialized ) call initialize_module
! Periodic domain, if distance is greater than half wraparound the other way.
x_dif = abs(loc1%x - loc2%x)
if (x_dif > 0.5_r8) x_dif = 1.0_r8 - x_dif
y_dif = abs(loc1%y - loc2%y)
if (y_dif > 0.5_r8) y_dif = 1.0_r8 - y_dif
get_dist = sqrt ( x_dif * x_dif + y_dif * y_dif)
end function get_dist
!---------------------------------------------------------------------------
function loc_eq(loc1,loc2)
! interface operator used to compare two locations.
! Returns true only if all components are 'the same' to within machine
! precision.
type(location_type), intent(in) :: loc1, loc2
logical :: loc_eq
if ( .not. module_initialized ) call initialize_module
loc_eq = .false.
if ( abs(loc1%x - loc2%x ) > epsilon(loc1%x ) ) return
if ( abs(loc1%y - loc2%y ) > epsilon(loc1%y ) ) return
loc_eq = .true.
end function loc_eq
!---------------------------------------------------------------------------
function loc_ne(loc1,loc2)
! interface operator used to compare two locations.
! Returns true if locations are not identical to machine precision.
type(location_type), intent(in) :: loc1, loc2
logical :: loc_ne
if ( .not. module_initialized ) call initialize_module
loc_ne = (.not. loc_eq(loc1,loc2))
end function loc_ne
!---------------------------------------------------------------------------
function get_location(loc)
! Given a location type, return the x, y
type(location_type), intent(in) :: loc
real(r8), dimension(2) :: get_location
if ( .not. module_initialized ) call initialize_module
get_location(1) = loc%x
get_location(2) = loc%y
end function get_location
!----------------------------------------------------------------------------
function set_location_single(x, y)
! Given an x, y pair, put the values into the location.
real(r8), intent(in) :: x, y
type (location_type) :: set_location_single
if ( .not. module_initialized ) call initialize_module
if(x < 0.0_r8 .or. x > 1.0_r8) then
write(errstring,*)'x (',x,') is not within range [0,1]'
call error_handler(E_ERR, 'set_location', errstring, source, revision, revdate)
endif
if(y < 0.0_r8 .or. y > 1.0_r8) then
write(errstring,*)'y (',y,') is not within range [0,1]'
call error_handler(E_ERR, 'set_location', errstring, source, revision, revdate)
endif
set_location_single%x = x
set_location_single%y = y
end function set_location_single
!----------------------------------------------------------------------------
function set_location_array(list)
! location semi-independent interface routine
! given 2 float numbers, call the underlying set_location routine
real(r8), intent(in) :: list(:)
type (location_type) :: set_location_array
if ( .not. module_initialized ) call initialize_module
if (size(list) < 2) then
write(errstring,*)'requires 2 input values'
call error_handler(E_ERR, 'set_location', errstring, source, revision, revdate)
endif
set_location_array = set_location_single(list(1), list(2))
end function set_location_array
!----------------------------------------------------------------------------
function set_location_missing()
! fill in the contents to a known value.
type (location_type) :: set_location_missing
if ( .not. module_initialized ) call initialize_module
set_location_missing%x = MISSING_R8
set_location_missing%y = MISSING_R8
end function set_location_missing
!---------------------------------------------------------------------------
function query_location(loc,attr)
! Returns the value of the attribute
!
type(location_type), intent(in) :: loc
character(len=*), optional, intent(in) :: attr
real(r8) :: query_location
if ( .not. module_initialized ) call initialize_module
! see the long comment in this routine in the threed_sphere
! module for warnings about compiler bugs before you change
! this code.
query_location = loc%x
if (.not. present(attr)) return
select case(attr)
case ('x','X')
query_location = loc%x
case ('y','Y')
query_location = loc%y
case default
call error_handler(E_ERR, 'query_location; twod', &
'Only x or y are legal attributes to request from location', source, revision, revdate)
end select
end function query_location
!----------------------------------------------------------------------------
subroutine write_location(locfile, loc, fform, charstring)
! Writes a 2D location to the file.
! additional functionality: if optional argument charstring is specified,
! it must be long enough to hold the string, and the location information is
! written into it instead of to a file. fform must be ascii (which is the
! default if not specified) to use this option.
integer, intent(in) :: locfile
type(location_type), intent(in) :: loc
character(len = *), intent(in), optional :: fform
character(len = *), intent(out), optional :: charstring
integer :: charlength
logical :: writebuf
! 10 format(1x,2(f22.14,1x)) ! old
10 format(1X,2(F20.16,1X))
if ( .not. module_initialized ) call initialize_module
! writing to a file (normal use) or to a character buffer?
writebuf = present(charstring)
! output file; test for ascii or binary, write what's asked, and return
if (.not. writebuf) then
if (ascii_file_format(fform)) then
write(locfile, '(''loc2D'')' )
write(locfile, 10) loc%x, loc%y
else
write(locfile) loc%x, loc%y
endif
return
endif
! you only get here if you're writing to a buffer and not
! to a file, and you can't have binary format set.
if (.not. ascii_file_format(fform)) then
call error_handler(E_ERR, 'write_location', &
'Cannot use string buffer with binary format', &
source, revision, revdate)
endif
! format the location to be more human-friendly; which in
! this case doesn't change the value.
! this must be the sum of the formats below.
charlength = 25
if (len(charstring) < charlength) then
write(errstring, *) 'charstring buffer must be at least ', charlength, ' chars long'
call error_handler(E_ERR, 'write_location', errstring, source, revision, revdate)
endif
write(charstring, '(A,F9.7,2X,F9.7)') 'X/Y: ', loc%x, loc%y
end subroutine write_location
!----------------------------------------------------------------------------
function read_location(locfile, fform)
! Reads a 2D location from locfile that was written by write_location.
! See write_location for additional discussion.
integer, intent(in) :: locfile
type(location_type) :: read_location
character(len = *), intent(in), optional :: fform
character(len=5) :: header
if ( .not. module_initialized ) call initialize_module
if (ascii_file_format(fform)) then
read(locfile, '(a5)' ) header
if(header /= 'loc2D') then
write(errstring,*)'Expected location header "loc2D" in input file, got ', header
call error_handler(E_ERR, 'read_location', errstring, source, revision, revdate)
endif
! Now read the location data value
read(locfile, *) read_location%x, read_location%y
else
read(locfile) read_location%x, read_location%y
endif
end function read_location
!--------------------------------------------------------------------------
subroutine interactive_location(location, set_to_default)
! Allows for interactive input of a location. Also gives option of selecting
! a uniformly distributed random location.
type(location_type), intent(out) :: location
logical, intent(in), optional :: set_to_default
real(r8) :: x, y
if ( .not. module_initialized ) call initialize_module
! If set_to_default is true, then just zero out and return
if(present(set_to_default)) then
if(set_to_default) then
location%x = 0.0
location%y = 0.0
return
endif
endif
write(*, *) 'Input X location for this obs: value 0 to 1 or a negative number for '
write(*, *) 'Uniformly distributed random location'
read(*, *) x
do while(x > 1.0_r8)
write(*, *) 'Input value greater than 1.0 is illegal, please try again'
read(*, *) x
end do
if(x < 0.0_r8) then
! Need to make sure random sequence is initialized
if(.not. ran_seq_init) then
call init_random_seq(ran_seq)
ran_seq_init = .TRUE.
endif
! Uniform location from 0 to 1 for this location type
location%x = random_uniform(ran_seq)
write(*, *) 'random X location is ', location%x
else
location%x = x
endif
write(*, *) 'Input Y location for this obs: value 0 to 1 or a negative number for '
write(*, *) 'Uniformly distributed random location'
read(*, *) y
do while(y > 1.0_r8)
write(*, *) 'Input value greater than 1.0 is illegal, please try again'
read(*, *) y
end do
if(y < 0.0_r8) then
! Need to make sure random sequence is initialized
if(.not. ran_seq_init) then
call init_random_seq(ran_seq)
ran_seq_init = .TRUE.
endif
! Uniform location from 0 to 1 for this location type
location%y = random_uniform(ran_seq)
write(*, *) 'random Y location is ', location%y
else
location%y = y
endif
end subroutine interactive_location
!----------------------------------------------------------------------------
subroutine get_close_obs_init(gc, num, obs)
! Initializes part of get_close accelerator that depends on the particular obs
type(get_close_type), intent(inout) :: gc
integer, intent(in) :: num
type(location_type), intent(in) :: obs(num)
! Set the value of num_obs in the structure
gc%num = num
end subroutine get_close_obs_init
!----------------------------------------------------------------------------
subroutine get_close_obs_destroy(gc)
type(get_close_type), intent(inout) :: gc
end subroutine get_close_obs_destroy
!----------------------------------------------------------------------------
subroutine get_close_maxdist_init(gc, maxdist, maxdist_list)
type(get_close_type), intent(inout) :: gc
real(r8), intent(in) :: maxdist
real(r8), intent(in), optional :: maxdist_list(:)
! Set the maximum distance in the structure
gc%maxdist = maxdist
end subroutine get_close_maxdist_init
!----------------------------------------------------------------------------
subroutine get_close_obs(gc, base_obs_loc, base_obs_type, obs, obs_kind, &
num_close, close_ind, dist)
! Default version with no smarts; no need to be smart in 1D
! Kinds are available here if one wanted to do more refined distances.
type(get_close_type), intent(in) :: gc
type(location_type), intent(in) :: base_obs_loc, obs(:)
integer, intent(in) :: base_obs_type, obs_kind(:)
integer, intent(out) :: num_close, close_ind(:)
real(r8), optional, intent(out) :: dist(:)
integer :: i
real(r8) :: this_dist
! the list of locations in the obs() argument must be the same
! as the list of locations passed into get_close_obs_init(), so
! gc%num and size(obs) better be the same. if the list changes,
! you have to destroy the old gc and init a new one.
if (size(obs) /= gc%num) then
write(errstring,*)'obs() array must match one passed to get_close_obs_init()'
call error_handler(E_ERR, 'get_close_obs', errstring, source, revision, revdate)
endif
! Return list of obs that are within maxdist and their distances
num_close = 0
do i = 1, gc%num
this_dist = get_dist(base_obs_loc, obs(i), base_obs_type, obs_kind(i))
if(this_dist <= gc%maxdist) then
! Add this ob to the list
num_close = num_close + 1
close_ind(num_close) = i
if (present(dist)) dist(num_close) = this_dist
endif
end do
end subroutine get_close_obs
!---------------------------------------------------------------------------
function get_maxdist(gc, obs_type)
type(get_close_type), intent(in) :: gc
integer, optional, intent(in) :: obs_type
real(r8) :: get_maxdist
get_maxdist = gc%maxdist
end function get_maxdist
!----------------------------------------------------------------------------
function is_location_in_region(loc, minl, maxl)
! Returns true if the given location is between the other two.
logical :: is_location_in_region
type(location_type), intent(in) :: loc, minl, maxl
if ( .not. module_initialized ) call initialize_module
! assume failure and return as soon as we are confirmed right.
! set to success only at the bottom after all tests have passed.
is_location_in_region = .false.
! FIXME: this is a doubly cyclic domain. check if min
! limit > max; if so, then wrap around.
!if (minl%x <= maxl%x) .and. ...
if ((loc%x < minl%x) .or. (loc%x > maxl%x)) return
if ((loc%y < minl%y) .or. (loc%y > maxl%y)) return
is_location_in_region = .true.
end function is_location_in_region
!----------------------------------------------------------------------------
! stubs - always say no, but allow this code to be compiled with
! common code that sometimes needs vertical info.
!----------------------------------------------------------------------------
function vert_is_undef(loc)
! Stub, always returns false.
logical :: vert_is_undef
type(location_type), intent(in) :: loc
vert_is_undef = .false.
end function vert_is_undef
!----------------------------------------------------------------------------
function vert_is_surface(loc)
! Stub, always returns false.
logical :: vert_is_surface
type(location_type), intent(in) :: loc
vert_is_surface = .false.
end function vert_is_surface
!----------------------------------------------------------------------------
function vert_is_pressure(loc)
! Stub, always returns false.
logical :: vert_is_pressure
type(location_type), intent(in) :: loc
vert_is_pressure = .false.
end function vert_is_pressure
!----------------------------------------------------------------------------
function vert_is_height(loc)
! Stub, always returns false.
logical :: vert_is_height
type(location_type), intent(in) :: loc
vert_is_height = .false.
end function vert_is_height
!----------------------------------------------------------------------------
function vert_is_level(loc)
! Stub, always returns false.
logical :: vert_is_level
type(location_type), intent(in) :: loc
vert_is_level = .false.
end function vert_is_level
!---------------------------------------------------------------------------
function has_vertical_localization()
! Always returns false since this type of location doesn't support
! vertical localization.
logical :: has_vertical_localization
if ( .not. module_initialized ) call initialize_module
has_vertical_localization = .false.
end function has_vertical_localization
!--------------------------------------------------------------------
!> dummy routine for models that don't have a vertical location
function get_vert(loc)
type(location_type), intent(in) :: loc
real(r8) :: get_vert
get_vert = 1 ! any old value
end function get_vert
!--------------------------------------------------------------------
!> dummy routine for models that don't have a vertical location
subroutine set_vert(loc, vloc)
type(location_type), intent(inout) :: loc
real(r8), intent(in) :: vloc
end subroutine set_vert
!----------------------------------------------------------------------------
!> set the which vert
subroutine set_which_vert(loc, which_vert)
type(location_type), intent(inout) :: loc
integer, intent(in) :: which_vert !< vertical coordinate type
end subroutine set_which_vert
!----------------------------------------------------------------------------
! end of location/twod/location_mod.f90
!----------------------------------------------------------------------------
end module location_mod
! <next few lines under version control, do not edit>
! $URL$
! $Id$
! $Revision$
! $Date$
|
(* *********************************************************************)
(* *)
(* The Compcert verified compiler *)
(* *)
(* Xavier Leroy, INRIA Paris-Rocquencourt *)
(* *)
(* Copyright Institut National de Recherche en Informatique et en *)
(* Automatique. All rights reserved. This file is distributed *)
(* under the terms of the INRIA Non-Commercial License Agreement. *)
(* *)
(* *********************************************************************)
(** Recognition of tail calls: correctness proof *)
Require Import Coqlib.
Require Import Maps.
Require Import AST.
Require Import Integers.
Require Import Values.
Require Import Memory.
Require Import Op.
Require Import Events.
Require Import Globalenvs.
Require Import Smallstep.
Require Import Registers.
Require Import RTL.
Require Import Conventions.
Require Import Tailcall.
Section WITHEC.
Context `{Hcc: CompilerConfiguration}.
(** * Syntactic properties of the code transformation *)
(** ** Measuring the number of instructions eliminated *)
(** The [return_measure c pc] function counts the number of instructions
eliminated by the code transformation, where [pc] is the successor
of a call turned into a tailcall. This is the length of the
move/nop/return sequence recognized by the [is_return] boolean function.
*)
Fixpoint return_measure_rec (n: nat) (c: code) (pc: node)
{struct n}: nat :=
match n with
| O => O
| S n' =>
match c!pc with
| Some(Inop s) => S(return_measure_rec n' c s)
| Some(Iop op args dst s) => S(return_measure_rec n' c s)
| _ => O
end
end.
Definition return_measure (c: code) (pc: node) :=
return_measure_rec niter c pc.
Lemma return_measure_bounds:
forall f pc, (return_measure f pc <= niter)%nat.
Proof.
intro f.
assert (forall n pc, (return_measure_rec n f pc <= n)%nat).
induction n; intros; simpl.
omega.
destruct (f!pc); try omega.
destruct i; try omega.
generalize (IHn n0). omega.
generalize (IHn n0). omega.
intros. unfold return_measure. apply H.
Qed.
Remark return_measure_rec_incr:
forall f n1 n2 pc,
(n1 <= n2)%nat ->
(return_measure_rec n1 f pc <= return_measure_rec n2 f pc)%nat.
Proof.
induction n1; intros; simpl.
omega.
destruct n2. omegaContradiction. assert (n1 <= n2)%nat by omega.
simpl. destruct f!pc; try omega. destruct i; try omega.
generalize (IHn1 n2 n H0). omega.
generalize (IHn1 n2 n H0). omega.
Qed.
Lemma is_return_measure_rec:
forall f n n' pc r,
is_return n f pc r = true -> (n <= n')%nat ->
return_measure_rec n f.(fn_code) pc = return_measure_rec n' f.(fn_code) pc.
Proof.
induction n; simpl; intros.
congruence.
destruct n'. omegaContradiction. simpl.
destruct (fn_code f)!pc; try congruence.
destruct i; try congruence.
decEq. apply IHn with r. auto. omega.
destruct (is_move_operation o l); try congruence.
destruct (Reg.eq r r1); try congruence.
decEq. apply IHn with r0. auto. omega.
Qed.
(** ** Relational characterization of the code transformation *)
(** The [is_return_spec] characterizes the instruction sequences
recognized by the [is_return] boolean function. *)
Inductive is_return_spec (f:function): node -> reg -> Prop :=
| is_return_none: forall pc r,
f.(fn_code)!pc = Some(Ireturn None) ->
is_return_spec f pc r
| is_return_some: forall pc r,
f.(fn_code)!pc = Some(Ireturn (Some r)) ->
is_return_spec f pc r
| is_return_nop: forall pc r s,
f.(fn_code)!pc = Some(Inop s) ->
is_return_spec f s r ->
(return_measure f.(fn_code) s < return_measure f.(fn_code) pc)%nat ->
is_return_spec f pc r
| is_return_move: forall pc r r' s,
f.(fn_code)!pc = Some(Iop Omove (r::nil) r' s) ->
is_return_spec f s r' ->
(return_measure f.(fn_code) s < return_measure f.(fn_code) pc)%nat ->
is_return_spec f pc r.
Lemma is_return_charact:
forall f n pc rret,
is_return n f pc rret = true -> (n <= niter)%nat ->
is_return_spec f pc rret.
Proof.
induction n; intros.
simpl in H. congruence.
generalize H. simpl.
caseEq ((fn_code f)!pc); try congruence.
intro i. caseEq i; try congruence.
intros s; intros. eapply is_return_nop; eauto. eapply IHn; eauto. omega.
unfold return_measure.
rewrite <- (is_return_measure_rec f (S n) niter pc rret); auto.
rewrite <- (is_return_measure_rec f n niter s rret); auto.
simpl. rewrite H2. omega. omega.
intros op args dst s EQ1 EQ2.
caseEq (is_move_operation op args); try congruence.
intros src IMO. destruct (Reg.eq rret src); try congruence.
subst rret. intro.
exploit is_move_operation_correct; eauto. intros [A B]. subst.
eapply is_return_move; eauto. eapply IHn; eauto. omega.
unfold return_measure.
rewrite <- (is_return_measure_rec f (S n) niter pc src); auto.
rewrite <- (is_return_measure_rec f n niter s dst); auto.
simpl. rewrite EQ2. omega. omega.
intros or EQ1 EQ2. destruct or; intros.
assert (r = rret). eapply proj_sumbool_true; eauto. subst r.
apply is_return_some; auto.
apply is_return_none; auto.
Qed.
(** The [transf_instr_spec] predicate relates one instruction in the
initial code with its possible transformations in the optimized code. *)
Inductive transf_instr_spec (f: function): instruction -> instruction -> Prop :=
| transf_instr_tailcall: forall sig ros args res s,
f.(fn_stacksize) = 0 ->
is_return_spec f s res ->
transf_instr_spec f (Icall sig ros args res s) (Itailcall sig ros args)
| transf_instr_default: forall i,
transf_instr_spec f i i.
Lemma transf_instr_charact:
forall f pc instr,
f.(fn_stacksize) = 0 ->
transf_instr_spec f instr (transf_instr f pc instr).
Proof.
intros. unfold transf_instr. destruct instr; try constructor.
caseEq (is_return niter f n r && tailcall_is_possible s &&
opt_typ_eq (sig_res s) (sig_res (fn_sig f))); intros.
destruct (andb_prop _ _ H0). destruct (andb_prop _ _ H1).
eapply transf_instr_tailcall; eauto.
eapply is_return_charact; eauto.
constructor.
Qed.
Lemma transf_instr_lookup:
forall f pc i,
f.(fn_code)!pc = Some i ->
exists i', (transf_function f).(fn_code)!pc = Some i' /\ transf_instr_spec f i i'.
Proof.
intros. unfold transf_function. destruct (zeq (fn_stacksize f) 0).
simpl. rewrite PTree.gmap. rewrite H. simpl.
exists (transf_instr f pc i); split. auto. apply transf_instr_charact; auto.
exists i; split. auto. constructor.
Qed.
(** * Semantic properties of the code transformation *)
(** ** The ``less defined than'' relation between register states *)
(** A call followed by a return without an argument can be turned
into a tail call. In this case, the original function returns
[Vundef], while the transformed function can return any value.
We account for this situation by using the ``less defined than''
relation between values and between memory states. We need to
extend it pointwise to register states. *)
Definition regset_lessdef (rs rs': regset) : Prop :=
forall r, Val.lessdef (rs#r) (rs'#r).
Lemma regset_get_list:
forall rs rs' l,
regset_lessdef rs rs' -> Val.lessdef_list (rs##l) (rs'##l).
Proof.
induction l; simpl; intros; constructor; auto.
Qed.
Lemma regset_set:
forall rs rs' v v' r,
regset_lessdef rs rs' -> Val.lessdef v v' ->
regset_lessdef (rs#r <- v) (rs'#r <- v').
Proof.
intros; red; intros. repeat rewrite PMap.gsspec. destruct (peq r0 r); auto.
Qed.
Lemma regset_init_regs:
forall params vl vl',
Val.lessdef_list vl vl' ->
regset_lessdef (init_regs vl params) (init_regs vl' params).
Proof.
induction params; intros.
simpl. red; intros. rewrite Regmap.gi. constructor.
simpl. inv H. red; intros. rewrite Regmap.gi. constructor.
apply regset_set. auto. auto.
Qed.
(** * Proof of semantic preservation *)
Section PRESERVATION.
Variable prog: program.
Let tprog := transf_program prog.
Let ge := Genv.globalenv prog.
Let tge := Genv.globalenv tprog.
Lemma symbols_preserved:
forall (s: ident), Genv.find_symbol tge s = Genv.find_symbol ge s.
Proof (Genv.find_symbol_transf transf_fundef prog).
Lemma varinfo_preserved:
forall b, Genv.find_var_info tge b = Genv.find_var_info ge b.
Proof (Genv.find_var_info_transf transf_fundef prog).
Lemma functions_translated:
forall (v: val) (f: RTL.fundef),
Genv.find_funct ge v = Some f ->
Genv.find_funct tge v = Some (transf_fundef f).
Proof (@Genv.find_funct_transf _ _ _ transf_fundef prog).
Lemma funct_ptr_translated:
forall (b: block) (f: RTL.fundef),
Genv.find_funct_ptr ge b = Some f ->
Genv.find_funct_ptr tge b = Some (transf_fundef f).
Proof (@Genv.find_funct_ptr_transf _ _ _ transf_fundef prog).
Lemma sig_preserved:
forall f, funsig (transf_fundef f) = funsig f.
Proof.
destruct f; auto. simpl. unfold transf_function.
destruct (zeq (fn_stacksize f) 0); auto.
Qed.
Lemma stacksize_preserved:
forall f, fn_stacksize (transf_function f) = fn_stacksize f.
Proof.
unfold transf_function. intros.
destruct (zeq (fn_stacksize f) 0); auto.
Qed.
Lemma find_function_translated:
forall ros rs rs' f,
find_function ge ros rs = Some f ->
regset_lessdef rs rs' ->
find_function tge ros rs' = Some (transf_fundef f).
Proof.
intros until f; destruct ros; simpl.
intros.
assert (rs'#r = rs#r).
exploit Genv.find_funct_inv; eauto. intros [b EQ].
generalize (H0 r). rewrite EQ. intro LD. inv LD. auto.
rewrite H1. apply functions_translated; auto.
rewrite symbols_preserved. destruct (Genv.find_symbol ge i); intros.
apply funct_ptr_translated; auto.
discriminate.
Qed.
(** Consider an execution of a call/move/nop/return sequence in the
original code and the corresponding tailcall in the transformed code.
The transition sequences are of the following form
(left: original code, right: transformed code).
[f] is the calling function and [fd] the called function.
<<
State stk f (Icall instruction) State stk' f' (Itailcall)
Callstate (frame::stk) fd args Callstate stk' fd' args'
. .
. .
. .
Returnstate (frame::stk) res Returnstate stk' res'
State stk f (move/nop/return seq)
.
.
.
State stk f (return instr)
Returnstate stk res
>>
The simulation invariant must therefore account for two kinds of
mismatches between the transition sequences:
- The call stack of the original program can contain more frames
than that of the transformed program (e.g. [frame] in the example above).
- The regular states corresponding to executing the move/nop/return
sequence must all correspond to the single [Returnstate stk' res']
state of the transformed program.
We first define the simulation invariant between call stacks.
The first two cases are standard, but the third case corresponds
to a frame that was eliminated by the transformation. *)
Inductive match_stackframes: list stackframe -> list stackframe -> Prop :=
| match_stackframes_nil:
match_stackframes nil nil
| match_stackframes_normal: forall stk stk' res sp pc rs rs' f,
match_stackframes stk stk' ->
regset_lessdef rs rs' ->
match_stackframes
(Stackframe res f (Vptr sp Int.zero) pc rs :: stk)
(Stackframe res (transf_function f) (Vptr sp Int.zero) pc rs' :: stk')
| match_stackframes_tail: forall stk stk' res sp pc rs f,
match_stackframes stk stk' ->
is_return_spec f pc res ->
f.(fn_stacksize) = 0 ->
match_stackframes
(Stackframe res f (Vptr sp Int.zero) pc rs :: stk)
stk'.
(** Here is the invariant relating two states. The first three
cases are standard. Note the ``less defined than'' conditions
over values and register states, and the corresponding ``extends''
relation over memory states. *)
Inductive match_states: state -> state -> Prop :=
| match_states_normal:
forall s sp pc rs m s' rs' m' f
(STACKS: match_stackframes s s')
(RLD: regset_lessdef rs rs')
(MLD: Mem.extends m m'),
match_states (State s f (Vptr sp Int.zero) pc rs m)
(State s' (transf_function f) (Vptr sp Int.zero) pc rs' m')
| match_states_call:
forall s f args m s' args' m',
match_stackframes s s' ->
Val.lessdef_list args args' ->
Mem.extends m m' ->
match_states (Callstate s f args m)
(Callstate s' (transf_fundef f) args' m')
| match_states_return:
forall s v m s' v' m',
match_stackframes s s' ->
Val.lessdef v v' ->
Mem.extends m m' ->
match_states (Returnstate s v m)
(Returnstate s' v' m')
| match_states_interm:
forall s sp pc rs m s' m' f r v'
(STACKS: match_stackframes s s')
(MLD: Mem.extends m m'),
is_return_spec f pc r ->
f.(fn_stacksize) = 0 ->
Val.lessdef (rs#r) v' ->
match_states (State s f (Vptr sp Int.zero) pc rs m)
(Returnstate s' v' m').
(** The last case of [match_states] corresponds to the execution
of a move/nop/return sequence in the original code that was
eliminated by the transformation:
<<
State stk f (move/nop/return seq) ~~ Returnstate stk' res'
.
.
.
State stk f (return instr) ~~ Returnstate stk' res'
>>
To preserve non-terminating behaviors, we need to make sure
that the execution of this sequence in the original code cannot
diverge. For this, we introduce the following complicated
measure over states, which will decrease strictly whenever
the original code makes a transition but the transformed code
does not. *)
Definition measure (st: state) : nat :=
match st with
| State s f sp pc rs m => (List.length s * (niter + 2) + return_measure f.(fn_code) pc + 1)%nat
| Callstate s f args m => 0%nat
| Returnstate s v m => (List.length s * (niter + 2))%nat
end.
Ltac TransfInstr :=
match goal with
| H: (PTree.get _ (fn_code _) = _) |- _ =>
destruct (transf_instr_lookup _ _ _ H) as [i' [TINSTR TSPEC]]; inv TSPEC
end.
Ltac EliminatedInstr :=
match goal with
| H: (is_return_spec _ _ _) |- _ => inv H; try congruence
| _ => idtac
end.
(** The proof of semantic preservation, then, is a simulation diagram
of the ``option'' kind. *)
Lemma transf_step_correct:
forall s1 t s2, step ge s1 t s2 ->
forall s1' (MS: match_states s1 s1'),
(exists s2', step tge s1' t s2' /\ match_states s2 s2')
\/ (measure s2 < measure s1 /\ t = E0 /\ match_states s2 s1')%nat.
Proof.
induction 1; intros; inv MS; EliminatedInstr.
(* nop *)
TransfInstr. left. econstructor; split.
eapply exec_Inop; eauto. constructor; auto.
(* eliminated nop *)
assert (s0 = pc') by congruence. subst s0.
right. split. simpl. omega. split. auto.
econstructor; eauto.
(* op *)
TransfInstr.
assert (Val.lessdef_list (rs##args) (rs'##args)). apply regset_get_list; auto.
exploit eval_operation_lessdef; eauto.
intros [v' [EVAL' VLD]].
left. exists (State s' (transf_function f) (Vptr sp0 Int.zero) pc' (rs'#res <- v') m'); split.
eapply exec_Iop; eauto. rewrite <- EVAL'.
apply eval_operation_preserved. exact symbols_preserved.
econstructor; eauto. apply regset_set; auto.
(* eliminated move *)
rewrite H1 in H. clear H1. inv H.
right. split. simpl. omega. split. auto.
econstructor; eauto. simpl in H0. rewrite PMap.gss. congruence.
(* load *)
TransfInstr.
assert (Val.lessdef_list (rs##args) (rs'##args)). apply regset_get_list; auto.
exploit eval_addressing_lessdef; eauto.
intros [a' [ADDR' ALD]].
exploit Mem.loadv_extends; eauto.
intros [v' [LOAD' VLD]].
left. exists (State s' (transf_function f) (Vptr sp0 Int.zero) pc' (rs'#dst <- v') m'); split.
eapply @exec_Iload with (a := a'). eauto. rewrite <- ADDR'.
apply eval_addressing_preserved. exact symbols_preserved. eauto.
econstructor; eauto. apply regset_set; auto.
(* store *)
TransfInstr.
assert (Val.lessdef_list (rs##args) (rs'##args)). apply regset_get_list; auto.
exploit eval_addressing_lessdef; eauto.
intros [a' [ADDR' ALD]].
exploit Mem.storev_extends. 2: eexact H1. eauto. eauto. apply RLD.
intros [m'1 [STORE' MLD']].
left. exists (State s' (transf_function f) (Vptr sp0 Int.zero) pc' rs' m'1); split.
eapply @exec_Istore with (a := a'). eauto. rewrite <- ADDR'.
apply eval_addressing_preserved. exact symbols_preserved. eauto.
destruct a; simpl in H1; try discriminate.
econstructor; eauto.
(* call *)
exploit find_function_translated; eauto. intro FIND'.
TransfInstr.
(* call turned tailcall *)
assert ({ m'' | Mem.free m' sp0 0 (fn_stacksize (transf_function f)) = Some m''}).
apply Mem.range_perm_free. rewrite stacksize_preserved. rewrite H7.
red; intros; omegaContradiction.
destruct X as [m'' FREE].
left. exists (Callstate s' (transf_fundef fd) (rs'##args) m''); split.
eapply exec_Itailcall; eauto. apply sig_preserved.
constructor. eapply match_stackframes_tail; eauto. apply regset_get_list; auto.
eapply Mem.free_right_extends; eauto.
rewrite stacksize_preserved. rewrite H7. intros. omegaContradiction.
(* call that remains a call *)
left. exists (Callstate (Stackframe res (transf_function f) (Vptr sp0 Int.zero) pc' rs' :: s')
(transf_fundef fd) (rs'##args) m'); split.
eapply exec_Icall; eauto. apply sig_preserved.
constructor. constructor; auto. apply regset_get_list; auto. auto.
(* tailcall *)
exploit find_function_translated; eauto. intro FIND'.
exploit Mem.free_parallel_extends; eauto. intros [m'1 [FREE EXT]].
TransfInstr.
left. exists (Callstate s' (transf_fundef fd) (rs'##args) m'1); split.
eapply exec_Itailcall; eauto. apply sig_preserved.
rewrite stacksize_preserved; auto.
constructor. auto. apply regset_get_list; auto. auto.
(* builtin *)
TransfInstr.
assert (Val.lessdef_list (rs##args) (rs'##args)). apply regset_get_list; auto.
exploit (external_call_mem_extends ef); eauto.
intros [v' [m'1 [A [B [C D]]]]].
left. exists (State s' (transf_function f) (Vptr sp0 Int.zero) pc' (rs'#res <- v') m'1); split.
eapply exec_Ibuiltin; eauto.
eapply external_call_symbols_preserved; eauto.
exact symbols_preserved. exact varinfo_preserved.
econstructor; eauto. apply regset_set; auto.
(* cond *)
TransfInstr.
left. exists (State s' (transf_function f) (Vptr sp0 Int.zero) (if b then ifso else ifnot) rs' m'); split.
eapply exec_Icond; eauto.
apply eval_condition_lessdef with (rs##args) m; auto. apply regset_get_list; auto.
constructor; auto.
(* jumptable *)
TransfInstr.
left. exists (State s' (transf_function f) (Vptr sp0 Int.zero) pc' rs' m'); split.
eapply exec_Ijumptable; eauto.
generalize (RLD arg). rewrite H0. intro. inv H2. auto.
constructor; auto.
(* return *)
exploit Mem.free_parallel_extends; eauto. intros [m'1 [FREE EXT]].
TransfInstr.
left. exists (Returnstate s' (regmap_optget or Vundef rs') m'1); split.
apply exec_Ireturn; auto. rewrite stacksize_preserved; auto.
constructor. auto.
destruct or; simpl. apply RLD. constructor.
auto.
(* eliminated return None *)
assert (or = None) by congruence. subst or.
right. split. simpl. omega. split. auto.
constructor. auto.
simpl. constructor.
eapply Mem.free_left_extends; eauto.
(* eliminated return Some *)
assert (or = Some r) by congruence. subst or.
right. split. simpl. omega. split. auto.
constructor. auto.
simpl. auto.
eapply Mem.free_left_extends; eauto.
(* internal call *)
exploit Mem.alloc_extends; eauto.
instantiate (1 := 0). omega.
instantiate (1 := fn_stacksize f). omega.
intros [m'1 [ALLOC EXT]].
assert (fn_stacksize (transf_function f) = fn_stacksize f /\
fn_entrypoint (transf_function f) = fn_entrypoint f /\
fn_params (transf_function f) = fn_params f).
unfold transf_function. destruct (zeq (fn_stacksize f) 0); auto.
destruct H0 as [EQ1 [EQ2 EQ3]].
left. econstructor; split.
simpl. eapply exec_function_internal; eauto. rewrite EQ1; eauto.
rewrite EQ2. rewrite EQ3. constructor; auto.
apply regset_init_regs. auto.
(* external call *)
exploit external_call_mem_extends; eauto.
intros [res' [m2' [A [B [C D]]]]].
left. exists (Returnstate s' res' m2'); split.
simpl. econstructor; eauto.
eapply external_call_symbols_preserved; eauto.
exact symbols_preserved. exact varinfo_preserved.
constructor; auto.
(* returnstate *)
inv H2.
(* synchronous return in both programs *)
left. econstructor; split.
apply exec_return.
constructor; auto. apply regset_set; auto.
(* return instr in source program, eliminated because of tailcall *)
right. split. unfold measure. simpl length.
change (S (length s) * (niter + 2))%nat
with ((niter + 2) + (length s) * (niter + 2))%nat.
generalize (return_measure_bounds (fn_code f) pc). omega.
split. auto.
econstructor; eauto.
rewrite Regmap.gss. auto.
Qed.
Lemma transf_initial_states:
forall st1, initial_state prog st1 ->
exists st2, initial_state tprog st2 /\ match_states st1 st2.
Proof.
intros. inv H.
exploit funct_ptr_translated; eauto. intro FIND.
exists (Callstate nil (transf_fundef f) nil m0); split.
econstructor; eauto. apply Genv.init_mem_transf. auto.
replace (prog_main tprog) with (prog_main prog).
rewrite symbols_preserved. eauto.
reflexivity.
rewrite <- H3. apply sig_preserved.
constructor. constructor. constructor. apply Mem.extends_refl.
Qed.
Lemma transf_final_states:
forall st1 st2 r,
match_states st1 st2 -> final_state st1 r -> final_state st2 r.
Proof.
intros. inv H0. inv H. inv H5. inv H3. constructor.
Qed.
(** The preservation of the observable behavior of the program then
follows. *)
Theorem transf_program_correct:
forward_simulation (RTL.semantics prog) (RTL.semantics tprog).
Proof.
eapply forward_simulation_opt with (measure := measure); eauto.
eexact symbols_preserved.
eexact transf_initial_states.
eexact transf_final_states.
exact transf_step_correct.
Qed.
End PRESERVATION.
End WITHEC.
|
(* Title: HOL/Auth/n_germanSymIndex_lemma_inv__38_on_rules.thy
Author: Yongjian Li and Kaiqiang Duan, State Key Lab of Computer Science, Institute of Software, Chinese Academy of Sciences
Copyright 2016 State Key Lab of Computer Science, Institute of Software, Chinese Academy of Sciences
*)
header{*The n_germanSymIndex Protocol Case Study*}
theory n_germanSymIndex_lemma_inv__38_on_rules imports n_germanSymIndex_lemma_on_inv__38
begin
section{*All lemmas on causal relation between inv__38*}
lemma lemma_inv__38_on_rules:
assumes b1: "r \<in> rules N" and b2: "(\<exists> p__Inv2. p__Inv2\<le>N\<and>f=inv__38 p__Inv2)"
shows "invHoldForRule s f r (invariants N)"
proof -
have c1: "(\<exists> i d. i\<le>N\<and>d\<le>N\<and>r=n_Store i d)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendReqS i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendReqE__part__0 i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendReqE__part__1 i)\<or>
(\<exists> i. i\<le>N\<and>r=n_RecvReqS N i)\<or>
(\<exists> i. i\<le>N\<and>r=n_RecvReqE N i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendInv__part__0 i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendInv__part__1 i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendInvAck i)\<or>
(\<exists> i. i\<le>N\<and>r=n_RecvInvAck i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendGntS i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendGntE N i)\<or>
(\<exists> i. i\<le>N\<and>r=n_RecvGntS i)\<or>
(\<exists> i. i\<le>N\<and>r=n_RecvGntE i)"
apply (cut_tac b1, auto) done
moreover {
assume d1: "(\<exists> i d. i\<le>N\<and>d\<le>N\<and>r=n_Store i d)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_StoreVsinv__38) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendReqS i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendReqSVsinv__38) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendReqE__part__0 i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendReqE__part__0Vsinv__38) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendReqE__part__1 i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendReqE__part__1Vsinv__38) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_RecvReqS N i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_RecvReqSVsinv__38) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_RecvReqE N i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_RecvReqEVsinv__38) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendInv__part__0 i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendInv__part__0Vsinv__38) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendInv__part__1 i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendInv__part__1Vsinv__38) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendInvAck i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendInvAckVsinv__38) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_RecvInvAck i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_RecvInvAckVsinv__38) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendGntS i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendGntSVsinv__38) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendGntE N i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendGntEVsinv__38) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_RecvGntS i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_RecvGntSVsinv__38) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_RecvGntE i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_RecvGntEVsinv__38) done
}
ultimately show "invHoldForRule s f r (invariants N)"
by satx
qed
end
|
/-
Copyright (c) 2019 Sébastien Gouëzel. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Sébastien Gouëzel
-/
import topology.metric_space.baire
import analysis.normed_space.operator_norm
import analysis.normed_space.affine_isometry
/-!
# Banach open mapping theorem
This file contains the Banach open mapping theorem, i.e., the fact that a bijective
bounded linear map between Banach spaces has a bounded inverse.
-/
open function metric set filter finset linear_map (range ker)
open_locale classical topology big_operators nnreal
variables {𝕜 : Type*} [nontrivially_normed_field 𝕜]
{E : Type*} [normed_add_comm_group E] [normed_space 𝕜 E]
{F : Type*} [normed_add_comm_group F] [normed_space 𝕜 F]
(f : E →L[𝕜] F)
include 𝕜
namespace continuous_linear_map
/-- A (possibly nonlinear) right inverse to a continuous linear map, which doesn't have to be
linear itself but which satisfies a bound `‖inverse x‖ ≤ C * ‖x‖`. A surjective continuous linear
map doesn't always have a continuous linear right inverse, but it always has a nonlinear inverse
in this sense, by Banach's open mapping theorem. -/
structure nonlinear_right_inverse :=
(to_fun : F → E)
(nnnorm : ℝ≥0)
(bound' : ∀ y, ‖to_fun y‖ ≤ nnnorm * ‖y‖)
(right_inv' : ∀ y, f (to_fun y) = y)
instance : has_coe_to_fun (nonlinear_right_inverse f) (λ _, F → E) := ⟨λ fsymm, fsymm.to_fun⟩
@[simp] lemma nonlinear_right_inverse.right_inv {f : E →L[𝕜] F} (fsymm : nonlinear_right_inverse f)
(y : F) : f (fsymm y) = y :=
fsymm.right_inv' y
lemma nonlinear_right_inverse.bound {f : E →L[𝕜] F} (fsymm : nonlinear_right_inverse f) (y : F) :
‖fsymm y‖ ≤ fsymm.nnnorm * ‖y‖ :=
fsymm.bound' y
end continuous_linear_map
/-- Given a continuous linear equivalence, the inverse is in particular an instance of
`nonlinear_right_inverse` (which turns out to be linear). -/
noncomputable def continuous_linear_equiv.to_nonlinear_right_inverse (f : E ≃L[𝕜] F) :
continuous_linear_map.nonlinear_right_inverse (f : E →L[𝕜] F) :=
{ to_fun := f.inv_fun,
nnnorm := ‖(f.symm : F →L[𝕜] E)‖₊,
bound' := λ y, continuous_linear_map.le_op_norm (f.symm : F →L[𝕜] E) _,
right_inv' := f.apply_symm_apply }
noncomputable instance (f : E ≃L[𝕜] F) :
inhabited (continuous_linear_map.nonlinear_right_inverse (f : E →L[𝕜] F)) :=
⟨f.to_nonlinear_right_inverse⟩
/-! ### Proof of the Banach open mapping theorem -/
variable [complete_space F]
namespace continuous_linear_map
/--
First step of the proof of the Banach open mapping theorem (using completeness of `F`):
by Baire's theorem, there exists a ball in `E` whose image closure has nonempty interior.
Rescaling everything, it follows that any `y ∈ F` is arbitrarily well approached by
images of elements of norm at most `C * ‖y‖`.
For further use, we will only need such an element whose image
is within distance `‖y‖/2` of `y`, to apply an iterative process. -/
lemma exists_approx_preimage_norm_le (surj : surjective f) :
∃C ≥ 0, ∀y, ∃x, dist (f x) y ≤ 1/2 * ‖y‖ ∧ ‖x‖ ≤ C * ‖y‖ :=
begin
have A : (⋃n:ℕ, closure (f '' (ball 0 n))) = univ,
{ refine subset.antisymm (subset_univ _) (λy hy, _),
rcases surj y with ⟨x, hx⟩,
rcases exists_nat_gt (‖x‖) with ⟨n, hn⟩,
refine mem_Union.2 ⟨n, subset_closure _⟩,
refine (mem_image _ _ _).2 ⟨x, ⟨_, hx⟩⟩,
rwa [mem_ball, dist_eq_norm, sub_zero] },
have : ∃ (n : ℕ) x, x ∈ interior (closure (f '' (ball 0 n))) :=
nonempty_interior_of_Union_of_closed (λn, is_closed_closure) A,
simp only [mem_interior_iff_mem_nhds, metric.mem_nhds_iff] at this,
rcases this with ⟨n, a, ε, ⟨εpos, H⟩⟩,
rcases normed_field.exists_one_lt_norm 𝕜 with ⟨c, hc⟩,
refine ⟨(ε/2)⁻¹ * ‖c‖ * 2 * n, _, λy, _⟩,
{ refine mul_nonneg (mul_nonneg (mul_nonneg _ (norm_nonneg _)) (by norm_num)) _,
exacts [inv_nonneg.2 (div_nonneg (le_of_lt εpos) (by norm_num)), n.cast_nonneg] },
{ by_cases hy : y = 0,
{ use 0, simp [hy] },
{ rcases rescale_to_shell hc (half_pos εpos) hy with ⟨d, hd, ydlt, leyd, dinv⟩,
let δ := ‖d‖ * ‖y‖/4,
have δpos : 0 < δ :=
div_pos (mul_pos (norm_pos_iff.2 hd) (norm_pos_iff.2 hy)) (by norm_num),
have : a + d • y ∈ ball a ε,
by simp [dist_eq_norm, lt_of_le_of_lt ydlt.le (half_lt_self εpos)],
rcases metric.mem_closure_iff.1 (H this) _ δpos with ⟨z₁, z₁im, h₁⟩,
rcases (mem_image _ _ _).1 z₁im with ⟨x₁, hx₁, xz₁⟩,
rw ← xz₁ at h₁,
rw [mem_ball, dist_eq_norm, sub_zero] at hx₁,
have : a ∈ ball a ε, by { simp, exact εpos },
rcases metric.mem_closure_iff.1 (H this) _ δpos with ⟨z₂, z₂im, h₂⟩,
rcases (mem_image _ _ _).1 z₂im with ⟨x₂, hx₂, xz₂⟩,
rw ← xz₂ at h₂,
rw [mem_ball, dist_eq_norm, sub_zero] at hx₂,
let x := x₁ - x₂,
have I : ‖f x - d • y‖ ≤ 2 * δ := calc
‖f x - d • y‖ = ‖f x₁ - (a + d • y) - (f x₂ - a)‖ :
by { congr' 1, simp only [x, f.map_sub], abel }
... ≤ ‖f x₁ - (a + d • y)‖ + ‖f x₂ - a‖ :
norm_sub_le _ _
... ≤ δ + δ : begin
apply add_le_add,
{ rw [← dist_eq_norm, dist_comm], exact le_of_lt h₁ },
{ rw [← dist_eq_norm, dist_comm], exact le_of_lt h₂ }
end
... = 2 * δ : (two_mul _).symm,
have J : ‖f (d⁻¹ • x) - y‖ ≤ 1/2 * ‖y‖ := calc
‖f (d⁻¹ • x) - y‖ = ‖d⁻¹ • f x - (d⁻¹ * d) • y‖ :
by rwa [f.map_smul _, inv_mul_cancel, one_smul]
... = ‖d⁻¹ • (f x - d • y)‖ : by rw [mul_smul, smul_sub]
... = ‖d‖⁻¹ * ‖f x - d • y‖ : by rw [norm_smul, norm_inv]
... ≤ ‖d‖⁻¹ * (2 * δ) : begin
apply mul_le_mul_of_nonneg_left I,
rw inv_nonneg,
exact norm_nonneg _
end
... = (‖d‖⁻¹ * ‖d‖) * ‖y‖ /2 : by { simp only [δ], ring }
... = ‖y‖/2 : by { rw [inv_mul_cancel, one_mul], simp [norm_eq_zero, hd] }
... = (1/2) * ‖y‖ : by ring,
rw ← dist_eq_norm at J,
have K : ‖d⁻¹ • x‖ ≤ (ε / 2)⁻¹ * ‖c‖ * 2 * ↑n * ‖y‖ := calc
‖d⁻¹ • x‖ = ‖d‖⁻¹ * ‖x₁ - x₂‖ : by rw [norm_smul, norm_inv]
... ≤ ((ε / 2)⁻¹ * ‖c‖ * ‖y‖) * (n + n) : begin
refine mul_le_mul dinv _ (norm_nonneg _) _,
{ exact le_trans (norm_sub_le _ _) (add_le_add (le_of_lt hx₁) (le_of_lt hx₂)) },
{ apply mul_nonneg (mul_nonneg _ (norm_nonneg _)) (norm_nonneg _),
exact inv_nonneg.2 (le_of_lt (half_pos εpos)) }
end
... = (ε / 2)⁻¹ * ‖c‖ * 2 * ↑n * ‖y‖ : by ring,
exact ⟨d⁻¹ • x, J, K⟩ } },
end
variable [complete_space E]
/-- The Banach open mapping theorem: if a bounded linear map between Banach spaces is onto, then
any point has a preimage with controlled norm. -/
theorem exists_preimage_norm_le (surj : surjective f) :
∃C > 0, ∀y, ∃x, f x = y ∧ ‖x‖ ≤ C * ‖y‖ :=
begin
obtain ⟨C, C0, hC⟩ := exists_approx_preimage_norm_le f surj,
/- Second step of the proof: starting from `y`, we want an exact preimage of `y`. Let `g y` be
the approximate preimage of `y` given by the first step, and `h y = y - f(g y)` the part that
has no preimage yet. We will iterate this process, taking the approximate preimage of `h y`,
leaving only `h^2 y` without preimage yet, and so on. Let `u n` be the approximate preimage
of `h^n y`. Then `u` is a converging series, and by design the sum of the series is a
preimage of `y`. This uses completeness of `E`. -/
choose g hg using hC,
let h := λy, y - f (g y),
have hle : ∀y, ‖h y‖ ≤ (1/2) * ‖y‖,
{ assume y,
rw [← dist_eq_norm, dist_comm],
exact (hg y).1 },
refine ⟨2 * C + 1, by linarith, λy, _⟩,
have hnle : ∀n:ℕ, ‖(h^[n]) y‖ ≤ (1/2)^n * ‖y‖,
{ assume n,
induction n with n IH,
{ simp only [one_div, nat.nat_zero_eq_zero, one_mul, iterate_zero_apply,
pow_zero] },
{ rw [iterate_succ'],
apply le_trans (hle _) _,
rw [pow_succ, mul_assoc],
apply mul_le_mul_of_nonneg_left IH,
norm_num } },
let u := λn, g((h^[n]) y),
have ule : ∀n, ‖u n‖ ≤ (1/2)^n * (C * ‖y‖),
{ assume n,
apply le_trans (hg _).2 _,
calc C * ‖(h^[n]) y‖ ≤ C * ((1/2)^n * ‖y‖) : mul_le_mul_of_nonneg_left (hnle n) C0
... = (1 / 2) ^ n * (C * ‖y‖) : by ring },
have sNu : summable (λn, ‖u n‖),
{ refine summable_of_nonneg_of_le (λn, norm_nonneg _) ule _,
exact summable.mul_right _ (summable_geometric_of_lt_1 (by norm_num) (by norm_num)) },
have su : summable u := summable_of_summable_norm sNu,
let x := tsum u,
have x_ineq : ‖x‖ ≤ (2 * C + 1) * ‖y‖ := calc
‖x‖ ≤ ∑'n, ‖u n‖ : norm_tsum_le_tsum_norm sNu
... ≤ ∑'n, (1/2)^n * (C * ‖y‖) :
tsum_le_tsum ule sNu (summable.mul_right _ summable_geometric_two)
... = (∑'n, (1/2)^n) * (C * ‖y‖) : tsum_mul_right
... = 2 * C * ‖y‖ : by rw [tsum_geometric_two, mul_assoc]
... ≤ 2 * C * ‖y‖ + ‖y‖ : le_add_of_nonneg_right (norm_nonneg y)
... = (2 * C + 1) * ‖y‖ : by ring,
have fsumeq : ∀n:ℕ, f (∑ i in finset.range n, u i) = y - (h^[n]) y,
{ assume n,
induction n with n IH,
{ simp [f.map_zero] },
{ rw [sum_range_succ, f.map_add, IH, iterate_succ', sub_add] } },
have : tendsto (λn, ∑ i in finset.range n, u i) at_top (𝓝 x) :=
su.has_sum.tendsto_sum_nat,
have L₁ : tendsto (λn, f (∑ i in finset.range n, u i)) at_top (𝓝 (f x)) :=
(f.continuous.tendsto _).comp this,
simp only [fsumeq] at L₁,
have L₂ : tendsto (λn, y - (h^[n]) y) at_top (𝓝 (y - 0)),
{ refine tendsto_const_nhds.sub _,
rw tendsto_iff_norm_tendsto_zero,
simp only [sub_zero],
refine squeeze_zero (λ_, norm_nonneg _) hnle _,
rw [← zero_mul ‖y‖],
refine (tendsto_pow_at_top_nhds_0_of_lt_1 _ _).mul tendsto_const_nhds; norm_num },
have feq : f x = y - 0 := tendsto_nhds_unique L₁ L₂,
rw sub_zero at feq,
exact ⟨x, feq, x_ineq⟩
end
/-- The Banach open mapping theorem: a surjective bounded linear map between Banach spaces is
open. -/
protected theorem is_open_map (surj : surjective f) : is_open_map f :=
begin
assume s hs,
rcases exists_preimage_norm_le f surj with ⟨C, Cpos, hC⟩,
refine is_open_iff.2 (λy yfs, _),
rcases mem_image_iff_bex.1 yfs with ⟨x, xs, fxy⟩,
rcases is_open_iff.1 hs x xs with ⟨ε, εpos, hε⟩,
refine ⟨ε/C, div_pos εpos Cpos, λz hz, _⟩,
rcases hC (z-y) with ⟨w, wim, wnorm⟩,
have : f (x + w) = z, by { rw [f.map_add, wim, fxy, add_sub_cancel'_right] },
rw ← this,
have : x + w ∈ ball x ε := calc
dist (x+w) x = ‖w‖ : by { rw dist_eq_norm, simp }
... ≤ C * ‖z - y‖ : wnorm
... < C * (ε/C) : begin
apply mul_lt_mul_of_pos_left _ Cpos,
rwa [mem_ball, dist_eq_norm] at hz,
end
... = ε : mul_div_cancel' _ (ne_of_gt Cpos),
exact set.mem_image_of_mem _ (hε this)
end
protected theorem quotient_map (surj : surjective f) : quotient_map f :=
(f.is_open_map surj).to_quotient_map f.continuous surj
lemma _root_.affine_map.is_open_map {P Q : Type*}
[metric_space P] [normed_add_torsor E P] [metric_space Q] [normed_add_torsor F Q]
(f : P →ᵃ[𝕜] Q) (hf : continuous f) (surj : surjective f) :
is_open_map f :=
affine_map.is_open_map_linear_iff.mp $ continuous_linear_map.is_open_map
{ cont := affine_map.continuous_linear_iff.mpr hf, .. f.linear }
(f.linear_surjective_iff.mpr surj)
/-! ### Applications of the Banach open mapping theorem -/
lemma interior_preimage (hsurj : surjective f) (s : set F) :
interior (f ⁻¹' s) = f ⁻¹' (interior s) :=
((f.is_open_map hsurj).preimage_interior_eq_interior_preimage f.continuous s).symm
lemma closure_preimage (hsurj : surjective f) (s : set F) :
closure (f ⁻¹' s) = f ⁻¹' (closure s) :=
((f.is_open_map hsurj).preimage_closure_eq_closure_preimage f.continuous s).symm
lemma frontier_preimage (hsurj : surjective f) (s : set F) :
frontier (f ⁻¹' s) = f ⁻¹' (frontier s) :=
((f.is_open_map hsurj).preimage_frontier_eq_frontier_preimage f.continuous s).symm
lemma exists_nonlinear_right_inverse_of_surjective (f : E →L[𝕜] F)
(hsurj : linear_map.range f = ⊤) : ∃ (fsymm : nonlinear_right_inverse f), 0 < fsymm.nnnorm :=
begin
choose C hC fsymm h using exists_preimage_norm_le _ (linear_map.range_eq_top.mp hsurj),
use { to_fun := fsymm,
nnnorm := ⟨C, hC.lt.le⟩,
bound' := λ y, (h y).2,
right_inv' := λ y, (h y).1 },
exact hC
end
/-- A surjective continuous linear map between Banach spaces admits a (possibly nonlinear)
controlled right inverse. In general, it is not possible to ensure that such a right inverse
is linear (take for instance the map from `E` to `E/F` where `F` is a closed subspace of `E`
without a closed complement. Then it doesn't have a continuous linear right inverse.) -/
@[irreducible] noncomputable def nonlinear_right_inverse_of_surjective
(f : E →L[𝕜] F) (hsurj : linear_map.range f = ⊤) : nonlinear_right_inverse f :=
classical.some (exists_nonlinear_right_inverse_of_surjective f hsurj)
lemma nonlinear_right_inverse_of_surjective_nnnorm_pos (f : E →L[𝕜] F)
(hsurj : linear_map.range f = ⊤) : 0 < (nonlinear_right_inverse_of_surjective f hsurj).nnnorm :=
begin
rw nonlinear_right_inverse_of_surjective,
exact classical.some_spec (exists_nonlinear_right_inverse_of_surjective f hsurj)
end
end continuous_linear_map
namespace linear_equiv
variables [complete_space E]
/-- If a bounded linear map is a bijection, then its inverse is also a bounded linear map. -/
@[continuity]
theorem continuous_symm (e : E ≃ₗ[𝕜] F) (h : continuous e) :
continuous e.symm :=
begin
rw continuous_def,
intros s hs,
rw [← e.image_eq_preimage],
rw [← e.coe_coe] at h ⊢,
exact continuous_linear_map.is_open_map ⟨↑e, h⟩ e.surjective s hs
end
/-- Associating to a linear equivalence between Banach spaces a continuous linear equivalence when
the direct map is continuous, thanks to the Banach open mapping theorem that ensures that the
inverse map is also continuous. -/
def to_continuous_linear_equiv_of_continuous (e : E ≃ₗ[𝕜] F) (h : continuous e) :
E ≃L[𝕜] F :=
{ continuous_to_fun := h,
continuous_inv_fun := e.continuous_symm h,
..e }
@[simp] lemma coe_fn_to_continuous_linear_equiv_of_continuous (e : E ≃ₗ[𝕜] F) (h : continuous e) :
⇑(e.to_continuous_linear_equiv_of_continuous h) = e := rfl
@[simp] lemma coe_fn_to_continuous_linear_equiv_of_continuous_symm (e : E ≃ₗ[𝕜] F)
(h : continuous e) :
⇑(e.to_continuous_linear_equiv_of_continuous h).symm = e.symm := rfl
end linear_equiv
namespace continuous_linear_equiv
variables [complete_space E]
/-- Convert a bijective continuous linear map `f : E →L[𝕜] F` from a Banach space to a normed space
to a continuous linear equivalence. -/
noncomputable def of_bijective (f : E →L[𝕜] F) (hinj : ker f = ⊥)
(hsurj : linear_map.range f = ⊤) : E ≃L[𝕜] F :=
(linear_equiv.of_bijective ↑f ⟨linear_map.ker_eq_bot.mp hinj, linear_map.range_eq_top.mp hsurj⟩)
.to_continuous_linear_equiv_of_continuous f.continuous
@[simp] lemma coe_fn_of_bijective (f : E →L[𝕜] F) (hinj : ker f = ⊥)
(hsurj : linear_map.range f = ⊤) : ⇑(of_bijective f hinj hsurj) = f := rfl
lemma coe_of_bijective (f : E →L[𝕜] F) (hinj : ker f = ⊥) (hsurj : linear_map.range f = ⊤) :
↑(of_bijective f hinj hsurj) = f := by { ext, refl }
@[simp] lemma of_bijective_symm_apply_apply (f : E →L[𝕜] F) (hinj : ker f = ⊥)
(hsurj : linear_map.range f = ⊤) (x : E) :
(of_bijective f hinj hsurj).symm (f x) = x :=
(of_bijective f hinj hsurj).symm_apply_apply x
@[simp] lemma of_bijective_apply_symm_apply (f : E →L[𝕜] F) (hinj : ker f = ⊥)
(hsurj : linear_map.range f = ⊤) (y : F) :
f ((of_bijective f hinj hsurj).symm y) = y :=
(of_bijective f hinj hsurj).apply_symm_apply y
end continuous_linear_equiv
namespace continuous_linear_map
variables [complete_space E]
/-- Intermediate definition used to show
`continuous_linear_map.closed_complemented_range_of_is_compl_of_ker_eq_bot`.
This is `f.coprod G.subtypeL` as an `continuous_linear_equiv`. -/
noncomputable def coprod_subtypeL_equiv_of_is_compl
(f : E →L[𝕜] F) {G : submodule 𝕜 F}
(h : is_compl (linear_map.range f) G) [complete_space G] (hker : ker f = ⊥) : (E × G) ≃L[𝕜] F :=
continuous_linear_equiv.of_bijective (f.coprod G.subtypeL)
(begin
rw ker_coprod_of_disjoint_range,
{ rw [hker, submodule.ker_subtypeL, submodule.prod_bot] },
{ rw submodule.range_subtypeL,
exact h.disjoint }
end)
(by simp only [range_coprod, h.sup_eq_top, submodule.range_subtypeL])
lemma range_eq_map_coprod_subtypeL_equiv_of_is_compl
(f : E →L[𝕜] F) {G : submodule 𝕜 F}
(h : is_compl (linear_map.range f) G) [complete_space G] (hker : ker f = ⊥) :
linear_map.range f = ((⊤ : submodule 𝕜 E).prod (⊥ : submodule 𝕜 G)).map
(f.coprod_subtypeL_equiv_of_is_compl h hker : E × G →ₗ[𝕜] F) :=
begin
rw [coprod_subtypeL_equiv_of_is_compl, _root_.coe_coe, continuous_linear_equiv.coe_of_bijective,
coe_coprod, linear_map.coprod_map_prod, submodule.map_bot, sup_bot_eq, submodule.map_top],
refl
end
/- TODO: remove the assumption `f.ker = ⊥` in the next lemma, by using the map induced by `f` on
`E / f.ker`, once we have quotient normed spaces. -/
lemma closed_complemented_range_of_is_compl_of_ker_eq_bot (f : E →L[𝕜] F) (G : submodule 𝕜 F)
(h : is_compl (linear_map.range f) G) (hG : is_closed (G : set F)) (hker : ker f = ⊥) :
is_closed (linear_map.range f : set F) :=
begin
haveI : complete_space G := hG.complete_space_coe,
let g := coprod_subtypeL_equiv_of_is_compl f h hker,
rw congr_arg coe (range_eq_map_coprod_subtypeL_equiv_of_is_compl f h hker ),
apply g.to_homeomorph.is_closed_image.2,
exact is_closed_univ.prod is_closed_singleton,
end
end continuous_linear_map
section closed_graph_thm
variables [complete_space E] (g : E →ₗ[𝕜] F)
/-- The **closed graph theorem** : a linear map between two Banach spaces whose graph is closed
is continuous. -/
theorem linear_map.continuous_of_is_closed_graph (hg : is_closed (g.graph : set $ E × F)) :
continuous g :=
begin
letI : complete_space g.graph := complete_space_coe_iff_is_complete.mpr hg.is_complete,
let φ₀ : E →ₗ[𝕜] E × F := linear_map.id.prod g,
have : function.left_inverse prod.fst φ₀ := λ x, rfl,
let φ : E ≃ₗ[𝕜] g.graph :=
(linear_equiv.of_left_inverse this).trans
(linear_equiv.of_eq _ _ g.graph_eq_range_prod.symm),
let ψ : g.graph ≃L[𝕜] E := φ.symm.to_continuous_linear_equiv_of_continuous
continuous_subtype_coe.fst,
exact (continuous_subtype_coe.comp ψ.symm.continuous).snd
end
/-- A useful form of the **closed graph theorem** : let `f` be a linear map between two Banach
spaces. To show that `f` is continuous, it suffices to show that for any convergent sequence
`uₙ ⟶ x`, if `f(uₙ) ⟶ y` then `y = f(x)`. -/
theorem linear_map.continuous_of_seq_closed_graph
(hg : ∀ (u : ℕ → E) x y, tendsto u at_top (𝓝 x) → tendsto (g ∘ u) at_top (𝓝 y) → y = g x) :
continuous g :=
begin
refine g.continuous_of_is_closed_graph (is_seq_closed.is_closed _),
rintros φ ⟨x, y⟩ hφg hφ,
refine hg (prod.fst ∘ φ) x y ((continuous_fst.tendsto _).comp hφ) _,
have : g ∘ prod.fst ∘ φ = prod.snd ∘ φ,
{ ext n,
exact (hφg n).symm },
rw this,
exact (continuous_snd.tendsto _).comp hφ
end
variable {g}
namespace continuous_linear_map
/-- Upgrade a `linear_map` to a `continuous_linear_map` using the **closed graph theorem**. -/
def of_is_closed_graph (hg : is_closed (g.graph : set $ E × F)) :
E →L[𝕜] F :=
{ to_linear_map := g,
cont := g.continuous_of_is_closed_graph hg }
@[simp] lemma coe_fn_of_is_closed_graph (hg : is_closed (g.graph : set $ E × F)) :
⇑(continuous_linear_map.of_is_closed_graph hg) = g := rfl
lemma coe_of_is_closed_graph (hg : is_closed (g.graph : set $ E × F)) :
↑(continuous_linear_map.of_is_closed_graph hg) = g := by { ext, refl }
/-- Upgrade a `linear_map` to a `continuous_linear_map` using a variation on the
**closed graph theorem**. -/
def of_seq_closed_graph
(hg : ∀ (u : ℕ → E) x y, tendsto u at_top (𝓝 x) → tendsto (g ∘ u) at_top (𝓝 y) → y = g x) :
E →L[𝕜] F :=
{ to_linear_map := g,
cont := g.continuous_of_seq_closed_graph hg }
@[simp] lemma coe_fn_of_seq_closed_graph
(hg : ∀ (u : ℕ → E) x y, tendsto u at_top (𝓝 x) → tendsto (g ∘ u) at_top (𝓝 y) → y = g x) :
⇑(continuous_linear_map.of_seq_closed_graph hg) = g := rfl
lemma coe_of_seq_closed_graph
(hg : ∀ (u : ℕ → E) x y, tendsto u at_top (𝓝 x) → tendsto (g ∘ u) at_top (𝓝 y) → y = g x) :
↑(continuous_linear_map.of_seq_closed_graph hg) = g := by { ext, refl }
end continuous_linear_map
end closed_graph_thm
|
= = Status = =
|
import numpy as np
import os
import sys
import torch
from torchvision import models,transforms
import torch.nn as nn
import torch.nn.functional as F
import inspect
class LPIPSvgg(torch.nn.Module):
def __init__(self, channels=3):
# Refer to https://github.com/richzhang/PerceptualSimilarity
assert channels == 3
super(LPIPSvgg, self).__init__()
vgg_pretrained_features = models.vgg16(pretrained=True).features
self.stage1 = torch.nn.Sequential()
self.stage2 = torch.nn.Sequential()
self.stage3 = torch.nn.Sequential()
self.stage4 = torch.nn.Sequential()
self.stage5 = torch.nn.Sequential()
for x in range(0,4):
self.stage1.add_module(str(x), vgg_pretrained_features[x])
for x in range(4, 9):
self.stage2.add_module(str(x), vgg_pretrained_features[x])
for x in range(9, 16):
self.stage3.add_module(str(x), vgg_pretrained_features[x])
for x in range(16, 23):
self.stage4.add_module(str(x), vgg_pretrained_features[x])
for x in range(23, 30):
self.stage5.add_module(str(x), vgg_pretrained_features[x])
for param in self.parameters():
param.requires_grad = False
self.register_buffer("mean", torch.tensor([0.485, 0.456, 0.406]).view(1,-1,1,1))
self.register_buffer("std", torch.tensor([0.229, 0.224, 0.225]).view(1,-1,1,1))
self.chns = [64,128,256,512,512]
self.weights = torch.load(os.path.abspath(os.path.join(inspect.getfile(LPIPSvgg),'..','weights/LPIPSvgg.pt')))
self.weights = list(self.weights.items())
def forward_once(self, x):
h = (x-self.mean)/self.std
h = self.stage1(h)
h_relu1_2 = h
h = self.stage2(h)
h_relu2_2 = h
h = self.stage3(h)
h_relu3_3 = h
h = self.stage4(h)
h_relu4_3 = h
h = self.stage5(h)
h_relu5_3 = h
outs = [h_relu1_2, h_relu2_2, h_relu3_3, h_relu4_3, h_relu5_3]
for k in range(len(outs)):
outs[k] = F.normalize(outs[k])
return outs
def forward(self, x, y, as_loss=True):
assert x.shape == y.shape
if as_loss:
feats0 = self.forward_once(x)
feats1 = self.forward_once(y)
else:
with torch.no_grad():
feats0 = self.forward_once(x)
feats1 = self.forward_once(y)
score = 0
for k in range(len(self.chns)):
score = score + (self.weights[k][1]*(feats0[k]-feats1[k])**2).mean([2,3]).sum(1)
if as_loss:
return score.mean()
else:
return score
if __name__ == '__main__':
from PIL import Image
import argparse
from utils import prepare_image
parser = argparse.ArgumentParser()
parser.add_argument('--ref', type=str, default='images/r0.png')
parser.add_argument('--dist', type=str, default='images/r1.png')
args = parser.parse_args()
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
ref = prepare_image(Image.open(args.ref).convert("RGB")).to(device)
dist = prepare_image(Image.open(args.dist).convert("RGB")).to(device)
model = LPIPSvgg().to(device)
score = model(ref, dist, as_loss=False)
print('score: %.4f' % score.item())
# score: 0.5435
|
/-
Copyright (c) 2022 Scott Morrison. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Scott Morrison
-/
import algebra.group.pi
import category_theory.limits.shapes.biproducts
import algebra.category.Module.limits
import algebra.homology.short_exact.abelian
/-!
# The category of `R`-modules has finite biproducts
-/
open category_theory
open category_theory.limits
open_locale big_operators
universes v u
namespace Module
variables {R : Type u} [ring R]
-- As `Module R` is preadditive, and has all limits, it automatically has biproducts.
instance : has_binary_biproducts (Module.{v} R) :=
has_binary_biproducts.of_has_binary_products
instance : has_finite_biproducts (Module.{v} R) :=
has_finite_biproducts.of_has_finite_products
-- We now construct explicit limit data,
-- so we can compare the biproducts to the usual unbundled constructions.
/--
Construct limit data for a binary product in `Module R`, using `Module.of R (M × N)`.
-/
@[simps cone_X is_limit_lift]
def binary_product_limit_cone (M N : Module.{v} R) : limits.limit_cone (pair M N) :=
{ cone :=
{ X := Module.of R (M × N),
π :=
{ app := λ j, discrete.cases_on j
(λ j, walking_pair.cases_on j (linear_map.fst R M N) (linear_map.snd R M N)),
naturality' := by rintros ⟨⟨⟩⟩ ⟨⟨⟩⟩ ⟨⟨⟨⟩⟩⟩; refl, }},
is_limit :=
{ lift := λ s, linear_map.prod (s.π.app ⟨walking_pair.left⟩) (s.π.app ⟨walking_pair.right⟩),
fac' := by { rintros s (⟨⟩|⟨⟩); { ext x, simp, }, },
uniq' := λ s m w,
begin
ext; [rw ← w ⟨walking_pair.left⟩, rw ← w ⟨walking_pair.right⟩]; refl,
end, } }
@[simp] lemma binary_product_limit_cone_cone_π_app_left (M N : Module.{v} R) :
(binary_product_limit_cone M N).cone.π.app ⟨walking_pair.left⟩ = linear_map.fst R M N := rfl
@[simp] lemma binary_product_limit_cone_cone_π_app_right (M N : Module.{v} R) :
(binary_product_limit_cone M N).cone.π.app ⟨walking_pair.right⟩ = linear_map.snd R M N := rfl
/--
We verify that the biproduct in `Module R` is isomorphic to
the cartesian product of the underlying types:
-/
@[simps hom_apply] noncomputable
def biprod_iso_prod (M N : Module.{v} R) : (M ⊞ N : Module.{v} R) ≅ Module.of R (M × N) :=
is_limit.cone_point_unique_up_to_iso
(binary_biproduct.is_limit M N)
(binary_product_limit_cone M N).is_limit
@[simp, elementwise] lemma biprod_iso_prod_inv_comp_fst (M N : Module.{v} R) :
(biprod_iso_prod M N).inv ≫ biprod.fst = linear_map.fst R M N :=
is_limit.cone_point_unique_up_to_iso_inv_comp _ _ (discrete.mk walking_pair.left)
@[simp, elementwise] lemma biprod_iso_prod_inv_comp_snd (M N : Module.{v} R) :
(biprod_iso_prod M N).inv ≫ biprod.snd = linear_map.snd R M N :=
is_limit.cone_point_unique_up_to_iso_inv_comp _ _ (discrete.mk walking_pair.right)
variables {J : Type v} (f : J → Module.{v} R)
namespace has_limit
/--
The map from an arbitrary cone over a indexed family of abelian groups
to the cartesian product of those groups.
-/
@[simps]
def lift (s : fan f) :
s.X ⟶ Module.of R (Π j, f j) :=
{ to_fun := λ x j, s.π.app ⟨j⟩ x,
map_add' := λ x y, by { ext, simp, },
map_smul' := λ r x, by { ext, simp, }, }
/--
Construct limit data for a product in `Module R`, using `Module.of R (Π j, F.obj j)`.
-/
@[simps] def product_limit_cone : limits.limit_cone (discrete.functor f) :=
{ cone :=
{ X := Module.of R (Π j, f j),
π := discrete.nat_trans (λ j, (linear_map.proj j.as : (Π j, f j) →ₗ[R] f j.as)), },
is_limit :=
{ lift := lift f,
fac' := λ s j, by { cases j, ext, simp, },
uniq' := λ s m w,
begin
ext x j,
dsimp only [has_limit.lift],
simp only [linear_map.coe_mk],
exact congr_arg (λ g : s.X ⟶ f j, (g : s.X → f j) x) (w ⟨j⟩),
end, }, }
end has_limit
open has_limit
/--
We verify that the biproduct we've just defined is isomorphic to the `Module R` structure
on the dependent function type
-/
@[simps hom_apply] noncomputable
def biproduct_iso_pi [fintype J] (f : J → Module.{v} R) :
(⨁ f : Module.{v} R) ≅ Module.of R (Π j, f j) :=
is_limit.cone_point_unique_up_to_iso
(biproduct.is_limit f)
(product_limit_cone f).is_limit
@[simp, elementwise] lemma biproduct_iso_pi_inv_comp_π [fintype J]
(f : J → Module.{v} R) (j : J) :
(biproduct_iso_pi f).inv ≫ biproduct.π f j = (linear_map.proj j : (Π j, f j) →ₗ[R] f j) :=
is_limit.cone_point_unique_up_to_iso_inv_comp _ _ (discrete.mk j)
end Module
section split_exact
variables {R : Type u} {A M B : Type v} [ring R] [add_comm_group A] [module R A]
[add_comm_group B] [module R B] [add_comm_group M] [module R M]
variables {j : A →ₗ[R] M} {g : M →ₗ[R] B}
open Module
/--The isomorphism `A × B ≃ₗ[R] M` coming from a right split exact sequence `0 ⟶ A ⟶ M ⟶ B ⟶ 0`
of modules.-/
noncomputable def lequiv_prod_of_right_split_exact {f : B →ₗ[R] M}
(hj : function.injective j) (exac : j.range = g.ker) (h : g.comp f = linear_map.id) :
(A × B) ≃ₗ[R] M :=
(({ right_split := ⟨as_hom f, h⟩,
mono := (Module.mono_iff_injective $ as_hom j).mpr hj,
exact := (exact_iff _ _).mpr exac } : right_split _ _).splitting.iso.trans $
biprod_iso_prod _ _).to_linear_equiv.symm
/--The isomorphism `A × B ≃ₗ[R] M` coming from a left split exact sequence `0 ⟶ A ⟶ M ⟶ B ⟶ 0`
of modules.-/
noncomputable def lequiv_prod_of_left_split_exact {f : M →ₗ[R] A}
(hg : function.surjective g) (exac : j.range = g.ker) (h : f.comp j = linear_map.id) :
(A × B) ≃ₗ[R] M :=
(({ left_split := ⟨as_hom f, h⟩,
epi := (Module.epi_iff_surjective $ as_hom g).mpr hg,
exact := (exact_iff _ _).mpr exac } : left_split _ _).splitting.iso.trans $
biprod_iso_prod _ _).to_linear_equiv.symm
end split_exact
|
# Coin toss problem
## What is the problem?
Let's pick up a random coin (not necessarily a fair one with equal probability of head and tail). We did the coin toss experiment $n$ times and gathered the observed data $D$ as a set of outcomes (e.g. $\{H, T, T, ...\}$). Now, we are interested in predicting the probability of heads $p(H)=\theta_{best}$ for our coin.
## Applying Bayes rule
In this problem, we will {ref}`model the distribution of parameters <parameters-framework>`.
\begin{equation}
\underbrace{p(\theta|D)}_{\text{Posterior}} = \frac{\overbrace{p(D|\theta)}^{\text{Likelihood}}}{\underbrace{p(D)}_{\text{Evidence}}}\underbrace{p(\theta)}_{\text{Prior}}
\end{equation}
\begin{equation}
p(D) = \int_{\theta}p(D|\theta)p(\theta)d\theta
\end{equation}
We are interested in $p(\theta|D)$ and to derive that, we need prior, likelihood and evidence terms. Let us look at them one by one.
### Prior
What is our prior belief about the coin's probability of head $p($H$)$? Yes, that's exactly the question. A most simple way is to assume equal probability of heads and tails. However, we can represent our prior belief in terms of a distribution. Let's assume a beta distribution over the probability of heads $p(H) = \theta$ (we will see in later sections why beta and not Gaussian or uniform or something else?). So, our prior distibution $p(\theta)$ is:
$$
p(\theta|\alpha, \beta) = \frac{\theta^{\alpha-1}(1-\theta)^{\beta-1}}{B(\alpha,\beta)}, \alpha,\beta>0\\
B(\alpha, \beta) = \frac{\Gamma(\alpha)\Gamma(\beta)}{\Gamma(\alpha+\beta)}\\
\Gamma(\alpha) = (\alpha-1)!
$$
Here, $\alpha$ and $\beta$ are the hyperparameters of the beta distrubution. $B$ is Beta function. You may play with [this interactive demo](https://huggingface.co/spaces/Zeel/Beta_distribution) to see how pdf changes with $\alpha$ and $\beta$. In our modeling, we can assume that $\alpha$ and $\beta$ are already known. There are methods of assuming distributions over the $\alpha$ and $\beta$ as well but that's out of the scope for now.
### Likelihood
Likelihood is probability of observing the data $D$ given $\theta$. From, $n$ number of experiments, if we received heads $h$ times, then $p(D|\theta)$ follows a Bernoulli distribution. We can also arrive at this formula by following the basic probability rules for independent events:
$$
p(D|\theta) = \theta^h(1-\theta)^{n-h}
$$
### Maximum likelihood estimation (MLE)
In cases, where prior is not available, we can use likelihood to get the best estimate of $\theta$. Let us find the optimal theta by differentiating likelihood $p(D|\theta)$ w.r.t $\theta$.
\begin{align}
p(D|\theta) &= (\theta)^h(1-\theta)^{n-h}\\
\text{taking log both sides to simplify things,}\\
\log p(D|\theta) &= h\log(\theta)+(n-h)\log(1-\theta)\\
\frac{d}{d\theta}\log p(D|\theta) &= \frac{h}{\theta} - \frac{n-h}{1-\theta} = 0\\
&= h(1-\theta)-(n-h)\theta = 0\\
&= h - h\theta - n\theta + h\theta = 0\\
\therefore \theta_{MLE} = \frac{h}{n}
\end{align}
How can we know if optima at $\theta_{MLE}$ is a maxima? well, it is a maxima if $\frac{d^2}{d\theta^2}\log p(D|\theta)$ is negative [(check here if not convinced)](https://www.khanacademy.org/math/multivariable-calculus/applications-of-multivariable-derivatives/optimizing-multivariable-functions/a/second-partial-derivative-test):
\begin{align}
\frac{d}{d\theta}\log p(D|\theta) &= \frac{h}{\theta} - \frac{n-h}{1-\theta}\\
\frac{d^2}{d\theta^2}\log p(D|\theta) &= -\frac{h}{\theta^2}-\frac{n-h}{(1-\theta)^2}
\end{align}
After a bit of thinking, one can see that above value is always negative and thus our optima is a maxima.
### Maximum a posteriori estimation (MAP)
We know that posterior is given by the following formula:
\begin{equation}
\underbrace{p(\theta|D)}_{\text{Posterior}} = \frac{\overbrace{p(D|\theta)}^{\text{Likelihood}}}{\underbrace{p(D)}_{\text{Evidence}}}\underbrace{p(\theta)}_{\text{Prior}}
\end{equation}
If we are only interested in maximum probable value of $\theta$ in the posterior (point estimate in other words), we can differentiate the posterior w.r.t. $\theta$. However, we have not yet derived the evidence but it does not depend on $\theta$. So, we can claim that the following is true:
$$
\arg \max_{\theta} p(\theta|D) = \arg \max_{\theta} p(D|\theta)p(\theta)
$$
Now, differentiating $p(D|\theta)p(\theta)$ w.r.t $\theta$:
\begin{align}
p(D|\theta)p(\theta) &= \theta^h(1-\theta)^{N-h}\cdot\frac{\theta^{\alpha-1}(1-\theta)^{\beta-1}}{B(\alpha, \beta)}\\
&= \frac{\theta^{h+\alpha-1}(1-\theta)^{N-h+\beta-1}}{B(\alpha, \beta)}\\
\text{Taking log for simplification}\\
\log p(\theta|D)p(\theta) &= (h+\alpha-1)\log(\theta) + (N-h+\beta-1)\log(1-\theta) - \log(B(\alpha, \beta))\\
\\
\frac{d}{d\theta} \log p(\theta|D)p(\theta) &= \frac{h+\alpha-1}{\theta} - \frac{N-h+\beta-1}{1-\theta} = 0\\
\\
\therefore \theta_{MAP} = \frac{h+(\alpha-1)}{N+(\alpha-1)+(\beta-1)}
\end{align}
Now, we have the maximum probable value of $\theta$ from the posterior but if we are interested in the posterior distribution, we must get the evidence!
### Evidence
The formula for computing the evidence is the following:
$$
p(D) = \int\limits_{\theta}p(D|\theta)p(\theta)d\theta
$$
Substituting the values and deriving the formula:
\begin{align}
p(D) &= \int\limits_{0}^{1}p(D|\theta)p(\theta)d\theta\\
&= \int\limits_{0}^{1}(\theta)^h(1-\theta)^{N-h}\frac{\theta^{\alpha-1}(1-\theta)^{\beta-1}}{B(\alpha,\beta)}d\theta\\
&= \frac{1}{B(\alpha,\beta)}\int\limits_{0}^{1}(\theta)^{h+\alpha-1}(1-\theta)^{N-h+\beta-1}d\theta\\
&= \frac{1}{B(\alpha,\beta)}B(h+\alpha, N-h+\beta)\\
\therefore p(D) = \frac{B(h+\alpha, N-h+\beta)}{B(\alpha,\beta)}
\end{align}
The last step follows from definition of [the Beta function](https://en.wikipedia.org/wiki/Beta_function).
### Posterior
Now, we have all the required terms to compute the posterior $p(\theta|D)$.
\begin{align}
p(\theta|D) &= \frac{p(D|\theta)}{p(D)}p(\theta)\\
&= \theta^h(1-\theta)^{n-h} \cdot \frac{B(\alpha,\beta)}{B(h+\alpha, N-h+\beta)} \cdot \frac{\theta^{\alpha-1}(1-\theta)^{\beta-1}}{B(\alpha,\beta)}\\
&= \frac{\theta^{h+\alpha-1}(1-\theta)^{N-h+\beta-1}}{B(h+\alpha, N-h+\beta)}
\\
\therefore p(\theta|D) = Beta(h+\alpha, N-h+\beta)
\end{align}
We have successfully derived the posterior and it follows a Beta distribution.
## MAP is not the expected value of the posterior
From [Wikipedia](https://en.wikipedia.org/wiki/Beta_distribution), expected value of our posterior is:
$$
\mathbb{E}_{\theta}(p(\theta|D)) = \frac{h+\alpha}{N + \alpha + \beta}
$$
We derived the MAP as:
$$
\theta_{MAP} = \frac{h+(\alpha-1)}{N+(\alpha-1)+(\beta-1)}
$$
We can see that both values are clearly different.
|
(* Title: HOL/Auth/n_germanSymIndex_lemma_inv__45_on_rules.thy
Author: Yongjian Li and Kaiqiang Duan, State Key Lab of Computer Science, Institute of Software, Chinese Academy of Sciences
Copyright 2016 State Key Lab of Computer Science, Institute of Software, Chinese Academy of Sciences
*)
header{*The n_germanSymIndex Protocol Case Study*}
theory n_germanSymIndex_lemma_inv__45_on_rules imports n_germanSymIndex_lemma_on_inv__45
begin
section{*All lemmas on causal relation between inv__45*}
lemma lemma_inv__45_on_rules:
assumes b1: "r \<in> rules N" and b2: "(\<exists> p__Inv0 p__Inv2. p__Inv0\<le>N\<and>p__Inv2\<le>N\<and>p__Inv0~=p__Inv2\<and>f=inv__45 p__Inv0 p__Inv2)"
shows "invHoldForRule s f r (invariants N)"
proof -
have c1: "(\<exists> i d. i\<le>N\<and>d\<le>N\<and>r=n_Store i d)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendReqS i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendReqE__part__0 i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendReqE__part__1 i)\<or>
(\<exists> i. i\<le>N\<and>r=n_RecvReqS N i)\<or>
(\<exists> i. i\<le>N\<and>r=n_RecvReqE N i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendInv__part__0 i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendInv__part__1 i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendInvAck i)\<or>
(\<exists> i. i\<le>N\<and>r=n_RecvInvAck i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendGntS i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendGntE N i)\<or>
(\<exists> i. i\<le>N\<and>r=n_RecvGntS i)\<or>
(\<exists> i. i\<le>N\<and>r=n_RecvGntE i)"
apply (cut_tac b1, auto) done
moreover {
assume d1: "(\<exists> i d. i\<le>N\<and>d\<le>N\<and>r=n_Store i d)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_StoreVsinv__45) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendReqS i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendReqSVsinv__45) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendReqE__part__0 i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendReqE__part__0Vsinv__45) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendReqE__part__1 i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendReqE__part__1Vsinv__45) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_RecvReqS N i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_RecvReqSVsinv__45) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_RecvReqE N i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_RecvReqEVsinv__45) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendInv__part__0 i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendInv__part__0Vsinv__45) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendInv__part__1 i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendInv__part__1Vsinv__45) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendInvAck i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendInvAckVsinv__45) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_RecvInvAck i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_RecvInvAckVsinv__45) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendGntS i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendGntSVsinv__45) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendGntE N i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendGntEVsinv__45) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_RecvGntS i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_RecvGntSVsinv__45) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_RecvGntE i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_RecvGntEVsinv__45) done
}
ultimately show "invHoldForRule s f r (invariants N)"
by satx
qed
end
|
(* Title: HOL/Auth/n_germanSimp_lemma_inv__8_on_rules.thy
Author: Yongjian Li and Kaiqiang Duan, State Key Lab of Computer Science, Institute of Software, Chinese Academy of Sciences
Copyright 2016 State Key Lab of Computer Science, Institute of Software, Chinese Academy of Sciences
*)
header{*The n_germanSimp Protocol Case Study*}
theory n_germanSimp_lemma_inv__8_on_rules imports n_germanSimp_lemma_on_inv__8
begin
section{*All lemmas on causal relation between inv__8*}
lemma lemma_inv__8_on_rules:
assumes b1: "r \<in> rules N" and b2: "(\<exists> p__Inv4. p__Inv4\<le>N\<and>f=inv__8 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
proof -
have c1: "(\<exists> i d. i\<le>N\<and>d\<le>N\<and>r=n_Store i d)\<or>
(\<exists> i. i\<le>N\<and>r=n_RecvReqS N i)\<or>
(\<exists> i. i\<le>N\<and>r=n_RecvReqE__part__0 N i)\<or>
(\<exists> i. i\<le>N\<and>r=n_RecvReqE__part__1 N i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendInv__part__0 i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendInv__part__1 i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendInvAck i)\<or>
(\<exists> i. i\<le>N\<and>r=n_RecvInvAck i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendGntS i)\<or>
(\<exists> i. i\<le>N\<and>r=n_SendGntE N i)\<or>
(\<exists> i. i\<le>N\<and>r=n_RecvGntS i)\<or>
(\<exists> i. i\<le>N\<and>r=n_RecvGntE i)"
apply (cut_tac b1, auto) done
moreover {
assume d1: "(\<exists> i d. i\<le>N\<and>d\<le>N\<and>r=n_Store i d)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_StoreVsinv__8) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_RecvReqS N i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_RecvReqSVsinv__8) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_RecvReqE__part__0 N i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_RecvReqE__part__0Vsinv__8) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_RecvReqE__part__1 N i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_RecvReqE__part__1Vsinv__8) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendInv__part__0 i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendInv__part__0Vsinv__8) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendInv__part__1 i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendInv__part__1Vsinv__8) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendInvAck i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendInvAckVsinv__8) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_RecvInvAck i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_RecvInvAckVsinv__8) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendGntS i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendGntSVsinv__8) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_SendGntE N i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_SendGntEVsinv__8) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_RecvGntS i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_RecvGntSVsinv__8) done
}
moreover {
assume d1: "(\<exists> i. i\<le>N\<and>r=n_RecvGntE i)"
have "invHoldForRule s f r (invariants N)"
apply (cut_tac b2 d1, metis n_RecvGntEVsinv__8) done
}
ultimately show "invHoldForRule s f r (invariants N)"
by satx
qed
end
|
theory step_rel
imports memory_model trans_sim
begin
locale step_rel = memory_model
where free_set = "free_set :: 'memory \<Rightarrow> 'loc set"
and can_read = "can_read :: 'memory \<Rightarrow> 'thread \<Rightarrow> 'loc \<Rightarrow> 'val set"
and update_mem=
"update_mem::'memory \<Rightarrow> ('thread, 'loc, 'val) access set \<Rightarrow> 'memory \<Rightarrow> bool"
and start_mem = "start_mem:: 'memory"
for free_set and can_read and update_mem and start_mem +
fixes step_rel::"'thread \<Rightarrow> ('node, 'edge_type, 'instr) flowgraph \<Rightarrow> 'memory \<Rightarrow> 'config \<Rightarrow>
('thread, 'loc, 'val) access set \<Rightarrow> 'config \<Rightarrow> bool"
and start_state::"('thread \<rightharpoonup> ('node, 'edge_type, 'instr) flowgraph)
\<Rightarrow> ('thread \<rightharpoonup> 'config) \<Rightarrow> 'memory \<Rightarrow> bool"
and get_point::"'config \<Rightarrow> 'node"
and instr_edges::"'instr \<Rightarrow> ('edge_type \<Rightarrow> nat) set"
and Seq::'edge_type
assumes start_points [simp]: "start_state CFGs S m
\<Longrightarrow> (\<lambda> x . case S x of Some a \<Rightarrow> (\<lambda>C. Some (get_point C)) a
| None \<Rightarrow> None) = start_points CFGs"
and step_along_edge: "\<lbrakk>step_rel t G m C ops C'; is_flowgraph G Seq instr_edges; get_point C \<in> Nodes G\<rbrakk> \<Longrightarrow>
\<exists>ty. (get_point C, get_point C', ty) \<in> Edges (G::('node, 'edge_type, 'instr) flowgraph)"
begin
lemma step_safe: "\<lbrakk>step_rel t G m C ops C'; is_flowgraph G Seq instr_edges; get_point C \<in> Nodes G\<rbrakk> \<Longrightarrow>
get_point C' \<in> Nodes G"
by (drule step_along_edge, simp+, simp add: is_flowgraph_def flowgraph_def pointed_graph_def)
abbreviation "well_formed G \<equiv> is_flowgraph G Seq instr_edges"
inductive one_step where
step_single [intro!]: "\<lbrakk>step_rel t G mem C ops C'; update_mem mem ops mem'\<rbrakk> \<Longrightarrow>
one_step t G (C, mem) (C', mem')"
lemma one_step_safe: "\<lbrakk>one_step t G (C, mem) (C', mem'); well_formed G; get_point C \<in> Nodes G\<rbrakk> \<Longrightarrow>
get_point C' \<in> Nodes G"
by (erule one_step.cases, rule step_safe, simp+)
lemma one_step_along_edge: "\<lbrakk>one_step t G (C, m) (C', m'); is_flowgraph G Seq instr_edges;
get_point C \<in> Nodes G\<rbrakk> \<Longrightarrow> \<exists>ty. (get_point C, get_point C', ty) \<in> Edges G"
by (erule one_step.cases, rule step_along_edge, simp+)
inductive conc_step where
step_thread [intro]: "\<lbrakk>CFGs t = Some G; states t = Some C; step_rel t G mem C ops C';
update_mem mem ops mem'\<rbrakk> \<Longrightarrow> conc_step CFGs (states, mem) (states(t \<mapsto> C'), mem')"
abbreviation "get_points (S::'thread \<rightharpoonup> 'config) \<equiv>
(\<lambda> x . case S x of Some a \<Rightarrow> (\<lambda>C. Some (get_point C)) a
| None \<Rightarrow> None)"
lemma one_step_conc_step: "\<lbrakk>one_step t G (C, m) (C', m'); CFGs t = Some G; states t = Some C\<rbrakk> \<Longrightarrow>
conc_step CFGs (states, m) (states(t \<mapsto> C'), m')"
by (erule one_step.cases, rule step_thread, auto)
lemma conc_step_safe: "\<lbrakk>conc_step CFGs (states, mem) (states', mem'); tCFG CFGs instr_edges Seq;
safe_points CFGs (get_points states)\<rbrakk> \<Longrightarrow>
safe_points CFGs (get_points states')"
apply (erule conc_step.cases, clarsimp simp add: safe_points_def)
apply (case_tac "t = t", clarsimp)
apply (rule step_safe, simp+)
apply (erule tCFG.CFGs, simp)
apply force
apply (force simp add: map_comp_def)
done
lemma conc_steps_safe: "\<lbrakk>(conc_step CFGs)^** (states, mem) (states', mem'); tCFG CFGs instr_edges Seq;
safe_points CFGs (get_points states)\<rbrakk> \<Longrightarrow>
safe_points CFGs (get_points states')"
by (drule_tac P="\<lambda>(states, mem) (states', mem'). safe_points CFGs (get_points states) \<longrightarrow>
safe_points CFGs (get_points states')" in rtranclp.induct, auto intro: conc_step_safe)
definition "run_prog CFGs C \<equiv> \<exists>C0 mem0. start_state CFGs C0 mem0 \<and> (conc_step CFGs)^** (C0, mem0) C"
lemma run_progI [intro]: "\<lbrakk>start_state CFGs C0 mem0; (conc_step CFGs)^** (C0, mem0) C\<rbrakk> \<Longrightarrow>
run_prog CFGs C"
by (force simp add: run_prog_def)
lemma run_prog_conc_step [intro]: "\<lbrakk>run_prog CFGs C; conc_step CFGs C C'\<rbrakk> \<Longrightarrow> run_prog CFGs C'"
by (force simp add: run_prog_def)
lemma run_prog_conc_steps [intro]: "\<lbrakk>run_prog CFGs C; (conc_step CFGs)^** C C'\<rbrakk> \<Longrightarrow> run_prog CFGs C'"
by (force simp add: run_prog_def)
lemma run_prog_induct [elim]: "\<lbrakk>run_prog CFGs C; \<And>C0 mem0. start_state CFGs C0 mem0 \<Longrightarrow> P (C0, mem0);
\<And>C C'. run_prog CFGs C \<Longrightarrow> P C \<Longrightarrow> conc_step CFGs C C' \<Longrightarrow> P C'\<rbrakk> \<Longrightarrow> P C"
apply (clarsimp simp add: run_prog_def)
apply (drule_tac P="\<lambda>C C'. start_state CFGs (fst C) (snd C) \<longrightarrow> P C'" in rtranclp.induct, auto)
by (metis (mono_tags))
lemma run_prog_one_step: "\<lbrakk>run_prog CFGs (S, mem); S t = Some s; CFGs t = Some G;
one_step t G (s, mem) (s', mem')\<rbrakk> \<Longrightarrow> run_prog CFGs (S(t \<mapsto> s'), mem')"
by (erule run_prog_conc_step, erule one_step.cases, auto)
lemma run_prog_one_steps: "\<lbrakk>run_prog CFGs (S, mem); S t = Some s; CFGs t = Some G;
(one_step t G)^** (s, mem) (s', mem')\<rbrakk> \<Longrightarrow> run_prog CFGs (S(t \<mapsto> s'), mem')"
apply (drule_tac P="\<lambda>(s, mem) (s', mem'). run_prog CFGs (S, mem) \<and> S t = Some s \<and> CFGs t = Some G \<longrightarrow>
run_prog CFGs (S(t \<mapsto> s'), mem')" in rtranclp.induct, auto simp add: map_upd_triv)
apply (drule_tac mem=ba in run_prog_one_step, simp+, force, simp+)
done
lemma run_prog_step: "\<lbrakk>run_prog CFGs (S, mem); S t = Some s; CFGs t = Some G;
step_rel t G mem s ops s'; update_mem mem ops mem'\<rbrakk> \<Longrightarrow> run_prog CFGs (S(t \<mapsto> s'), mem')"
by (erule run_prog_one_step, auto)
lemma run_prog_safe: "\<lbrakk>run_prog CFGs (S, mem); tCFG CFGs instr_edges Seq\<rbrakk> \<Longrightarrow>
safe_points CFGs (get_points S)"
proof - assume "tCFG CFGs instr_edges Seq" then interpret tCFG .
show "\<lbrakk>run_prog CFGs (S, mem); tCFG CFGs instr_edges Seq\<rbrakk> \<Longrightarrow>
safe_points CFGs (get_points S)"
by (clarsimp simp add: run_prog_def, rule conc_steps_safe, simp+)
qed
(* paths *)
lemma step_increment_path: "\<lbrakk>step_rel t G m C a C'; tCFG CFGs instr_edges Seq; CFGs t = Some G;
l \<in> pre_tCFG.Paths CFGs ps; p = get_point C; p' = get_point C'; ps t = Some p'; p \<in> Nodes G\<rbrakk> \<Longrightarrow>
[ps(t \<mapsto> p)] \<frown> l \<in> pre_tCFG.Paths CFGs (ps(t \<mapsto> p))"
proof - assume "tCFG CFGs instr_edges Seq" then interpret tCFG .
show "\<lbrakk>step_rel t G m C a C'; tCFG CFGs instr_edges Seq; CFGs t = Some G;
l \<in> pre_tCFG.Paths CFGs ps; p = get_point C; p' = get_point C'; ps t = Some p'; p \<in> Nodes G\<rbrakk> \<Longrightarrow>
[ps(t \<mapsto> p)] \<frown> l \<in> pre_tCFG.Paths CFGs (ps(t \<mapsto> p))"
apply (rule pre_tCFG.path_incremental_gen, unfold_locales, simp)
apply (frule step_along_edge)
apply (erule tCFG.CFGs, simp+)
done
qed
lemma step_increment_rpath: "\<lbrakk>step_rel t G m C a C'; tCFG CFGs instr_edges Seq; CFGs t = Some G;
l \<in> pre_tCFG.RPaths CFGs ps; p0 = get_point C; p = get_point C'; ps t = Some p0; p0 \<in> Nodes G\<rbrakk> \<Longrightarrow>
[ps(t \<mapsto> p)] \<frown> l \<in> pre_tCFG.RPaths CFGs (ps(t \<mapsto> p))"
proof - assume "tCFG CFGs instr_edges Seq" then interpret tCFG .
show "\<lbrakk>step_rel t G m C a C'; tCFG CFGs instr_edges Seq; CFGs t = Some G;
l \<in> pre_tCFG.RPaths CFGs ps; p0 = get_point C; p = get_point C'; ps t = Some p0; p0 \<in> Nodes G\<rbrakk> \<Longrightarrow>
[ps(t \<mapsto> p)] \<frown> l \<in> pre_tCFG.RPaths CFGs (ps(t \<mapsto> p))"
apply (rule rpath_incremental_gen, simp+, clarsimp)
apply (frule step_along_edge)
apply (erule tCFG.CFGs, simp+)
done
qed
lemma one_step_increment_path: "\<lbrakk>one_step t G (C, m) (C', m'); tCFG CFGs instr_edges Seq; CFGs t = Some G;
l \<in> pre_tCFG.Paths CFGs ps; p = get_point C; p' = get_point C'; ps t = Some p'; p \<in> Nodes G\<rbrakk> \<Longrightarrow>
[ps(t \<mapsto> p)] \<frown> l \<in> pre_tCFG.Paths CFGs (ps(t \<mapsto> p))"
by (erule one_step.cases, rule step_increment_path, simp+)
lemma one_step_increment_rpath: "\<lbrakk>one_step t G (C, m) (C', m'); tCFG CFGs instr_edges Seq; CFGs t = Some G;
l \<in> pre_tCFG.RPaths CFGs ps; p0 = get_point C; p = get_point C'; ps t = Some p0; p0 \<in> Nodes G\<rbrakk> \<Longrightarrow>
[ps(t \<mapsto> p)] \<frown> l \<in> pre_tCFG.RPaths CFGs (ps(t \<mapsto> p))"
by (erule one_step.cases, rule step_increment_rpath, simp+)
lemma conc_step_increment_path: "\<lbrakk>conc_step CFGs C C'; tCFG CFGs instr_edges Seq;
l \<in> pre_tCFG.Paths CFGs (get_points (fst C')); safe_points CFGs (get_points (fst C))\<rbrakk> \<Longrightarrow>
[get_points (fst C)] \<frown> l \<in> pre_tCFG.Paths CFGs (get_points (fst C))"
apply (auto elim!: conc_step.cases)
apply (frule_tac ps="get_points (states(t \<mapsto> C'a))" in step_increment_path, auto simp add: safe_points_def)
apply force
apply (subgoal_tac "get_points (states(t \<mapsto> C'a))(t \<mapsto> get_point Ca) = get_points states", simp)
apply (rule ext, clarsimp simp add: map_comp_def)
done
lemma conc_steps_path: "\<lbrakk>(conc_step CFGs)^** (states, mem) (states', mem'); tCFG CFGs instr_edges Seq;
l \<in> pre_tCFG.Paths CFGs (get_points states'); safe_points CFGs (get_points states)\<rbrakk> \<Longrightarrow>
\<exists>l'. hd (l' @ [l 0]) = get_points states \<and> l' \<frown> l \<in> pre_tCFG.Paths CFGs (get_points states)"
proof - assume "tCFG CFGs instr_edges Seq" then interpret tCFG .
show "\<lbrakk>(conc_step CFGs)^** (states, mem) (states', mem'); tCFG CFGs instr_edges Seq;
l \<in> pre_tCFG.Paths CFGs (get_points states'); safe_points CFGs (get_points states)\<rbrakk> \<Longrightarrow>
\<exists>l'. hd (l' @ [l 0]) = get_points states \<and> l' \<frown> l \<in> pre_tCFG.Paths CFGs (get_points states)"
apply (drule_tac P="\<lambda>(states, mem) (states', mem'). \<forall>l. l \<in> pre_tCFG.Paths CFGs (get_points states') \<and>
safe_points CFGs (get_points states) \<longrightarrow> (\<exists>l'. hd (l' @ [l 0]) = get_points states \<and>
l' \<frown> l \<in> pre_tCFG.Paths CFGs (get_points states))" in rtranclp.induct, auto)
apply (rule_tac x="[]" in exI, simp)
apply (drule conc_step_increment_path, simp+)
apply (drule conc_steps_safe, simp+)
by (metis append_is_Nil_conv hd_append2 i_append_assoc i_append_nth_Cons_0 not_Cons_self2)
qed
lemma run_prog_path: "\<lbrakk>run_prog CFGs C; tCFG CFGs instr_edges Seq\<rbrakk> \<Longrightarrow>
\<exists>C0 mem0. start_state CFGs C0 mem0 \<and> (\<exists>l\<in>pre_tCFG.Paths CFGs (start_points CFGs). \<exists>i. l i = get_points (fst C))"
proof - assume "tCFG CFGs instr_edges Seq" then interpret tCFG .
show "\<lbrakk>run_prog CFGs C; tCFG CFGs instr_edges Seq\<rbrakk> \<Longrightarrow>
\<exists>C0 mem0. start_state CFGs C0 mem0 \<and> (\<exists>l\<in>pre_tCFG.Paths CFGs (start_points CFGs). \<exists>i. l i = get_points (fst C))"
apply (clarsimp simp add: run_prog_def)
apply (cut_tac q="get_points (fst C)" in exists_path, clarsimp)
apply (case_tac C, clarsimp)
apply (drule conc_steps_path, simp+)
apply clarsimp
apply (rule conjI, force)
apply (rule_tac x="l' \<frown> l" in bexI, simp_all)
apply (rule_tac x="length l'" in exI, simp)
done
qed
(* The step-star relation as inducing a list of intermediate states. *)
lemma conc_step_star_steps: "(conc_step CFGs)^** C C' \<Longrightarrow>
\<exists>l. hd (l @ [C']) = C \<and> (\<forall>i<length l. conc_step CFGs (l ! i) ((l @ [C']) ! Suc i))"
apply (induct rule: rtranclp_induct, auto)
apply (rule_tac x="[]" in exI, simp)
apply (rule_tac x="l @ [(a, b)]" in exI, clarsimp)
apply (rule conjI, case_tac l, simp+)
apply clarsimp
apply (case_tac "i = length l", clarsimp simp add: nth_append)
apply (erule_tac x=i in allE, auto simp add: nth_append)
done
lemma step_star_path: "\<lbrakk>hd (l' @ [C']) = C; \<forall>i<length l'. conc_step CFGs (l' ! i) ((l' @ [C']) ! Suc i);
l \<in> pre_tCFG.Paths CFGs (get_points (fst C')); safe_points CFGs (get_points (fst C)); tCFG CFGs instr_edges Seq\<rbrakk> \<Longrightarrow>
map (get_points o fst) l' \<frown> l \<in> pre_tCFG.Paths CFGs (get_points (fst C))"
apply (induct l' arbitrary: C l, auto)
apply (case_tac l', auto)
apply (drule conc_step_increment_path, simp+)
apply (subgoal_tac "(get_points a # map (get_points \<circ> fst) list) \<frown> l \<in> pre_tCFG.Paths CFGs (get_points a)")
apply (erule_tac x=0 in allE, clarsimp)
apply (drule conc_step_increment_path, simp+)
apply (subgoal_tac "\<forall>i<Suc (length list). conc_step CFGs (((a, b) # list) ! i) ((list @ [C']) ! i)")
apply (subgoal_tac "safe_points CFGs (get_points a)", force)
apply (erule_tac x=0 in allE, clarsimp, rule conc_step_safe, auto)
done
lemma run_prog_steps: "\<lbrakk>run_prog CFGs C; tCFG CFGs instr_edges Seq\<rbrakk> \<Longrightarrow>
\<exists>l C0 mem0. start_state CFGs C0 mem0 \<and>
(\<forall>i<length l. conc_step CFGs (l ! i) ((l @ [C]) ! Suc i)) \<and>
(\<exists>l'\<in>pre_tCFG.Paths CFGs (get_points (fst C)). map (get_points o fst) l \<frown> l' \<in> pre_tCFG.Paths CFGs (start_points CFGs))"
proof - assume "tCFG CFGs instr_edges Seq" then interpret tCFG .
show "\<lbrakk>run_prog CFGs C; tCFG CFGs instr_edges Seq\<rbrakk> \<Longrightarrow>
\<exists>l C0 mem0. start_state CFGs C0 mem0 \<and>
(\<forall>i<length l. conc_step CFGs (l ! i) ((l @ [C]) ! Suc i)) \<and>
(\<exists>l'\<in>pre_tCFG.Paths CFGs (get_points (fst C)). map (get_points o fst) l \<frown> l' \<in> pre_tCFG.Paths CFGs (start_points CFGs))"
apply (clarsimp simp add: run_prog_def)
apply (drule conc_step_star_steps, clarsimp)
apply (cut_tac q="get_points (fst C)" in exists_path, clarsimp)
apply (frule step_star_path, simp+)
apply (rule conjI, force+)
done
qed
lemma conc_step_star_path2: "\<lbrakk>(conc_step CFGs)^** C C'; l \<in> pre_tCFG.Paths CFGs (get_points (fst C'));
safe_points CFGs (get_points (fst C)); tCFG CFGs instr_edges Seq\<rbrakk> \<Longrightarrow>
\<exists>l'. hd (l' @ [l 0]) = get_points (fst C) \<and> l' \<frown> l \<in> pre_tCFG.Paths CFGs (get_points (fst C)) \<and>
(\<forall>i<length l'. \<exists>C''. l' ! i = get_points (fst C'') \<and> (conc_step CFGs)^** C C'' \<and> (conc_step CFGs)^** C'' C')"
proof - assume "tCFG CFGs instr_edges Seq" then interpret tCFG .
show "\<lbrakk>(conc_step CFGs)^** C C'; l \<in> pre_tCFG.Paths CFGs (get_points (fst C'));
safe_points CFGs (get_points (fst C)); tCFG CFGs instr_edges Seq\<rbrakk> \<Longrightarrow>
\<exists>l'. hd (l' @ [l 0]) = get_points (fst C) \<and> l' \<frown> l \<in> pre_tCFG.Paths CFGs (get_points (fst C)) \<and>
(\<forall>i<length l'. \<exists>C''. l' ! i = get_points (fst C'') \<and> (conc_step CFGs)^** C C'' \<and> (conc_step CFGs)^** C'' C')"
apply (induct arbitrary: l rule: rtranclp_induct, auto)
apply (rule_tac x="[]" in exI, simp)
apply (frule conc_step_increment_path, simp+)
apply (case_tac C, rule conc_steps_safe, simp+)
apply (subgoal_tac "\<exists>l'. hd (l' @ [get_points a]) = get_points (fst C) \<and> l' \<frown> [get_points a] \<frown> l \<in>
pre_tCFG.Paths CFGs (get_points (fst C)) \<and> (\<forall>i<length l'. \<exists>aa. l' ! i = get_points aa \<and> (\<exists>ba.
(conc_step CFGs)^** C (aa, ba) \<and> (conc_step CFGs)^** (aa, ba) (a, b)))", clarsimp)
apply (rule_tac x="l' @ [get_points a]" in exI, clarsimp)
apply (rule conjI, case_tac l', simp+)
apply clarsimp
apply (case_tac "i = length l'", clarsimp)
apply (rule_tac x=a in exI, simp, rule_tac x=b in exI, simp)
apply (erule_tac x=i in allE, clarsimp)
apply (rule_tac x=aaa in exI, simp add: nth_append)
apply (rule_tac x=baa in exI, simp)
by (metis i_append_nth_Cons_0)
qed
lemma run_prog_path2: "\<lbrakk>run_prog CFGs C; tCFG CFGs instr_edges Seq\<rbrakk> \<Longrightarrow>
\<exists>C0 mem0. start_state CFGs C0 mem0 \<and> (\<exists>l\<in>pre_tCFG.Paths CFGs (start_points CFGs).
\<exists>i. l i = get_points (fst C) \<and> (\<forall>j<i. \<exists>C'. run_prog CFGs C' \<and> l j = get_points (fst C')))"
proof - assume "tCFG CFGs instr_edges Seq" then interpret tCFG .
show "\<lbrakk>run_prog CFGs C; tCFG CFGs instr_edges Seq\<rbrakk> \<Longrightarrow>
\<exists>C0 mem0. start_state CFGs C0 mem0 \<and> (\<exists>l\<in>pre_tCFG.Paths CFGs (start_points CFGs).
\<exists>i. l i = get_points (fst C) \<and> (\<forall>j<i. \<exists>C'. run_prog CFGs C' \<and> l j = get_points (fst C')))"
apply (clarsimp simp add: run_prog_def)
apply (cut_tac q="get_points (fst C)" in exists_path, clarsimp)
apply (drule conc_step_star_path2, simp+)
apply clarsimp
apply (rule conjI, force)
apply (rule_tac x="l' \<frown> l" in bexI, simp_all)
apply (rule_tac x="length l'" in exI, clarsimp)
by smt
qed
lemma run_prog_rpath: "\<lbrakk>run_prog CFGs C; tCFG CFGs instr_edges Seq\<rbrakk> \<Longrightarrow>
\<exists>l. l \<in> pre_tCFG.RPaths CFGs (get_points (fst C))"
proof - assume "tCFG CFGs instr_edges Seq" then interpret tCFG .
show "\<lbrakk>run_prog CFGs C; tCFG CFGs instr_edges Seq\<rbrakk> \<Longrightarrow>
\<exists>l. l \<in> pre_tCFG.RPaths CFGs (get_points (fst C))"
by (drule run_prog_path, simp, clarsimp, drule_tac i=i in reverse_path, simp, force)
qed
(* simulation relations and lifting *)
definition "lift_reach_sim_rel sim_rel CFGs CFGs' t C C' \<equiv>
run_prog CFGs C \<and> run_prog CFGs' C' \<and> (case (C, C') of ((states, mem), (states', mem')) \<Rightarrow>
(\<exists>s s' G G'. states t = Some s \<and> states' t = Some s' \<and> CFGs t = Some G \<and> CFGs' t = Some G' \<and>
sim_rel G G' (s, mem) (s', mem')) \<and> (\<forall>t'. t' \<noteq> t \<longrightarrow> states t' = states' t'))"
definition "add_reach CFGs CFGs' t sim_rel G G' c c' \<equiv> \<exists>S S'. S t = Some (fst c) \<and>
run_prog CFGs (S, snd c) \<and> S' t = Some (fst c') \<and> run_prog CFGs' (S', snd c') \<and> sim_rel G G' c c'"
lemma add_reach_sim_rel: "\<lbrakk>sim_rel G G' c c'; \<exists>S S'. S t = Some (fst c) \<and> run_prog CFGs (S, snd c) \<and>
S' t = Some (fst c') \<and> run_prog CFGs' (S', snd c')\<rbrakk> \<Longrightarrow>
add_reach CFGs CFGs' t sim_rel G G' c c'"
by (simp add: add_reach_def)
end
locale sim_base = step_rel
where free_set = "free_set :: 'memory \<Rightarrow> 'loc set"
and can_read = "can_read :: 'memory \<Rightarrow> 'thread \<Rightarrow> 'loc \<Rightarrow> 'val set"
and start_state="start_state::('thread \<rightharpoonup> ('node, 'edge_type, 'instr) flowgraph) \<Rightarrow>
('thread \<rightharpoonup> 'config) \<Rightarrow> 'memory \<Rightarrow> bool"
and update_mem=
"update_mem::'memory \<Rightarrow> ('thread, 'loc, 'val) access set \<Rightarrow> 'memory \<Rightarrow> bool"
and step_rel = "step_rel ::
'thread
\<Rightarrow> ('node, 'edge_type, 'instr) flowgraph
\<Rightarrow> 'memory \<Rightarrow> 'config \<Rightarrow> ('thread, 'loc, 'val) access set \<Rightarrow> 'config \<Rightarrow> bool"
and start_mem = "start_mem:: 'memory"
and get_point="get_point::'config \<Rightarrow> 'node"
and instr_edges="instr_edges::'instr \<Rightarrow> ('edge_type \<Rightarrow> nat) set"
and Seq="Seq::'edge_type"+
tCFG?: tCFG
where CFGs="CFGs::('thread \<rightharpoonup> ('node, 'edge_type, 'instr) flowgraph)"
and instr_edges="instr_edges::'instr \<Rightarrow> ('edge_type \<Rightarrow> nat) set"
and Seq="Seq::'edge_type" +
tCFG': tCFG
where CFGs="CFGs'::('thread \<rightharpoonup> ('node, 'edge_type, 'instr) flowgraph)"
and instr_edges="instr_edges::'instr \<Rightarrow> ('edge_type \<Rightarrow> nat) set"
and Seq="Seq::'edge_type"
for free_set can_read step_rel get_point instr_edges Seq start_state update_mem start_mem CFGs CFGs' +
assumes step_read_ops: "\<lbrakk>step_rel t G mem C ops C'; CFGs t = Some G;
\<forall>l\<in>get_ptrs ops. can_read mem t l = can_read mem' t l; free_set mem = free_set mem'\<rbrakk> \<Longrightarrow>
step_rel t G mem' C ops C'"
and ops_thread: "\<lbrakk>step_rel t G mem state ops state'; CFGs t = Some G; a \<in> ops\<rbrakk> \<Longrightarrow> get_thread a = t"
begin
lemma sim_by_reachable_thread_mem_obs [rule_format]:
"\<lbrakk>tCFG_sim (add_reach CFGs' CFGs t sim_rel G' G) (=) G' G (one_step t) obs (get_mem o snd);
CFGs t = Some G; CFGs' t = Some G'; \<forall>t'. t' \<noteq> t \<longrightarrow> CFGs t' = CFGs' t'; \<forall>mem s mem' s'.
sim_rel G' G (s, mem) (s', mem') \<longrightarrow> (\<forall>S. run_prog CFGs' (S, mem) \<longrightarrow> (free_set mem = free_set mem' \<and>
(\<forall>t' ops s1 s2. run_prog CFGs' (S, mem) \<and> run_prog CFGs (S(t \<mapsto> s'), mem') \<and> S t = Some s \<and>
S t' = Some s1 \<and> t' \<noteq> t \<and> t' \<in> dom CFGs \<longrightarrow> (step_rel t' (the (CFGs t')) mem s1 ops s2 \<longrightarrow>
(\<forall>l\<in>get_ptrs ops. can_read mem t' l = can_read mem' t' l)) \<and>
(step_rel t' (the (CFGs t')) mem' s1 ops s2 \<longrightarrow> (\<forall>mem2. update_mem mem ops mem2 \<and> t \<notin> get_thread ` ops \<longrightarrow>
(\<exists>mem2'. update_mem mem' ops mem2' \<and> (\<forall>l\<in>obs. get_mem mem2' l = get_mem mem2 l) \<and> sim_rel G' G (s, mem2) (s', mem2')))))))\<rbrakk> \<Longrightarrow>
tCFG_sim (lift_reach_sim_rel sim_rel CFGs' CFGs t) (=) CFGs' CFGs conc_step obs (get_mem o snd)"
apply (simp add: tCFG_sim_def, unfold_locales, clarsimp simp add: trsys_of_tCFG_def)
apply (rule conc_step.cases, simp+, clarsimp simp add: lift_reach_sim_rel_def)
apply (rule conjI, clarsimp)
apply (drule_tac sa="(C, mem)" and sb="(s', ba)" in simulation.simulation)
apply (clarsimp simp add: add_reach_def)
apply (rule_tac x=states in exI, simp, rule_tac x=aa in exI, simp)
apply (clarsimp simp add: trsys_of_tCFG_def)
apply (rule conjI, erule step_single, simp+)
apply (clarsimp simp add: trsys_of_tCFG_def add_reach_def)
apply (erule one_step.cases, clarsimp)
apply ((rule exI)+, rule context_conjI, rule_tac t=t in step_thread, simp add: dom_def, simp+)
apply (rule conjI, erule run_prog_step, simp+)
apply (erule run_prog_step, simp+)
apply clarsimp
apply (subgoal_tac "aa = states(t \<mapsto> s')", thin_tac "\<forall>t'. t' \<noteq> t \<longrightarrow> states t' = aa t'",
clarsimp)
apply (erule_tac x=ta in allE)
apply (erule_tac x = mem in allE)
apply (erule_tac x = s in allE)
apply (erule_tac x = mem' in allE)
apply (erule_tac x = s' in allE)
apply (erule impE, simp)
apply (erule_tac x=states in allE, clarsimp)
apply (erule_tac x=ta in allE, erule_tac x=ops in allE, erule_tac x=C in allE, simp, erule impE,
simp add: dom_def)
apply (erule_tac x=C' in allE, clarsimp)
apply (drule_tac mem=mem and mem'=ba in step_read_ops, simp+)
apply (erule_tac x=mem' in allE, clarsimp)
apply (erule impE, clarsimp)
apply (cut_tac t=ta in ops_thread, simp_all, simp+)
apply clarsimp
apply (rule exI, rule_tac x=mem2' in exI, rule context_conjI, rule_tac t=ta in step_thread,
simp add: dom_def, simp+)
apply (rule conjI, erule run_prog_conc_step, simp+)
apply (rule conjI, erule run_prog_conc_step, simp+)
apply (clarsimp intro!: ext simp add: restrict_map_def)
apply (rule ext, simp)
done
(* Slightly reorganized other-threads hypothesis. *)
lemma sim_by_reachable_thread_obs [rule_format]:
"\<lbrakk>tCFG_sim (add_reach CFGs' CFGs t sim_rel G' G) (=) G' G (one_step t) obs (get_mem o snd);
CFGs t = Some G; CFGs' t = Some G'; \<forall>t'. t' \<noteq> t \<longrightarrow> CFGs t' = CFGs' t';
\<forall>mem s mem' s'. sim_rel G' G (s, mem) (s', mem') \<longrightarrow> (free_set mem = free_set mem' \<and>
(\<forall>t' ops s1 s2 S. run_prog CFGs' (S, mem) \<and> run_prog CFGs (S(t \<mapsto> s'), mem') \<and>
S t = Some s \<and> S t' = Some s1 \<and> t' \<noteq> t \<and> t' \<in> dom CFGs \<longrightarrow>
(step_rel t' (the (CFGs t')) mem s1 ops s2 \<longrightarrow> (\<forall>l\<in>get_ptrs ops. can_read mem t' l = can_read mem' t' l)) \<and>
(step_rel t' (the (CFGs t')) mem' s1 ops s2 \<longrightarrow> (\<forall>mem2. update_mem mem ops mem2 \<and> t \<notin> get_thread ` ops \<longrightarrow>
(\<exists> mem2'. update_mem mem' ops mem2' \<and> (\<forall>l\<in>obs. get_mem mem2' l = get_mem mem2 l) \<and> sim_rel G' G (s, mem2) (s', mem2'))))))\<rbrakk> \<Longrightarrow>
tCFG_sim (lift_reach_sim_rel sim_rel CFGs' CFGs t) (=) CFGs' CFGs conc_step obs (get_mem o snd)"
apply (rule sim_by_reachable_thread_mem_obs, simp+)
apply clarsimp
apply (erule_tac x=mem in allE, erule_tac x=s in allE, erule_tac x=mem' in allE,
erule_tac x=s' in allE, erule impE, assumption, clarsimp)
apply (erule_tac x=t' in allE, erule_tac x=ops in allE, erule_tac x=s1 in allE, erule impE)
apply (rule_tac x=S in exI, force)
apply (erule_tac x=s2 in allE, force)
done
lemma sim_by_reachable_thread [rule_format]: "\<lbrakk>tCFG_sim (add_reach CFGs' CFGs t sim_rel G' G) (op =)
G' G (one_step t) UNIV (get_mem o snd); CFGs t = Some G; CFGs' t = Some G';
\<forall>t'. t' \<noteq> t \<longrightarrow> CFGs t' = CFGs' t'; \<forall>mem s mem' s'. sim_rel G' G (s, mem) (s', mem') \<longrightarrow>
(free_set mem = free_set mem' \<and> (\<forall>t'. t' \<noteq> t \<longrightarrow> can_read mem t' = can_read mem' t') \<and>
(\<forall>ops mem2. update_mem mem ops mem2 \<and> t \<notin> get_thread ` ops \<longrightarrow>
(\<exists>mem2'. update_mem mem' ops mem2' \<and> get_mem mem2' = get_mem mem2 \<and> sim_rel G' G (s, mem2) (s', mem2'))))\<rbrakk> \<Longrightarrow>
tCFG_sim (lift_reach_sim_rel sim_rel CFGs' CFGs t) (op =) CFGs' CFGs conc_step UNIV (get_mem o snd)"
apply (erule sim_by_reachable_thread_obs, auto simp add: fun_upd_def)
by (smt UNIV_I UNIV_eq_I domD domI)
lemma sim_no_mem [rule_format]: "\<lbrakk>tCFG_sim (add_reach CFGs' CFGs t sim_rel G' G) (op =)
G' G (one_step t) UNIV (get_mem o snd); CFGs t = Some G; CFGs' t = Some G';
\<forall>t'. t' \<noteq> t \<longrightarrow> CFGs t' = CFGs' t'; \<forall>mem s mem' s'. sim_rel G' G (s, mem) (s', mem') \<longrightarrow> mem = mem';
\<forall>s s' mem ops mem'. sim_rel G' G (s, mem) (s', mem) \<and> t \<notin> get_thread ` ops \<and> update_mem mem ops mem' \<longrightarrow>
sim_rel G' G (s, mem') (s', mem')\<rbrakk> \<Longrightarrow>
tCFG_sim (lift_reach_sim_rel sim_rel CFGs' CFGs t) (op =) CFGs' CFGs conc_step UNIV (get_mem o snd)"
by (rule sim_by_reachable_thread, simp+, metis)
end
end
|
### Example 5: Laplace equation
In this tutorial we will look constructing the steady-state heat example using the Laplace equation. In contrast to the previous tutorials this example is entirely driven by the prescribed Dirichlet and Neumann boundary conditions, instead of an initial condition. We will also demonstrate how to use Devito to solve a steady-state problem without time derivatives and how to switch buffers explicitly without having to re-compile the kernel.
First, we again define our governing equation:
$$\frac{\partial ^2 p}{\partial x^2} + \frac{\partial ^2 p}{\partial y^2} = 0$$
We are again discretizing second-order derivatives using a central difference scheme to construct a diffusion problem (see tutorial 3). This time we have no time-dependent term in our equation though, since there is no term $p_{i,j}^{n+1}$. This means that we are simply updating our field variable $p$ over and over again, until we have reached an equilibrium state. In a discretised form, after rearranging to update the central point $p_{i,j}^n$ we have
$$p_{i,j}^n = \frac{\Delta y^2(p_{i+1,j}^n+p_{i-1,j}^n)+\Delta x^2(p_{i,j+1}^n + p_{i,j-1}^n)}{2(\Delta x^2 + \Delta y^2)}$$
And, as always, we first re-create the original implementation to see what we are aiming for. Here we initialise the field $p$ to $0$ and apply the following bounday conditions:
$p=0$ at $x=0$
$p=y$ at $x=2$
$\frac{\partial p}{\partial y}=0$ at $y=0, \ 1$
**Developer note:**
The original tutorial stores the field data in the layout `(ny, nx)`. Until now we have used `(x, y)` notation for creating our Devito examples, but for this one we will adopt the `(y, x)` layout for compatibility reasons.
```python
from examples.cfd import plot_field
import numpy as np
%matplotlib inline
# Some variable declarations
nx = 31
ny = 31
c = 1
dx = 2. / (nx - 1)
dy = 1. / (ny - 1)
```
```python
def laplace2d(p, bc_y, dx, dy, l1norm_target):
l1norm = 1
pn = np.empty_like(p)
while l1norm > l1norm_target:
pn = p.copy()
p[1:-1, 1:-1] = ((dy**2 * (pn[1:-1, 2:] + pn[1:-1, 0:-2]) +
dx**2 * (pn[2:, 1:-1] + pn[0:-2, 1:-1])) /
(2 * (dx**2 + dy**2)))
p[:, 0] = 0 # p = 0 @ x = 0
p[:, -1] = bc_right # p = y @ x = 2
p[0, :] = p[1, :] # dp/dy = 0 @ y = 0
p[-1, :] = p[-2, :] # dp/dy = 0 @ y = 1
l1norm = (np.sum(np.abs(p[:]) - np.abs(pn[:])) /
np.sum(np.abs(pn[:])))
return p
```
```python
#NBVAL_IGNORE_OUTPUT
# Out initial condition is 0 everywhere,except at the boundary
p = np.zeros((ny, nx))
# Boundary conditions
bc_right = np.linspace(0, 1, ny)
p[:, 0] = 0 # p = 0 @ x = 0
p[:, -1] = bc_right # p = y @ x = 2
p[0, :] = p[1, :] # dp/dy = 0 @ y = 0
p[-1, :] = p[-2, :] # dp/dy = 0 @ y = 1
plot_field(p, ymax=1.0, view=(30, 225))
```
```python
#NBVAL_IGNORE_OUTPUT
p = laplace2d(p, bc_right, dx, dy, 1e-4)
plot_field(p, ymax=1.0, view=(30, 225))
```
Ok, nice. Now, to re-create this example in Devito we need to look a little bit further under the hood. There are two things that make this different to the examples we covered so far:
* We have no time dependence in the `p` field, but we still need to advance the state of p in between buffers. So, instead of using `TimeFunction` objects that provide multiple data buffers for timestepping schemes, we will use `Function` objects that have no time dimension and only allocate a single buffer according to the space dimensions. However, since we are still implementing a pseudo-timestepping loop, we will need to objects, say `p` and `pn`, to act as alternating buffers.
* If we're using two different symbols to denote our buffers, any operator we create will only perform a single timestep. This is desired though, since we need to check a convergence criteria outside of the main stencil update to determine when we stop iterating. As a result we will need to call the operator repeatedly after instantiating it outside the convergence loop.
So, how do we make sure our operator doesn't accidentally overwrite values in the same buffer? Well, we can again let SymPy reorganise our Laplace equation based on `pn` to generate the stencil, but when we create the update expression, we set the LHS to our second buffer variable `p`.
```python
from devito import Grid, Function
from sympy import Eq, solve
# Create two explicit buffers for pseudo-timestepping
grid = Grid(shape=(nx, ny), extent=(1., 2.))
p = Function(name='p', grid=grid, space_order=2)
pn = Function(name='pn', grid=grid, space_order=2)
# Create Laplace equation base on `pn`
eqn = Eq(pn.laplace)
# Let SymPy solve for the central stencil point
stencil = solve(eqn, pn)[0]
# Now we let our stencil populate our second buffer `p`
eq_stencil = Eq(p, stencil)
# In the resulting stencil `pn` is exclusively used on the RHS
# and `p` on the LHS is the grid the kernel will update
print("Update stencil:\n%s\n" % eq_stencil)
```
Update stencil:
Eq(p(x, y), (h_x**2*pn(x, y - h_y) + h_x**2*pn(x, y + h_y) + h_y**2*pn(x - h_x, y) + h_y**2*pn(x + h_x, y))/(2*(h_x**2 + h_y**2)))
Now we can add our boundary conditions. We have already seen how to prescribe constant Dirichlet BCs by simply setting values using the low-level notation. This time we will go a little further by setting a prescribed profile, which we create first as a custom 1D symbol and supply with the BC values. For this we need to create a `Function` object that has a different shape than our general `grid`, so instead of the grid we provide an explicit pair of dimension symbols and the according shape for the data.
```python
x, y = grid.dimensions
bc_right = Function(name='bc_right', shape=(nx, ), dimensions=(x, ))
bc_right.data[:] = np.linspace(0, 1, nx)
```
Now we can create a set of expressions for the BCs again, where we wet prescribed values on the right and left of our grid. For the Neuman BCs along the top and bottom boundaries we simply copy the second rwo from the outside into the outermost row, just as the original tutorial did. Using these expressions and our stencil update we can now create an operator.
```python
#NBVAL_IGNORE_OUTPUT
from devito import Operator
# Create boundary condition expressions
bc = [Eq(p.indexed[x, 0], 0.)] # p = 0 @ x = 0
bc += [Eq(p.indexed[x, ny-1], bc_right.indexed[x])] # p = y @ x = 2
bc += [Eq(p.indexed[0, y], p.indexed[1, y])] # dp/dy = 0 @ y = 0
bc += [Eq(p.indexed[nx-1, y], p.indexed[nx-2, y])] # dp/dy = 0 @ y = 1
# Now we can build the operator that we need
op = Operator(expressions=[eq_stencil] + bc)
```
DSE: extract_time_invariants [flops: 10, elapsed: 0.00] >>
eliminate_inter_stencil_redundancies [flops: 10, elapsed: 0.00] >>
eliminate_intra_stencil_redundancies [flops: 10, elapsed: 0.00] >>
factorize [flops: 10, elapsed: 0.00] >>
finalize [flops: 14, elapsed: 0.00]
[Total elapsed: 0.01 s]
DLE: analyze [elapsed: 0.01] >>
avoid_denormals [elapsed: 0.00] >>
loop_fission [elapsed: 0.00] >>
loop_blocking [elapsed: 0.02] >>
simdize [elapsed: 0.12] >>
create_elemental_functions [elapsed: 0.00] >>
minimize_remainders [elapsed: 0.00]
[Total elapsed: 0.16 s]
We can now use this single-step operator repeatedly in a Python loop, where we can arbitrarily execute other code in between invocations. This allows us to update our L1 norm and check for convergence. Using our pre0compiled operator now comes down to a single function call that supplies the relevant data symbols. One thing to note is that we now do exactly the same thing as the original NumPy loop, in that we deep-copy the data between each iteration of the loop, which we will look at after this.
```python
#NBVAL_IGNORE_OUTPUT
# Silence the runtime performance logging
from devito import configuration
configuration['log_level'] = 'ERROR'
# Initialise the two buffer fields
p.data[:] = 0.
p.data[:, -1] = np.linspace(0, 1, ny)
pn.data[:] = 0.
pn.data[:, -1] = np.linspace(0, 1, ny)
# Visualize the initial condition
plot_field(p.data, ymax=1.0, view=(30, 225))
# Run the convergence loop with deep data copies
l1norm_target = 1.e-4
l1norm = 1
while l1norm > l1norm_target:
# This call implies a deep data copy
pn.data[:] = p.data[:]
op(p=p, pn=pn)
l1norm = (np.sum(np.abs(p.data[:]) - np.abs(pn.data[:])) /
np.sum(np.abs(pn.data[:])))
# Visualize the converged steady-state
plot_field(p.data, ymax=1.0, view=(30, 225))
```
One crucial detail about the code above is that the deep data copy between iterations will really hurt performance if we were to run this on a large grid. However, we have already seen how we can match data symbols to symbolic names when calling the pre-compiled operator, which we can now use to actually switch the roles of `pn` and `p` between iterations, eg. `op(p=pn, pn=p)`. Thus, we can implement a simple buffer-switching scheme by simply testing for odd and even time-steps, without ever having to shuffle data around.
```python
#NBVAL_IGNORE_OUTPUT
# Initialise the two buffer fields
p.data[:] = 0.
p.data[:, -1] = np.linspace(0, 1, ny)
pn.data[:] = 0.
pn.data[:, -1] = np.linspace(0, 1, ny)
# Visualize the initial condition
plot_field(p.data, ymax=1.0, view=(30, 225))
# Run the convergence loop by explicitly flipping buffers
l1norm_target = 1.e-4
l1norm = 1
counter = 0
while l1norm > l1norm_target:
# Determine buffer order
if counter % 2 == 0:
_p = p
_pn = pn
else:
_p = pn
_pn = p
# Apply operator
op(p=_p, pn=_pn)
# Compute L1 norm
l1norm = (np.sum(np.abs(_p.data[:]) - np.abs(_pn.data[:])) /
np.sum(np.abs(_pn.data[:])))
counter += 1
plot_field(p.data, ymax=1.0, view=(30, 225))
```
|
module Text.Bounded
%default total
public export
record Bounds where
constructor MkBounds
startLine : Int
startCol : Int
endLine : Int
endCol : Int
export
Show Bounds where
showPrec d (MkBounds sl sc el ec) =
showCon d "MkBounds" (concat [showArg sl, showArg sc, showArg el, showArg ec])
export
startBounds : Bounds -> (Int, Int)
startBounds b = (b.startLine, b.startCol)
export
endBounds : Bounds -> (Int, Int)
endBounds b = (b.endLine, b.endCol)
export
Eq Bounds where
(MkBounds sl sc el ec) == (MkBounds sl' sc' el' ec') =
sl == sl'
&& sc == sc'
&& el == el'
&& ec == ec'
public export
record WithBounds ty where
constructor MkBounded
val : ty
isIrrelevant : Bool
bounds : Bounds
export
start : WithBounds ty -> (Int, Int)
start = startBounds . bounds
export
end : WithBounds ty -> (Int, Int)
end = endBounds . bounds
export
Eq ty => Eq (WithBounds ty) where
(MkBounded val ir bd) == (MkBounded val' ir' bd') =
val == val' && ir == ir' && bd == bd'
export
Show ty => Show (WithBounds ty) where
showPrec d (MkBounded val ir bd) =
showCon d "MkBounded" (concat [showArg ir, showArg val, showArg bd])
export
Functor WithBounds where
map f (MkBounded val ir bd) = MkBounded (f val) ir bd
export
Foldable WithBounds where
foldr c n b = c b.val n
export
Traversable WithBounds where
traverse f (MkBounded v a bd) = (\ v => MkBounded v a bd) <$> f v
export
irrelevantBounds : ty -> WithBounds ty
irrelevantBounds x = MkBounded x True (MkBounds (-1) (-1) (-1) (-1))
export
removeIrrelevance : WithBounds ty -> WithBounds ty
removeIrrelevance (MkBounded val ir bd) = MkBounded val True bd
export
mergeBounds : WithBounds ty -> WithBounds ty' -> WithBounds ty'
mergeBounds (MkBounded _ True _) (MkBounded val True _) = irrelevantBounds val
mergeBounds (MkBounded _ True _) b2 = b2
mergeBounds b1 (MkBounded val True _) = const val <$> b1
mergeBounds b1 b2 =
let (ur, uc) = min (start b1) (start b2)
(lr, lc) = max (end b1) (end b2) in
MkBounded b2.val False (MkBounds ur uc lr lc)
export
joinBounds : WithBounds (WithBounds ty) -> WithBounds ty
joinBounds b = mergeBounds b b.val
|
C Copyright(C) 1999-2020 National Technology & Engineering Solutions
C of Sandia, LLC (NTESS). Under the terms of Contract DE-NA0003525 with
C NTESS, the U.S. Government retains certain rights in this software.
C
C See packages/seacas/LICENSE for details
SUBROUTINE INBOUN (MDIM, JJ, IFOUND, IIN, N1, N2, N3, N2OLD,
& MERGE, NOROOM, NEWNUM, NHOLD, IHOLD, IFLAG, INUM, IFIRST,
& LIST, LINK, IWT, JHOLD, ADDOLD)
C***********************************************************************
C SUBROUTINE INBOUN = INPUTS AND LINKS BOUNDARY FLAG INFORMATION
C***********************************************************************
C SUBROUTINE CALLED BY:
C READ = READS AND/OR MERGES QMESH CARD FILE(S)
C LINKBC = LINKS BOUNDARY FLAGS TO ENTITIES
C***********************************************************************
DIMENSION IHOLD(2, MDIM), IFLAG(MDIM)
DIMENSION INUM(MDIM), IFIRST(MDIM)
DIMENSION LIST(2, MDIM), LINK(2, MDIM)
DIMENSION IIN(IFOUND), IWT(3, MDIM)
LOGICAL NOROOM, MERGE, NEWNUM, ADDOLD, ADDLNK
NEWNUM = .FALSE.
NOROOM = .FALSE.
IZ = 0
IOLD = 0
IF ((JJ.LE.0) .OR. (JJ .GT. 10000)) THEN
WRITE(*, 10000) JJ
RETURN
END IF
NOROOM = .TRUE.
C GET THE CORRECT FLAG ID
IF (JJ .GT. N1) THEN
N1 = JJ
ELSE IF (MERGE) THEN
JHOLD = JJ
ADDLNK = .FALSE.
CALL LTSORT (MDIM, LINK, JJ, IPNTR, ADDLNK)
IF (IPNTR .GT. 0) THEN
IF (JHOLD .GT. NHOLD)NHOLD = JHOLD
CALL LTSORT (MDIM, IHOLD, JHOLD, IPNTR, ADDLNK)
IF (IPNTR .GT. 0) THEN
JJ = IPNTR
ELSE
JJ = N1 + 1
N1 = JJ
NEWNUM = .TRUE.
ADDLNK = .TRUE.
CALL LTSORT (MDIM, LINK, JJ, IZ, ADDLNK)
CALL LTSORT (MDIM, IHOLD, JHOLD, JJ, ADDLNK)
END IF
END IF
END IF
IF (N2 + 1 .GT. MDIM) RETURN
C GET THE OLD LOCATION OF THE FLAG IF IT IS THERE
ADDLNK = .FALSE.
CALL LTSORT (MDIM, LINK, JJ, IOLD, ADDLNK)
C IF THE FLAG CURRENTLY EXISTS, SHIFT THE FLAG DATA TO THE END
C OF THE CURRENT FLAG LIST, TO FACILITATE ADDING MORE ENTRIES
C TO THE OLD FLAG
IF (IOLD .GT. 0) THEN
C SHIFT THE OLD DEFINITION TO THE END OF THE LIST
IFLAG(N2 + 1) = IFLAG(IOLD)
INUM(N2 + 1) = INUM(IOLD)
IWT(1, N2 + 1) = IWT(1, IOLD)
IWT(2, N2 + 1) = IWT(2, IOLD)
IWT(3, N2 + 1) = IWT(3, IOLD)
IFIRST(N2 + 1) = N3 + 1
IF (IOLD .LT. N2) THEN
KOUNT = IFIRST(IOLD + 1) - IFIRST(IOLD)
ELSE IF (IOLD .EQ. N2) THEN
KOUNT = INUM(IOLD)
ELSE
CALL MESSAGE('IN INBOUN, ERROR REORDERING FLAG LIST')
RETURN
END IF
NLIST1 = IFIRST(IOLD)
NPLACE = N3
DO 100 I = NLIST1, NLIST1 + INUM(IOLD) - 1
NPLACE = NPLACE + 1
IF (NPLACE .GT. MDIM) RETURN
LIST(1, NPLACE) = LIST(1, I)
LIST(2, NPLACE) = LIST(2, I)
100 CONTINUE
C SLIDE ALL TRAILING FLAGS OVER TO FILL THE GAP IN THE LIST
C RESORT THE POINTER ARRAY AS THE LIST FILLS AND STEP N2OLD
C DOWN A NOTCH SO THESE WILL BE RELINKED IF NECESSARY
IF (N2OLD .GT. 0) N2OLD = N2OLD - 1
ADDLNK = .TRUE.
DO 110 I = IOLD, N2
IFLAG(I) = IFLAG(I + 1)
INUM(I) = INUM(I + 1)
IFIRST(I) = IFIRST(I + 1) - KOUNT
IWT(1, I) = IWT(1, I + 1)
IWT(2, I) = IWT(2, I + 1)
IWT(3, I) = IWT(3, I + 1)
CALL LTSORT (MDIM, LINK, IFLAG(I), I, ADDLNK)
110 CONTINUE
N3 = IFIRST(N2) + INUM(N2) - 1
DO 120 I = NLIST1, N3
IKOUNT = I + KOUNT
LIST(1, I) = LIST(1, IKOUNT)
LIST(2, I) = LIST(2, IKOUNT)
120 CONTINUE
ELSE
C LINK UP THE FLAG IN THE NEXT OPEN SLOT
ADDLNK = .TRUE.
N2 = N2 + 1
CALL LTSORT (MDIM, LINK, JJ, N2, ADDLNK)
IFLAG(N2) = JJ
IFIRST(N2) = N3 + 1
IWT(1, N2) = 0
IWT(2, N2) = 0
IWT(3, N2) = 0
END IF
C READ IN THE NEW FLAG LIST
DO 150 I = 1, IFOUND
JJ = IIN(I)
IF (JJ .EQ. 0) GO TO 160
C CHECK TO MAKE SURE THIS ENTITY IS NOT ALREADY IN THE LIST
DO 130 K = IFIRST(N2), N3
IF (LIST(1, K) .EQ. JJ) GO TO 140
130 CONTINUE
N3 = N3 + 1
IF (N3 .GT. MDIM) RETURN
LIST(1, N3) = JJ
LIST(2, N3) = 0
140 CONTINUE
150 CONTINUE
160 CONTINUE
INUM(N2) = N3 - IFIRST(N2) + 1
NOROOM = .FALSE.
RETURN
10000 FORMAT (' A FLAG NO. OF:', I7, ' IS NOT ALLOWED', /,
& ' THIS FLAG WILL NOT BE INPUT INTO DATABASE')
END
|
PISystemStatus <- function(upTimeInMinutes = NULL, state = NULL, cacheInstances = NULL, serverTime = NULL, webException = NULL) {
if (is.null(upTimeInMinutes) == FALSE) {
}
if (is.null(state) == FALSE) {
if (is.character(state) == FALSE) {
return (print(paste0("Error: state must be a string.")))
}
}
if (is.null(cacheInstances) == FALSE) {
if (check.integer(cacheInstances) == FALSE) {
return (print(paste0("Error: cacheInstances must be an integer.")))
}
}
if (is.null(serverTime) == FALSE) {
if (is.character(serverTime) == FALSE) {
return (print(paste0("Error: serverTime must be a string.")))
}
}
if (is.null(webException) == FALSE) {
className <- attr(webException, "className")
if ((is.null(className)) || (className != "PIWebException")) {
return (print(paste0("Error: the class from the parameter webException should be PIWebException.")))
}
}
value <- list(
UpTimeInMinutes = upTimeInMinutes,
State = state,
CacheInstances = cacheInstances,
ServerTime = serverTime,
WebException = webException)
valueCleaned <- rmNullObs(value)
attr(valueCleaned, "className") <- "PISystemStatus"
return(valueCleaned)
}
|
module NF.Nat where
open import NF
open import Relation.Binary.PropositionalEquality
open import Data.Nat
instance
nf0 : NF 0
Sing.unpack (NF.!! nf0) = 0
Sing.eq (NF.!! nf0) = refl
{-# INLINE nf0 #-}
nfSuc : {n : ℕ}{{nfn : NF n}} -> NF (suc n)
Sing.unpack (NF.!! (nfSuc {n})) = suc (nf n)
Sing.eq (NF.!! (nfSuc {{nfn}})) = cong suc nf≡
{-# INLINE nfSuc #-} |
State Before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderTop α
a b c : α
⊢ Codisjoint (a ⊓ b) c ↔ Codisjoint a c ∧ Codisjoint b c State After: no goals Tactic: simp only [codisjoint_iff, sup_inf_right, inf_eq_top_iff] |
lemma le_add_iff2: "a *\<^sub>R e + c \<le> b *\<^sub>R e + d \<longleftrightarrow> c \<le> (b - a) *\<^sub>R e + d" for c d e :: "'a::ordered_real_vector" |
Real Function ppk1(srt)
Real xarray(7), earray(7)
Save
Data xarray/0.013, 0.025, 0.016, 0.012, 0.017, 0.029, 0.025/
Data earray/3.67, 4.95, 5.52, 5.97, 6.05, 6.92, 7.87/
pmass = 0.9383
ppk1 = 0.
If (srt<=2.63) Return
If (srt>4.08) Then
ppk1 = 0.025
Return
End If
plab = sqrt(((srt**2-2.*pmass**2)/(2.*pmass))**2-pmass**2)
If (plab<earray(1)) Then
ppk1 = xarray(1)
Return
End If
Do ie = 1, 7
If (earray(ie)==plab) Then
ppk1 = xarray(ie)
Goto 10
Else If (earray(ie)>plab) Then
ymin = alog(xarray(ie-1))
ymax = alog(xarray(ie))
xmin = alog(earray(ie-1))
xmax = alog(earray(ie))
ppk1 = exp(ymin+(alog(plab)-xmin)*(ymax-ymin)/(xmax-xmin))
Goto 10
End If
End Do
10 Continue
Return
End Function ppk1
|
/-
Copyright (c) 2022 Yaël Dillies. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Yaël Dillies
-/
import combinatorics.simple_graph.connectivity
import data.fin.succ_pred
import order.succ_pred.relation
/-!
# The Hasse diagram as a graph
This file defines the Hasse diagram of an order (graph of `covby`, the covering relation) and the
path graph on `n` vertices.
## Main declarations
* `simple_graph.hasse`: Hasse diagram of an order.
* `simple_graph.path_graph`: Path graph on `n` vertices.
-/
open order order_dual relation
namespace simple_graph
variables (α β : Type*)
section preorder
variables [preorder α] [preorder β]
/-- The Hasse diagram of an order as a simple graph. The graph of the covering relation. -/
def hasse : simple_graph α :=
{ adj := λ a b, a ⋖ b ∨ b ⋖ a,
symm := λ a b, or.symm,
loopless := λ a h, h.elim (irrefl _) (irrefl _) }
variables {α β} {a b : α}
@[simp] lemma hasse_adj : (hasse α).adj a b ↔ a ⋖ b ∨ b ⋖ a := iff.rfl
/-- `αᵒᵈ` and `α` have the same Hasse diagram. -/
def hasse_dual_iso : hasse αᵒᵈ ≃g hasse α :=
{ map_rel_iff' := λ a b, by simp [or_comm],
..of_dual }
@[simp] lemma hasse_dual_iso_apply (a : αᵒᵈ) : hasse_dual_iso a = of_dual a := rfl
@[simp] lemma hasse_dual_iso_symm_apply (a : α) : hasse_dual_iso.symm a = to_dual a := rfl
end preorder
section linear_order
variables [linear_order α]
lemma hasse_preconnected_of_succ [succ_order α] [is_succ_archimedean α] : (hasse α).preconnected :=
λ a b, begin
rw reachable_iff_refl_trans_gen,
exact refl_trans_gen_of_succ _ (λ c hc, or.inl $ covby_succ_of_not_is_max hc.2.not_is_max)
(λ c hc, or.inr $ covby_succ_of_not_is_max hc.2.not_is_max),
end
lemma hasse_preconnected_of_pred [pred_order α] [is_pred_archimedean α] : (hasse α).preconnected :=
λ a b, begin
rw [reachable_iff_refl_trans_gen, ←refl_trans_gen_swap],
exact refl_trans_gen_of_pred _ (λ c hc, or.inl $ pred_covby_of_not_is_min hc.1.not_is_min)
(λ c hc, or.inr $ pred_covby_of_not_is_min hc.1.not_is_min),
end
end linear_order
/-- The path graph on `n` vertices. -/
def path_graph (n : ℕ) : simple_graph (fin n) := hasse _
lemma path_graph_preconnected (n : ℕ) : (path_graph n).preconnected := hasse_preconnected_of_succ _
lemma path_graph_connected (n : ℕ) : (path_graph (n + 1)).connected := ⟨path_graph_preconnected _⟩
end simple_graph
|
/-
Copyright (c) 2020 Simon Hudon All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Simon Hudon
-/
import control.functor.multivariate
import data.qpf.multivariate.basic
/-!
# Constant functors are QPFs
Constant functors map every type vectors to the same target type. This
is a useful device for constructing data types from more basic types
that are not actually functorial. For instance `const n nat` makes
`nat` into a functor that can be used in a functor-based data type
specification.
-/
universes u
namespace mvqpf
open_locale mvfunctor
variables (n : ℕ)
/-- Constant multivariate functor -/
@[nolint unused_arguments]
def const (A : Type*) (v : typevec.{u} n) : Type* :=
A
instance const.inhabited {A α} [inhabited A] : inhabited (const n A α) :=
⟨ (default A : A) ⟩
namespace const
open mvfunctor mvpfunctor
variables {n} {A : Type u} {α β : typevec.{u} n} (f : α ⟹ β)
/-- Constructor for constant functor -/
protected def mk (x : A) : (const n A) α := x
/-- Destructor for constant functor -/
protected def get (x : (const n A) α) : A := x
@[simp] protected lemma mk_get (x : (const n A) α) : const.mk (const.get x) = x := rfl
@[simp] protected lemma get_mk (x : A) : const.get (const.mk x : const n A α) = x := rfl
/-- `map` for constant functor -/
protected def map : (const n A) α → (const n A) β :=
λ x, x
instance : mvfunctor (const n A) :=
{ map := λ α β f, const.map }
lemma map_mk (x : A) :
f <$$> const.mk x = const.mk x := rfl
lemma get_map (x : (const n A) α) :
const.get (f <$$> x) = const.get x := rfl
instance mvqpf : @mvqpf _ (const n A) (mvqpf.const.mvfunctor) :=
{ P := mvpfunctor.const n A,
abs := λ α x, mvpfunctor.const.get x,
repr := λ α x, mvpfunctor.const.mk n x,
abs_repr := by intros; simp,
abs_map := by intros; simp; refl,
}
end const
end mvqpf
|
! MIT License
! Copyright (c) 2020 Sam Miller
! Permission is hereby granted, free of charge, to any person obtaining a copy
! of this software and associated documentation files (the "Software"), to deal
! in the Software without restriction, including without limitation the rights
! to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
! copies of the Software, and to permit persons to whom the Software is
! furnished to do so, subject to the following conditions:
!
! The above copyright notice and this permission notice shall be included in all
! copies or substantial portions of the Software.
!
! THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
! IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
! FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
! AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
! LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
! OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
! SOFTWARE.
module mod_flux_solver
!< Summary: Provide a base Riemann solver class structure
!< Date: 06/22/2020
!< Author: Sam Miller
use, intrinsic :: iso_fortran_env, only: ik => int32, rk => real64
use mod_field, only: field_2d_t, field_2d
use mod_globals, only: debug_print, enable_debug_print
use mod_floating_point_utils, only: neumaier_sum_4
use mod_grid_block_2d, only: grid_block_2d_t
use mod_input, only: input_t
use mod_boundary_conditions, only: boundary_condition_t
use mod_bc_factory, only: bc_factory
implicit none
private
public :: flux_solver_t, edge_split_flux_solver_t
type, abstract :: flux_solver_t
type(input_t) :: input !<
character(len=32) :: name = '' !<
integer(ik) :: iteration = 0 !<
real(rk) :: time = 0.0_rk !<
real(rk) :: dt = 0.0_rk !<
integer(ik), dimension(2) :: lbounds = 0 !< (i,j); lower cell bounds
integer(ik), dimension(2) :: ubounds = 0 !< (i,j); upper cell bounds
contains
procedure, public :: init_boundary_conditions
procedure, public :: apply_primitive_bc
! Deferred methods
procedure(initialize), deferred, public :: initialize
procedure(solve), deferred, public :: solve
endtype flux_solver_t
type, abstract, extends(flux_solver_t) :: edge_split_flux_solver_t
!< Directionally split flux solver class
real(rk), dimension(:, :, :), allocatable :: iflux !< ((1:4), i, j) edge flux of the i-direction edges
real(rk), dimension(:, :, :), allocatable :: jflux !< ((1:4), i, j) edge flux of the j-direction edges
contains
procedure, public :: flux_split_edges
endtype edge_split_flux_solver_t
abstract interface
subroutine solve(self, dt, grid, rho, u, v, p, d_rho_dt, d_rho_u_dt, d_rho_v_dt, d_rho_E_dt)
!< Solve and flux the edges
import :: flux_solver_t, rk
import :: grid_block_2d_t, field_2d_t
class(flux_solver_t), intent(inout) :: self
real(rk), intent(in) :: dt !< timestep delta t
class(grid_block_2d_t), intent(in) :: grid
class(field_2d_t), intent(inout) :: rho !< density
class(field_2d_t), intent(inout) :: u !< x-velocity
class(field_2d_t), intent(inout) :: v !< y-velocity
class(field_2d_t), intent(inout) :: p !< pressure
real(rk), dimension(:, :), allocatable, intent(out) :: d_rho_dt !< d/dt of the density field
real(rk), dimension(:, :), allocatable, intent(out) :: d_rho_u_dt !< d/dt of the rhou field
real(rk), dimension(:, :), allocatable, intent(out) :: d_rho_v_dt !< d/dt of the rhov field
real(rk), dimension(:, :), allocatable, intent(out) :: d_rho_E_dt !< d/dt of the rhoE field
! type(field_2d_t), intent(out) :: d_rho_dt !< d/dt of the density field
! type(field_2d_t), intent(out) :: d_rho_u_dt !< d/dt of the rhou field
! type(field_2d_t), intent(out) :: d_rho_v_dt !< d/dt of the rhov field
! type(field_2d_t), intent(out) :: d_rho_E_dt !< d/dt of the rhoE field
endsubroutine
subroutine initialize(self, input, time)
import :: flux_solver_t, rk
import :: input_t
class(flux_solver_t), intent(inout) :: self
class(input_t), intent(in) :: input
real(rk), intent(in) :: time
endsubroutine
endinterface
contains
subroutine init_boundary_conditions(self, grid, bc_plus_x, bc_minus_x, bc_plus_y, bc_minus_y)
class(flux_solver_t), intent(inout) :: self
class(grid_block_2d_t), intent(in) :: grid
class(boundary_condition_t), pointer :: bc => null()
class(boundary_condition_t), allocatable, intent(out):: bc_plus_x
class(boundary_condition_t), allocatable, intent(out):: bc_plus_y
class(boundary_condition_t), allocatable, intent(out):: bc_minus_x
class(boundary_condition_t), allocatable, intent(out):: bc_minus_y
! Locals
integer(ik) :: alloc_status
if(enable_debug_print) call debug_print('Calling flux_solver_t%init_boundary_conditions()', __FILE__, __LINE__)
! Set boundary conditions
bc => bc_factory(bc_type=self%input%plus_x_bc, location='+x', input=self%input, grid=grid, time=self%time)
allocate(bc_plus_x, source=bc, stat=alloc_status)
if(alloc_status /= 0) error stop "Unable to allocate bc_plus_x"
deallocate(bc)
bc => bc_factory(bc_type=self%input%plus_y_bc, location='+y', input=self%input, grid=grid, time=self%time)
allocate(bc_plus_y, source=bc, stat=alloc_status)
if(alloc_status /= 0) error stop "Unable to allocate bc_plus_y"
deallocate(bc)
bc => bc_factory(bc_type=self%input%minus_x_bc, location='-x', input=self%input, grid=grid, time=self%time)
allocate(bc_minus_x, source=bc, stat=alloc_status)
if(alloc_status /= 0) error stop "Unable to allocate bc_minus_x"
deallocate(bc)
bc => bc_factory(bc_type=self%input%minus_y_bc, location='-y', input=self%input, grid=grid, time=self%time)
allocate(bc_minus_y, source=bc, stat=alloc_status)
if(alloc_status /= 0) error stop "Unable to allocate bc_minus_y"
deallocate(bc)
endsubroutine init_boundary_conditions
subroutine apply_primitive_bc(self, rho, u, v, p, &
bc_plus_x, bc_minus_x, bc_plus_y, bc_minus_y)
!< Apply the boundary conditions to the primitive variables (rho, u, v, and p). BC's are applied
!< in order of their priority, with the highest going first
class(flux_solver_t), intent(inout) :: self
class(field_2d_t), intent(inout) :: rho
class(field_2d_t), intent(inout) :: u
class(field_2d_t), intent(inout) :: v
class(field_2d_t), intent(inout) :: p
class(boundary_condition_t), intent(inout):: bc_plus_x
class(boundary_condition_t), intent(inout):: bc_plus_y
class(boundary_condition_t), intent(inout):: bc_minus_x
class(boundary_condition_t), intent(inout):: bc_minus_y
integer(ik) :: priority
integer(ik) :: max_priority_bc !< highest goes first
call debug_print('Running flux_solver_t%apply_primitive_bc()', __FILE__, __LINE__)
max_priority_bc = max(bc_plus_x%priority, bc_plus_y%priority, &
bc_minus_x%priority, bc_minus_y%priority)
call bc_plus_x%set_time(time=self%time)
call bc_minus_x%set_time(time=self%time)
call bc_plus_y%set_time(time=self%time)
call bc_minus_y%set_time(time=self%time)
do priority = max_priority_bc, 0, -1
if(bc_plus_x%priority == priority) then
call bc_plus_x%apply(rho=rho, u=u, v=v, p=p)
endif
if(bc_plus_y%priority == priority) then
call bc_plus_y%apply(rho=rho, u=u, v=v, p=p)
endif
if(bc_minus_x%priority == priority) then
call bc_minus_x%apply(rho=rho, u=u, v=v, p=p)
endif
if(bc_minus_y%priority == priority) then
call bc_minus_y%apply(rho=rho, u=u, v=v, p=p)
endif
enddo
endsubroutine apply_primitive_bc
subroutine flux_split_edges(self, grid, d_rho_dt, d_rho_u_dt, d_rho_v_dt, d_rho_E_dt)
!< Flux the edges to get the residuals, e.g. 1/vol * d/dt U
class(edge_split_flux_solver_t), intent(in) :: self
class(grid_block_2d_t), intent(in) :: grid !< grid topology class
real(rk), dimension(:, :), allocatable, intent(out) :: d_rho_dt !< d/dt of the density field
real(rk), dimension(:, :), allocatable, intent(out) :: d_rho_u_dt !< d/dt of the rhou field
real(rk), dimension(:, :), allocatable, intent(out) :: d_rho_v_dt !< d/dt of the rhov field
real(rk), dimension(:, :), allocatable, intent(out) :: d_rho_E_dt !< d/dt of the rhoE field
! Locals
integer(ik) :: i, j, ilo, ihi, jlo, jhi
integer(ik) :: ilo_halo, ihi_halo, jlo_halo, jhi_halo
real(rk), dimension(4) :: delta_l !< edge length
real(rk), parameter :: FLUX_EPS = 1e-13_rk
logical, parameter :: SCALE = .true.
logical, parameter :: CHECK_TOLERANCE = .true.
real(rk), parameter :: REL_TOL = 1e-14_rk
real(rk) :: rho_i, rho_j
real(rk) :: rhou_i_flux, rhou_j_flux
real(rk) :: rhov_i_flux, rhov_j_flux
real(rk) :: rhoE_i_flux, rhoE_j_flux
real(rk) :: rho_flux, max_iflux, max_jflux
real(rk) :: rhou_flux
real(rk) :: rhov_flux
real(rk) :: rhoE_flux
real(rk) :: orig_diff, scaled_diff
call debug_print('Running flux_solver_t%flux_split_edges()', __FILE__, __LINE__)
! Block bounds
ilo = grid%lbounds(1)
ihi = grid%ubounds(1)
jlo = grid%lbounds(2)
jhi = grid%ubounds(2)
ilo_halo = grid%lbounds_halo(1)
ihi_halo = grid%ubounds_halo(1)
jlo_halo = grid%lbounds_halo(2)
jhi_halo = grid%ubounds_halo(2)
allocate(d_rho_dt(ilo_halo:ihi_halo, jlo_halo:jhi_halo))
allocate(d_rho_u_dt(ilo_halo:ihi_halo, jlo_halo:jhi_halo))
allocate(d_rho_v_dt(ilo_halo:ihi_halo, jlo_halo:jhi_halo))
allocate(d_rho_E_dt(ilo_halo:ihi_halo, jlo_halo:jhi_halo))
! /\
! jflux(i,j) 'R' |
! o--------------------o
! | 'L' |
! <---| |--->
! -iflux(i-1, j) | cell (i,j) | iflux(i, j)
! | |
! | 'L' | 'R'
! o--------------------o
! jflux(i,j-1) |
! \/
!
! This is the numbering convention that this module uses
! ------------------------------------
! rho
! ------------------------------------
do j = jlo, jhi
do i = ilo, ihi
delta_l = grid%edge_lengths(:, i, j)
if(SCALE) then
max_iflux = max(abs(self%iflux(1, i, j)), &
abs(self%iflux(1, i - 1, j)), 1.0_rk)
max_jflux = max(abs(self%jflux(1, i, j)), &
abs(self%jflux(1, i, j - 1)), 1.0_rk)
else
max_iflux = 1.0_rk
max_jflux = 1.0_rk
endif
! normalize by the max to avoid catastrophic cancellation if possible
rho_i = ((self%iflux(1, i, j) / max_iflux * delta_l(2)) + &
(-self%iflux(1, i - 1, j) / max_iflux * delta_l(4))) * max_iflux
rho_j = ((self%jflux(1, i, j) / max_jflux * delta_l(3)) + &
(-self%jflux(1, i, j - 1) / max_jflux * delta_l(1))) * max_jflux
! Relative error check... if the diff is 10 orders of mag from the max, make it 0
if(CHECK_TOLERANCE .and. abs(rho_i) < max_iflux * REL_TOL) rho_i = 0.0_rk
if(CHECK_TOLERANCE .and. abs(rho_j) < max_jflux * REL_TOL) rho_j = 0.0_rk
rho_flux = rho_i + rho_j
if(near_zero(rho_flux)) rho_flux = 0.0_rk
d_rho_dt(i, j) = -rho_flux
enddo
enddo
! ------------------------------------
! rho u
! ------------------------------------
do j = jlo, jhi
do i = ilo, ihi
delta_l = grid%edge_lengths(:, i, j)
if(SCALE) then
max_iflux = max(abs(self%iflux(2, i, j)), &
abs(self%iflux(2, i - 1, j)), 1.0_rk)
max_jflux = max(abs(self%jflux(2, i, j)), &
abs(self%jflux(2, i, j - 1)), 1.0_rk)
else
max_iflux = 1.0_rk
max_jflux = 1.0_rk
endif
! normalize by the max to avoid catastrophic cancellation if possible
rhou_i_flux = ((self%iflux(2, i, j) / max_iflux * delta_l(2)) + &
(-self%iflux(2, i - 1, j) / max_iflux * delta_l(4))) * max_iflux
rhou_j_flux = ((self%jflux(2, i, j) / max_jflux * delta_l(3)) + &
(-self%jflux(2, i, j - 1) / max_jflux * delta_l(1))) * max_jflux
! Relative error check... if the diff is 10 orders of mag from the max, make it 0
! print*, max_iflux, abs(rhou_i_flux), abs(rhou_i_flux) < max_iflux * REL_TOL, max_jflux, abs(rhou_j_flux), abs(rhou_j_flux) < max_jflux * REL_TOL
if(CHECK_TOLERANCE .and. abs(rhou_i_flux) < max_iflux * REL_TOL) rhou_i_flux = 0.0_rk
if(CHECK_TOLERANCE .and. abs(rhou_j_flux) < max_jflux * REL_TOL) rhou_j_flux = 0.0_rk
rhou_flux = rhou_i_flux + rhou_j_flux
if(near_zero(rhou_flux)) rhou_flux = 0.0_rk
d_rho_u_dt(i, j) = -rhou_flux
enddo
enddo
! ------------------------------------
! rho v
! ------------------------------------
do j = jlo, jhi
do i = ilo, ihi
delta_l = grid%edge_lengths(:, i, j)
if(SCALE) then
max_iflux = max(abs(self%iflux(3, i, j)), &
abs(self%iflux(3, i - 1, j)), 1.0_rk)
max_jflux = max(abs(self%jflux(3, i, j)), &
abs(self%jflux(3, i, j - 1)), 1.0_rk)
else
max_iflux = 1.0_rk
max_jflux = 1.0_rk
endif
! normalize by the max to avoid catastrophic cancellation if possible
rhov_i_flux = ((self%iflux(3, i, j) / max_iflux * delta_l(2)) + &
(-self%iflux(3, i - 1, j) / max_iflux * delta_l(4))) * max_iflux
rhov_j_flux = ((self%jflux(3, i, j) / max_jflux * delta_l(3)) + &
(-self%jflux(3, i, j - 1) / max_jflux * delta_l(1))) * max_jflux
if(CHECK_TOLERANCE .and. abs(rhov_i_flux) < max_iflux * REL_TOL) rhov_i_flux = 0.0_rk
if(CHECK_TOLERANCE .and. abs(rhov_j_flux) < max_jflux * REL_TOL) rhov_j_flux = 0.0_rk
rhov_flux = rhov_i_flux + rhov_j_flux
if(near_zero(rhov_flux)) rhov_flux = 0.0_rk
d_rho_v_dt(i, j) = -rhov_flux
! Relative error check... if the diff is 10 orders of mag from the max, make it 0
! if(i == 555 .and. j == 20) then
! print*, rhov_flux, rhov_i_flux, rhov_j_flux
! ! print*, self%iflux(3, i, j), self%iflux(3, i - 1, j)
! ! print*, max_iflux, abs(rhov_i_flux), max_iflux * REL_TOL, abs(rhov_i_flux) < max_iflux * REL_TOL
! ! print*
! ! print*, self%jflux(3, i, j), self%jflux(3, i, j - 1)
! ! print*, max_jflux, abs(rhov_j_flux), max_jflux * REL_TOL, abs(rhov_j_flux) < max_jflux * REL_TOL
! endif
enddo
enddo
! ------------------------------------
! rho E
! ------------------------------------
do j = jlo, jhi
do i = ilo, ihi
delta_l = grid%edge_lengths(:, i, j)
if(SCALE) then
max_iflux = max(abs(self%iflux(4, i, j)), &
abs(self%iflux(4, i - 1, j)), 1.0_rk)
max_jflux = max(abs(self%jflux(4, i, j)), &
abs(self%jflux(4, i, j - 1)), 1.0_rk)
else
max_iflux = 1.0_rk
max_jflux = 1.0_rk
endif
! normalize by the max to avoid catastrophic cancellation if possible
rhoE_i_flux = ((self%iflux(4, i, j) / max_iflux * delta_l(2)) + &
(-self%iflux(4, i - 1, j) / max_iflux * delta_l(4))) * max_iflux
rhoE_j_flux = ((self%jflux(4, i, j) / max_jflux * delta_l(3)) + &
(-self%jflux(4, i, j - 1) / max_jflux * delta_l(1))) * max_jflux
! Relative error check... if the diff is 10 orders of mag from the max, make it 0
if(CHECK_TOLERANCE .and. abs(rhoE_i_flux) < max_iflux * REL_TOL) rhoE_i_flux = 0.0_rk
if(CHECK_TOLERANCE .and. abs(rhoE_j_flux) < max_jflux * REL_TOL) rhoE_j_flux = 0.0_rk
rhoE_flux = rhoE_i_flux + rhoE_j_flux
if(near_zero(rhoE_flux)) rhoE_flux = 0.0_rk
d_rho_E_dt(i, j) = -rhoE_flux
enddo
enddo
!$omp simd
do j = jlo, jhi
do i = ilo, ihi
d_rho_dt(i, j) = d_rho_dt(i, j) / grid%volume(i, j)
enddo
enddo
!$omp end simd
!$omp simd
do j = jlo, jhi
do i = ilo, ihi
d_rho_u_dt(i, j) = d_rho_u_dt(i, j) / grid%volume(i, j)
enddo
enddo
!$omp end simd
!$omp simd
do j = jlo, jhi
do i = ilo, ihi
d_rho_v_dt(i, j) = d_rho_v_dt(i, j) / grid%volume(i, j)
enddo
enddo
!$omp end simd
!$omp simd
do j = jlo, jhi
do i = ilo, ihi
d_rho_E_dt(i, j) = d_rho_E_dt(i, j) / grid%volume(i, j)
enddo
enddo
!$omp end simd
! Zero out the halo layers
! call d_rho_dt%zero_out_halo()
! call d_rho_u_dt%zero_out_halo()
! call d_rho_v_dt%zero_out_halo()
! call d_rho_E_dt%zero_out_halo()
associate(ilo_s => grid%lbounds_halo(1), ilo_e => grid%lbounds(1) - 1, &
ihi_s => grid%ubounds(1) + 1, ihi_e => grid%ubounds_halo(1), &
jlo_s => grid%lbounds_halo(2), jlo_e => grid%lbounds(2) - 1, &
jhi_s => grid%ubounds(2) + 1, jhi_e => grid%ubounds_halo(2))
d_rho_dt(ilo_s:ilo_e, :) = 0.0_rk ! lower i cells
d_rho_dt(ihi_s:ihi_e, :) = 0.0_rk ! upper i cells
d_rho_dt(:, jlo_s:jlo_e) = 0.0_rk ! lower j cells
d_rho_dt(:, jhi_s:jhi_e) = 0.0_rk ! upper j cells
d_rho_u_dt(ilo_s:ilo_e, :) = 0.0_rk ! lower i cells
d_rho_u_dt(ihi_s:ihi_e, :) = 0.0_rk ! upper i cells
d_rho_u_dt(:, jlo_s:jlo_e) = 0.0_rk ! lower j cells
d_rho_u_dt(:, jhi_s:jhi_e) = 0.0_rk ! upper j cells
d_rho_v_dt(ilo_s:ilo_e, :) = 0.0_rk ! lower i cells
d_rho_v_dt(ihi_s:ihi_e, :) = 0.0_rk ! upper i cells
d_rho_v_dt(:, jlo_s:jlo_e) = 0.0_rk ! lower j cells
d_rho_v_dt(:, jhi_s:jhi_e) = 0.0_rk ! upper j cells
d_rho_E_dt(ilo_s:ilo_e, :) = 0.0_rk ! lower i cells
d_rho_E_dt(ihi_s:ihi_e, :) = 0.0_rk ! upper i cells
d_rho_E_dt(:, jlo_s:jlo_e) = 0.0_rk ! lower j cells
d_rho_E_dt(:, jhi_s:jhi_e) = 0.0_rk ! upper j cells
endassociate
endsubroutine flux_split_edges
logical elemental function near_zero(test_number, epsilon)
real(rk), intent (in) :: test_number
real(rk), intent (in), optional :: epsilon
real(rk), parameter :: TINY_NUM = tiny(1.0_rk), TINY_FACTOR = 5.0
real(kind(epsilon)) :: local_epsilon
local_epsilon = TINY_FACTOR * TINY_NUM
if (present(epsilon)) then
if (abs(epsilon) >= TINY_NUM) local_epsilon = abs(epsilon)
end if
near_zero = abs(test_number) < local_epsilon
end function near_zero
endmodule mod_flux_solver
|
(*******************************************************************************
Project: Refining Authenticated Key Agreement with Strong Adversaries
Module: dhlvl1.thy (Isabelle/HOL 2016-1)
ID: $Id: dhlvl1.thy 133183 2017-01-31 13:55:43Z csprenge $
Author: Joseph Lallemand, INRIA Nancy <[email protected]>
Christoph Sprenger, ETH Zurich <[email protected]>
Level-1 Diffie-Hellman guard protocol.
Copyright (c) 2015-2016 Joseph Lallemand and Christoph Sprenger
Licence: LGPL
*******************************************************************************)
section \<open>Authenticated Diffie Hellman Protocol (L1)\<close>
theory dhlvl1
imports Runs Secrecy AuthenticationI Payloads
begin
declare option.split_asm [split]
(**************************************************************************************************)
subsection \<open>State and Events\<close>
(**************************************************************************************************)
consts
Nend :: "nat"
abbreviation nx :: nat where "nx \<equiv> 2"
abbreviation ny :: nat where "ny \<equiv> 3"
text \<open>Proofs break if @{term "1"} is used, because @{method "simp"} replaces it with
@{term "Suc 0"}\dots.\<close>
abbreviation
"xEnd \<equiv> Var 0"
abbreviation
"xnx \<equiv> Var 2"
abbreviation
"xny \<equiv> Var 3"
abbreviation
"xsk \<equiv> Var 4"
abbreviation
"xgnx \<equiv> Var 5"
abbreviation
"xgny \<equiv> Var 6"
abbreviation
"End \<equiv> Number Nend"
text \<open>Domain of each role (protocol dependent).\<close>
fun domain :: "role_t \<Rightarrow> var set" where
"domain Init = {xnx, xgnx, xgny, xsk, xEnd}"
| "domain Resp = {xny, xgnx, xgny, xsk, xEnd}"
consts
test :: rid_t
consts
guessed_runs :: "rid_t \<Rightarrow> run_t"
guessed_frame :: "rid_t \<Rightarrow> frame"
text \<open>Specification of the guessed frame:
\begin{enumerate}
\item Domain
\item Well-typedness.
The messages in the frame of a run never contain implementation material
even if the agents of the run are dishonest.
Therefore we consider only well-typed frames.
This is notably required for the session key compromise; it also helps proving
the partitionning of ik,
since we know that the messages added by the protocol do not contain ltkeys in their
payload and are therefore valid implementations.
\item We also ensure that the values generated by the frame owner are correctly guessed.
\end{enumerate}\<close>
specification (guessed_frame)
guessed_frame_dom_spec [simp]:
"dom (guessed_frame R) = domain (role (guessed_runs R))"
guessed_frame_payload_spec [simp, elim]:
"guessed_frame R x = Some y \<Longrightarrow> y \<in> payload"
guessed_frame_Init_xnx [simp]:
"role (guessed_runs R) = Init \<Longrightarrow> guessed_frame R xnx = Some (NonceF (R$nx))"
guessed_frame_Init_xgnx [simp]:
"role (guessed_runs R) = Init \<Longrightarrow> guessed_frame R xgnx = Some (Exp Gen (NonceF (R$nx)))"
guessed_frame_Resp_xny [simp]:
"role (guessed_runs R) = Resp \<Longrightarrow> guessed_frame R xny = Some (NonceF (R$ny))"
guessed_frame_Resp_xgny [simp]:
"role (guessed_runs R) = Resp \<Longrightarrow> guessed_frame R xgny = Some (Exp Gen (NonceF (R$ny)))"
guessed_frame_xEnd [simp]:
"guessed_frame R xEnd = Some End"
apply (rule exI [of _
"\<lambda>R.
if role (guessed_runs R) = Init then
[xnx \<mapsto> NonceF (R$nx), xgnx \<mapsto> Exp Gen (NonceF (R$nx)), xgny \<mapsto> End,
xsk \<mapsto> End, xEnd \<mapsto> End]
else
[xny \<mapsto> NonceF (R$ny), xgnx \<mapsto> End, xgny \<mapsto> Exp Gen (NonceF (R$ny)),
xsk \<mapsto> End, xEnd \<mapsto> End]"],
auto simp add: domIff intro: role_t.exhaust)
done
abbreviation
"test_owner \<equiv> owner (guessed_runs test)"
abbreviation
"test_partner \<equiv> partner (guessed_runs test)"
text \<open>Level 1 state.\<close>
record l1_state =
s0_state +
progress :: progress_t
signalsInit :: "signal \<Rightarrow> nat"
signalsResp :: "signal \<Rightarrow> nat"
type_synonym l1_obs = "l1_state"
abbreviation
run_ended :: "var set option \<Rightarrow> bool"
where
"run_ended r \<equiv> in_progress r xEnd"
lemma run_ended_not_None [elim]:
"run_ended R \<Longrightarrow> R = None \<Longrightarrow> False"
by (fast dest: in_progress_Some)
text \<open>@{term "test_ended s"} $\longleftrightarrow$ the test run has ended in @{term "s"}.\<close>
abbreviation
test_ended :: "'a l1_state_scheme \<Rightarrow> bool"
where
"test_ended s \<equiv> run_ended (progress s test)"
text \<open>A run can emit signals if it involves the same agents as the test run, and if the test run
has not ended yet.\<close>
definition
can_signal :: "'a l1_state_scheme \<Rightarrow> agent \<Rightarrow> agent \<Rightarrow> bool"
where
"can_signal s A B \<equiv>
((A = test_owner \<and> B = test_partner) \<or> (B = test_owner \<and> A = test_partner)) \<and>
\<not> test_ended s"
text \<open>Events.\<close>
definition
l1_learn :: "msg \<Rightarrow> ('a l1_state_scheme * 'a l1_state_scheme) set"
where
"l1_learn m \<equiv> {(s,s').
\<comment> \<open>guard\<close>
synth (analz (insert m (ik s))) \<inter> (secret s) = {} \<and>
\<comment> \<open>action\<close>
s' = s \<lparr>ik := ik s \<union> {m}\<rparr>
}"
text \<open>Potocol events.\<close>
text \<open>
\begin{itemize}
\item step 1: create @{term "Ra"}, @{term "A"} generates @{term "nx"},
computes $@{term "g"}^@{term "nx"}$
\item step 2: create @{term "Rb"}, @{term "B"} reads $@{term "g"}^@{term "nx"}$ insecurely,
generates @{term "ny"}, computes $@{term "g"}^@{term "ny"}$,
computes $@{term "g"}^@{term "nx*ny"}$,
emits a running signal for @{term "Init"}, $@{term "g"}^@{term "nx*ny"}$
\item step 3: @{term "A"} reads $@{term "g"}^@{term "ny"}$ and $@{term "g"}^@{term "nx"}$
authentically,
computes $@{term "g"}^@{term "ny*nx"}$, emits a commit signal for @{term "Init"},
$@{term "g"}^@{term "ny*nx"}$, a running signal for @{term "Resp"}, $@{term "g"}^@{term "ny*nx"}$,
declares the secret $@{term "g"}^@{term "ny*nx"}$
\item step 4: @{term "B"} reads $@{term "g"}^@{term "nx"}$ and $@{term "g"}^@{term "ny"}$
authentically,
emits a commit signal for @{term "Resp"}, $@{term "g"}^@{term "nx*ny"}$,
declares the secret $@{term "g"}^@{term "nx*ny"}$
\end{itemize}
\<close>
definition
l1_step1 :: "rid_t \<Rightarrow> agent \<Rightarrow> agent \<Rightarrow> ('a l1_state_scheme * 'a l1_state_scheme) set"
where
"l1_step1 Ra A B \<equiv> {(s, s').
\<comment> \<open>guards:\<close>
Ra \<notin> dom (progress s) \<and>
guessed_runs Ra = \<lparr>role=Init, owner=A, partner=B\<rparr> \<and>
\<comment> \<open>actions:\<close>
s' = s\<lparr>
progress := (progress s)(Ra \<mapsto> {xnx, xgnx})
\<rparr>
}"
definition
l1_step2 :: "rid_t \<Rightarrow> agent \<Rightarrow> agent \<Rightarrow> msg \<Rightarrow> ('a l1_state_scheme * 'a l1_state_scheme) set"
where
"l1_step2 Rb A B gnx \<equiv> {(s, s').
\<comment> \<open>guards:\<close>
guessed_runs Rb = \<lparr>role=Resp, owner=B, partner=A\<rparr> \<and>
Rb \<notin> dom (progress s) \<and>
guessed_frame Rb xgnx = Some gnx \<and>
guessed_frame Rb xsk = Some (Exp gnx (NonceF (Rb$ny))) \<and>
\<comment> \<open>actions:\<close>
s' = s\<lparr> progress := (progress s)(Rb \<mapsto> {xny, xgny, xgnx, xsk}),
signalsInit := if can_signal s A B then
addSignal (signalsInit s) (Running A B (Exp gnx (NonceF (Rb$ny))))
else
signalsInit s
\<rparr>
}"
definition
l1_step3 :: "rid_t \<Rightarrow> agent \<Rightarrow> agent \<Rightarrow> msg \<Rightarrow> ('a l1_state_scheme * 'a l1_state_scheme) set"
where
"l1_step3 Ra A B gny \<equiv> {(s, s').
\<comment> \<open>guards:\<close>
guessed_runs Ra = \<lparr>role=Init, owner=A, partner=B\<rparr> \<and>
progress s Ra = Some {xnx, xgnx} \<and>
guessed_frame Ra xgny = Some gny \<and>
guessed_frame Ra xsk = Some (Exp gny (NonceF (Ra$nx))) \<and>
(can_signal s A B \<longrightarrow> \<comment> \<open>authentication guard\<close>
(\<exists> Rb. guessed_runs Rb = \<lparr>role=Resp, owner=B, partner=A\<rparr> \<and>
in_progressS (progress s Rb) {xny, xgnx, xgny, xsk} \<and>
guessed_frame Rb xgny = Some gny \<and>
guessed_frame Rb xgnx = Some (Exp Gen (NonceF (Ra$nx))))) \<and>
(Ra = test \<longrightarrow> Exp gny (NonceF (Ra$nx)) \<notin> synth (analz (ik s))) \<and>
\<comment> \<open>actions:\<close>
s' = s\<lparr> progress := (progress s)(Ra \<mapsto> {xnx, xgnx, xgny, xsk, xEnd}),
secret := {x. x = Exp gny (NonceF (Ra$nx)) \<and> Ra = test} \<union> secret s,
signalsInit := if can_signal s A B then
addSignal (signalsInit s) (Commit A B (Exp gny (NonceF (Ra$nx))))
else
signalsInit s,
signalsResp := if can_signal s A B then
addSignal (signalsResp s) (Running A B (Exp gny (NonceF (Ra$nx))))
else
signalsResp s
\<rparr>
}"
definition
l1_step4 :: "rid_t \<Rightarrow> agent \<Rightarrow> agent \<Rightarrow> msg \<Rightarrow> ('a l1_state_scheme * 'a l1_state_scheme) set"
where
"l1_step4 Rb A B gnx \<equiv> {(s, s').
\<comment> \<open>guards:\<close>
guessed_runs Rb = \<lparr>role=Resp, owner=B, partner=A\<rparr> \<and>
progress s Rb = Some {xny, xgnx, xgny, xsk} \<and>
guessed_frame Rb xgnx = Some gnx \<and>
(can_signal s A B \<longrightarrow> \<comment> \<open>authentication guard\<close>
(\<exists> Ra. guessed_runs Ra = \<lparr>role=Init, owner=A, partner=B\<rparr> \<and>
in_progressS (progress s Ra) {xnx, xgnx, xgny, xsk, xEnd} \<and>
guessed_frame Ra xgnx = Some gnx \<and>
guessed_frame Ra xgny = Some (Exp Gen (NonceF (Rb$ny))))) \<and>
(Rb = test \<longrightarrow> Exp gnx (NonceF (Rb$ny)) \<notin> synth (analz (ik s))) \<and>
\<comment> \<open>actions:\<close>
s' = s\<lparr> progress := (progress s)(Rb \<mapsto> {xny, xgnx, xgny, xsk, xEnd}),
secret := {x. x = Exp gnx (NonceF (Rb$ny)) \<and> Rb = test} \<union> secret s,
signalsResp := if can_signal s A B then
addSignal (signalsResp s) (Commit A B (Exp gnx (NonceF (Rb$ny))))
else
signalsResp s
\<rparr>
}"
text \<open>Specification.\<close>
definition
l1_init :: "l1_state set"
where
"l1_init \<equiv> { \<lparr>
ik = {},
secret = {},
progress = Map.empty,
signalsInit = \<lambda>x. 0,
signalsResp = \<lambda>x. 0
\<rparr> }"
definition
l1_trans :: "('a l1_state_scheme * 'a l1_state_scheme) set" where
"l1_trans \<equiv> (\<Union>m Ra Rb A B x.
l1_step1 Ra A B \<union>
l1_step2 Rb A B x \<union>
l1_step3 Ra A B x \<union>
l1_step4 Rb A B x \<union>
l1_learn m \<union>
Id
)"
definition
l1 :: "(l1_state, l1_obs) spec" where
"l1 \<equiv> \<lparr>
init = l1_init,
trans = l1_trans,
obs = id
\<rparr>"
lemmas l1_defs =
l1_def l1_init_def l1_trans_def
l1_learn_def
l1_step1_def l1_step2_def l1_step3_def l1_step4_def
lemmas l1_nostep_defs =
l1_def l1_init_def l1_trans_def
lemma l1_obs_id [simp]: "obs l1 = id"
by (simp add: l1_def)
lemma run_ended_trans:
"run_ended (progress s R) \<Longrightarrow>
(s, s') \<in> trans l1 \<Longrightarrow>
run_ended (progress s' R)"
apply (auto simp add: l1_nostep_defs)
apply (auto simp add: l1_defs ik_dy_def)
done
lemma can_signal_trans:
"can_signal s' A B \<Longrightarrow>
(s, s') \<in> trans l1 \<Longrightarrow>
can_signal s A B"
by (auto simp add: can_signal_def run_ended_trans)
(**************************************************************************************************)
subsection \<open>Refinement: secrecy\<close>
(**************************************************************************************************)
text \<open>Mediator function.\<close>
definition
med01s :: "l1_obs \<Rightarrow> s0_obs"
where
"med01s t \<equiv> \<lparr> ik = ik t, secret = secret t \<rparr>"
text \<open>Relation between states.\<close>
definition
R01s :: "(s0_state * l1_state) set"
where
"R01s \<equiv> {(s,s').
s = \<lparr>ik = ik s', secret = secret s'\<rparr>
}"
text \<open>Protocol independent events.\<close>
lemma l1_learn_refines_learn:
"{R01s} s0_learn m, l1_learn m {>R01s}"
apply (simp add: PO_rhoare_defs R01s_def)
apply auto
apply (simp add: l1_defs s0_defs s0_secrecy_def)
done
text \<open>Protocol events.\<close>
lemma l1_step1_refines_skip:
"{R01s} Id, l1_step1 Ra A B {>R01s}"
by (auto simp add: PO_rhoare_defs R01s_def l1_step1_def)
lemma l1_step2_refines_skip:
"{R01s} Id, l1_step2 Rb A B gnx {>R01s}"
apply (auto simp add: PO_rhoare_defs R01s_def)
apply (auto simp add: l1_step2_def)
done
lemma l1_step3_refines_add_secret_skip:
"{R01s} s0_add_secret (Exp gny (NonceF (Ra$nx))) \<union> Id, l1_step3 Ra A B gny {>R01s}"
apply (auto simp add: PO_rhoare_defs R01s_def s0_add_secret_def)
apply (auto simp add: l1_step3_def)
done
lemma l1_step4_refines_add_secret_skip:
"{R01s} s0_add_secret (Exp gnx (NonceF (Rb$ny))) \<union> Id, l1_step4 Rb A B gnx {>R01s}"
apply (auto simp add: PO_rhoare_defs R01s_def s0_add_secret_def)
apply (auto simp add: l1_step4_def)
done
text \<open>Refinement proof.\<close>
lemmas l1_trans_refines_s0_trans =
l1_learn_refines_learn
l1_step1_refines_skip l1_step2_refines_skip
l1_step3_refines_add_secret_skip l1_step4_refines_add_secret_skip
lemma l1_refines_init_s0 [iff]:
"init l1 \<subseteq> R01s `` (init s0)"
by (auto simp add: R01s_def s0_defs l1_defs s0_secrecy_def)
lemma l1_refines_trans_s0 [iff]:
"{R01s} trans s0, trans l1 {> R01s}"
by (auto simp add: s0_def l1_def s0_trans_def l1_trans_def
intro: l1_trans_refines_s0_trans)
lemma obs_consistent_med01x [iff]:
"obs_consistent R01s med01s s0 l1"
by (auto simp add: obs_consistent_def R01s_def med01s_def)
text \<open>Refinement result.\<close>
lemma l1s_refines_s0 [iff]:
"refines
R01s
med01s s0 l1"
by (auto simp add:refines_def PO_refines_def)
lemma l1_implements_s0 [iff]: "implements med01s s0 l1"
by (rule refinement_soundness) (fast)
(**************************************************************************************************)
subsection \<open>Derived invariants: secrecy\<close>
(**************************************************************************************************)
abbreviation "l1_secrecy \<equiv> s0_secrecy"
lemma l1_obs_secrecy [iff]: "oreach l1 \<subseteq> l1_secrecy"
apply (rule external_invariant_translation
[OF s0_obs_secrecy _ l1_implements_s0])
apply (auto simp add: med01s_def s0_secrecy_def)
done
lemma l1_secrecy [iff]: "reach l1 \<subseteq> l1_secrecy"
by (rule external_to_internal_invariant [OF l1_obs_secrecy], auto)
(**************************************************************************************************)
subsection \<open>Invariants: @{term "Init"} authenticates @{term "Resp"}\<close>
(**************************************************************************************************)
subsubsection \<open>inv1\<close>
(**************************************************************************************************)
text \<open>If an initiator commit signal exists for $(@{term "g"}^@{term "ny"})^@{term "Ra$nx"}$
then @{term "Ra"} is
@{term "Init"}, has passed step 3, and has \<open>(g^ny)^(Ra$nx)\<close> as the key in its frame.\<close>
definition
l1_inv1 :: "l1_state set"
where
"l1_inv1 \<equiv> {s. \<forall> Ra A B gny.
signalsInit s (Commit A B (Exp gny (NonceF (Ra$nx)))) > 0 \<longrightarrow>
guessed_runs Ra = \<lparr>role=Init, owner=A, partner=B\<rparr> \<and>
progress s Ra = Some {xnx, xgnx, xgny, xsk, xEnd} \<and>
guessed_frame Ra xsk = Some (Exp gny (NonceF (Ra$nx)))
}"
lemmas l1_inv1I = l1_inv1_def [THEN setc_def_to_intro, rule_format]
lemmas l1_inv1E [elim] = l1_inv1_def [THEN setc_def_to_elim, rule_format]
lemmas l1_inv1D = l1_inv1_def [THEN setc_def_to_dest, rule_format, rotated 1, simplified]
lemma l1_inv1_init [iff]:
"init l1 \<subseteq> l1_inv1"
by (auto simp add: l1_def l1_init_def l1_inv1_def)
lemma l1_inv1_trans [iff]:
"{l1_inv1} trans l1 {> l1_inv1}"
apply (auto simp add: PO_hoare_defs l1_nostep_defs intro!: l1_inv1I)
apply (auto simp add: l1_defs ik_dy_def l1_inv1_def dest: Exp_Exp_Gen_inj2 [OF sym])
done
lemma PO_l1_inv1 [iff]: "reach l1 \<subseteq> l1_inv1"
by (rule inv_rule_basic) (auto)
subsubsection \<open>inv2\<close>
(**************************************************************************************************)
text \<open>If a @{term "Resp"} run @{term "Rb"} has passed step 2 then
(if possible) an initiator running signal has been emitted.\<close>
definition
l1_inv2 :: "l1_state set"
where
"l1_inv2 \<equiv> {s. \<forall> gnx A B Rb.
guessed_runs Rb = \<lparr>role=Resp, owner=B, partner=A\<rparr> \<longrightarrow>
in_progressS (progress s Rb) {xny, xgnx, xgny, xsk} \<longrightarrow>
guessed_frame Rb xgnx = Some gnx \<longrightarrow>
can_signal s A B \<longrightarrow>
signalsInit s (Running A B (Exp gnx (NonceF (Rb$ny)))) > 0
}"
lemmas l1_inv2I = l1_inv2_def [THEN setc_def_to_intro, rule_format]
lemmas l1_inv2E [elim] = l1_inv2_def [THEN setc_def_to_elim, rule_format]
lemmas l1_inv2D = l1_inv2_def [THEN setc_def_to_dest, rule_format, rotated 1, simplified]
lemma l1_inv2_init [iff]:
"init l1 \<subseteq> l1_inv2"
by (auto simp add: l1_def l1_init_def l1_inv2_def)
lemma l1_inv2_trans [iff]:
"{l1_inv2} trans l1 {> l1_inv2}"
apply (auto simp add: PO_hoare_defs intro!: l1_inv2I)
apply (drule can_signal_trans, assumption)
apply (auto simp add: l1_nostep_defs)
apply (auto simp add: l1_defs ik_dy_def l1_inv2_def)
done
lemma PO_l1_inv2 [iff]: "reach l1 \<subseteq> l1_inv2"
by (rule inv_rule_basic) (auto)
subsubsection \<open>inv3 (derived)\<close>
(**************************************************************************************************)
text \<open>
If an @{term "Init"} run before step 3 and a @{term "Resp"} run after step 2 both know the same
half-keys (more or less), then the number of @{term "Init"} running signals for the key is strictly
greater than the number of @{term "Init"} commit signals.
(actually, there are 0 commit and 1 running).
\<close>
definition
l1_inv3 :: "l1_state set"
where
"l1_inv3 \<equiv> {s. \<forall> A B Rb Ra gny.
guessed_runs Rb = \<lparr>role=Resp, owner=B, partner=A\<rparr> \<longrightarrow>
in_progressS (progress s Rb) {xny, xgnx, xgny, xsk} \<longrightarrow>
guessed_frame Rb xgny = Some gny \<longrightarrow>
guessed_frame Rb xgnx = Some (Exp Gen (NonceF (Ra$nx))) \<longrightarrow>
guessed_runs Ra = \<lparr>role=Init, owner=A, partner=B\<rparr> \<longrightarrow>
progress s Ra = Some {xnx, xgnx} \<longrightarrow>
can_signal s A B \<longrightarrow>
signalsInit s (Commit A B (Exp gny (NonceF (Ra$nx))))
< signalsInit s (Running A B (Exp gny (NonceF (Ra$nx))))
}"
lemmas l1_inv3I = l1_inv3_def [THEN setc_def_to_intro, rule_format]
lemmas l1_inv3E [elim] = l1_inv3_def [THEN setc_def_to_elim, rule_format]
lemmas l1_inv3D = l1_inv3_def [THEN setc_def_to_dest, rule_format, rotated 1, simplified]
lemma l1_inv3_derived: "l1_inv1 \<inter> l1_inv2 \<subseteq> l1_inv3"
apply (auto intro!: l1_inv3I)
apply (auto dest!: l1_inv2D)
apply (rename_tac x A B Rb Ra)
apply (case_tac
"signalsInit x (Commit A B (Exp (Exp Gen (NonceF (Rb $ ny))) (NonceF (Ra $ nx)))) > 0", auto)
apply (fastforce dest: l1_inv1D elim: equalityE)
done
subsection \<open>Invariants: @{term "Resp"} authenticates @{term "Init"}\<close>
(**************************************************************************************************)
subsubsection \<open>inv4\<close>
(**************************************************************************************************)
text \<open>If a @{term "Resp"} commit signal exists for $(@{term "g"}^@{term "nx"})^@{term "Rb$ny"}$
then @{term "Rb"} is @{term "Resp"}, has finished its run, and
has $(@{term "g"}^@{term "nx"})^@{term "Rb$ny"}$ as the key in its frame.\<close>
definition
l1_inv4 :: "l1_state set"
where
"l1_inv4 \<equiv> {s. \<forall> Rb A B gnx.
signalsResp s (Commit A B (Exp gnx (NonceF (Rb$ny)))) > 0 \<longrightarrow>
guessed_runs Rb = \<lparr>role=Resp, owner=B, partner=A\<rparr> \<and>
progress s Rb = Some {xny, xgnx, xgny, xsk, xEnd} \<and>
guessed_frame Rb xgnx = Some gnx
}"
lemmas l1_inv4I = l1_inv4_def [THEN setc_def_to_intro, rule_format]
lemmas l1_inv4E [elim] = l1_inv4_def [THEN setc_def_to_elim, rule_format]
lemmas l1_inv4D = l1_inv4_def [THEN setc_def_to_dest, rule_format, rotated 1, simplified]
lemma l1_inv4_init [iff]:
"init l1 \<subseteq> l1_inv4"
by (auto simp add: l1_def l1_init_def l1_inv4_def)
declare domIff [iff]
lemma l1_inv4_trans [iff]:
"{l1_inv4} trans l1 {> l1_inv4}"
apply (auto simp add: PO_hoare_defs l1_nostep_defs intro!: l1_inv4I)
apply (auto simp add: l1_inv4_def l1_defs ik_dy_def dest: Exp_Exp_Gen_inj2 [OF sym])
done
declare domIff [iff del]
lemma PO_l1_inv4 [iff]: "reach l1 \<subseteq> l1_inv4"
by (rule inv_rule_basic) (auto)
subsubsection \<open>inv5\<close>
(**************************************************************************************************)
text \<open>If an @{term "Init"} run @{term "Ra"} has passed step3 then (if possible) a
@{term "Resp"} running signal has been emitted.\<close>
definition
l1_inv5 :: "l1_state set"
where
"l1_inv5 \<equiv> {s. \<forall> gny A B Ra.
guessed_runs Ra = \<lparr>role=Init, owner=A, partner=B\<rparr> \<longrightarrow>
in_progressS (progress s Ra) {xnx, xgnx, xgny, xsk, xEnd} \<longrightarrow>
guessed_frame Ra xgny = Some gny \<longrightarrow>
can_signal s A B \<longrightarrow>
signalsResp s (Running A B (Exp gny (NonceF (Ra$nx)))) > 0
}"
lemmas l1_inv5I = l1_inv5_def [THEN setc_def_to_intro, rule_format]
lemmas l1_inv5E [elim] = l1_inv5_def [THEN setc_def_to_elim, rule_format]
lemmas l1_inv5D = l1_inv5_def [THEN setc_def_to_dest, rule_format, rotated 1, simplified]
lemma l1_inv5_init [iff]:
"init l1 \<subseteq> l1_inv5"
by (auto simp add: l1_def l1_init_def l1_inv5_def)
lemma l1_inv5_trans [iff]:
"{l1_inv5} trans l1 {> l1_inv5}"
apply (auto simp add: PO_hoare_defs intro!: l1_inv5I)
apply (drule can_signal_trans, assumption)
apply (auto simp add: l1_nostep_defs)
apply (auto simp add: l1_defs ik_dy_def l1_inv5_def)
done
lemma PO_l1_inv5 [iff]: "reach l1 \<subseteq> l1_inv5"
by (rule inv_rule_basic) (auto)
subsubsection \<open>inv6 (derived)\<close>
(**************************************************************************************************)
text \<open>If a @{term "Resp"} run before step 4 and an @{term "Init"} run after step 3 both know
the same half-keys (more or less), then the number of @{term "Resp"} running signals
for the key is strictly greater than the number of @{term "Resp"} commit signals.
(actually, there are 0 commit and 1 running).
\<close>
definition
l1_inv6 :: "l1_state set"
where
"l1_inv6 \<equiv> {s. \<forall> A B Rb Ra gnx.
guessed_runs Ra = \<lparr>role=Init, owner=A, partner=B\<rparr> \<longrightarrow>
in_progressS (progress s Ra) {xnx, xgnx, xgny, xsk, xEnd} \<longrightarrow>
guessed_frame Ra xgnx = Some gnx \<longrightarrow>
guessed_frame Ra xgny = Some (Exp Gen (NonceF (Rb$ny))) \<longrightarrow>
guessed_runs Rb = \<lparr>role=Resp, owner=B, partner=A\<rparr> \<longrightarrow>
progress s Rb = Some {xny, xgnx, xgny, xsk} \<longrightarrow>
can_signal s A B \<longrightarrow>
signalsResp s (Commit A B (Exp gnx (NonceF (Rb$ny))))
< signalsResp s (Running A B (Exp gnx (NonceF (Rb$ny))))
}"
lemmas l1_inv6I = l1_inv6_def [THEN setc_def_to_intro, rule_format]
lemmas l1_inv6E [elim] = l1_inv6_def [THEN setc_def_to_elim, rule_format]
lemmas l1_inv6D = l1_inv6_def [THEN setc_def_to_dest, rule_format, rotated 1, simplified]
lemma l1_inv6_derived:
"l1_inv4 \<inter> l1_inv5 \<subseteq> l1_inv6"
proof (auto intro!: l1_inv6I)
fix s::l1_state fix A B Rb Ra
assume HRun:"guessed_runs Ra = \<lparr>role = Init, owner = A, partner = B\<rparr>"
"in_progressS (progress s Ra) {xnx, xgnx, xgny, xsk, xEnd}"
"guessed_frame Ra xgny = Some (Exp Gen (NonceF (Rb $ ny)))"
"can_signal s A B"
assume HRb: "progress s Rb = Some {xny, xgnx, xgny, xsk}"
assume I4:"s \<in> l1_inv4"
assume I5:"s \<in> l1_inv5"
from I4 HRb
have "signalsResp s (Commit A B (Exp (Exp Gen (NonceF (Rb $ ny))) (NonceF (Ra $ nx)))) > 0
\<Longrightarrow> False"
proof (auto dest!: l1_inv4D)
assume "{xny, xgnx, xgny, xsk, xEnd} = {xny, xgnx, xgny, xsk}"
thus ?thesis by force
qed
then have
HC: "signalsResp s (Commit A B (Exp (Exp Gen (NonceF (Rb $ ny))) (NonceF (Ra $ nx)))) = 0"
by auto
from I5 HRun
have "signalsResp s (Running A B (Exp (Exp Gen (NonceF (Rb $ ny))) (NonceF (Ra $ nx)))) > 0"
by (auto dest!: l1_inv5D)
with HC show
"signalsResp s (Commit A B (Exp (Exp Gen (NonceF (Rb $ ny))) (NonceF (Ra $ nx))))
< signalsResp s (Running A B (Exp (Exp Gen (NonceF (Rb $ ny))) (NonceF (Ra $ nx))))"
by auto
qed
(**************************************************************************************************)
subsection \<open>Refinement: injective agreement (@{term "Init"} authenticates @{term "Resp"})\<close>
(**************************************************************************************************)
text \<open>Mediator function.\<close>
definition
med01iai :: "l1_obs \<Rightarrow> a0i_obs"
where
"med01iai t \<equiv> \<lparr>a0n_state.signals = signalsInit t\<rparr>"
text \<open>Relation between states.\<close>
definition
R01iai :: "(a0i_state * l1_state) set"
where
"R01iai \<equiv> {(s,s').
a0n_state.signals s = signalsInit s'
}"
text \<open>Protocol-independent events.\<close>
lemma l1_learn_refines_a0_ia_skip_i:
"{R01iai} Id, l1_learn m {>R01iai}"
apply (auto simp add: PO_rhoare_defs R01iai_def)
apply (simp add: l1_learn_def)
done
text \<open>Protocol events.\<close>
lemma l1_step1_refines_a0i_skip_i:
"{R01iai} Id, l1_step1 Ra A B {>R01iai}"
by (auto simp add: PO_rhoare_defs R01iai_def l1_step1_def)
lemma l1_step2_refines_a0i_running_skip_i:
"{R01iai} a0i_running A B (Exp gnx (NonceF (Rb$ny))) \<union> Id, l1_step2 Rb A B gnx {>R01iai}"
by (auto simp add: PO_rhoare_defs R01iai_def, simp_all add: l1_step2_def a0i_running_def, auto)
lemma l1_step3_refines_a0i_commit_skip_i:
"{R01iai \<inter> (UNIV \<times> l1_inv3)}
a0i_commit A B (Exp gny (NonceF (Ra$nx))) \<union> Id,
l1_step3 Ra A B gny
{>R01iai}"
apply (auto simp add: PO_rhoare_defs R01iai_def)
apply (auto simp add: l1_step3_def a0i_commit_def)
apply (force elim!: l1_inv3E)+
done
lemma l1_step4_refines_a0i_skip_i:
"{R01iai} Id, l1_step4 Rb A B gnx {>R01iai}"
by (auto simp add: PO_rhoare_defs R01iai_def, auto simp add: l1_step4_def)
text \<open>Refinement proof.\<close>
lemmas l1_trans_refines_a0i_trans_i =
l1_learn_refines_a0_ia_skip_i
l1_step1_refines_a0i_skip_i l1_step2_refines_a0i_running_skip_i
l1_step3_refines_a0i_commit_skip_i l1_step4_refines_a0i_skip_i
lemma l1_refines_init_a0i_i [iff]:
"init l1 \<subseteq> R01iai `` (init a0i)"
by (auto simp add: R01iai_def a0i_defs l1_defs)
lemma l1_refines_trans_a0i_i [iff]:
"{R01iai \<inter> (UNIV \<times> (l1_inv1 \<inter> l1_inv2))} trans a0i, trans l1 {> R01iai}"
proof -
let ?pre' = "R01iai \<inter> (UNIV \<times> l1_inv3)"
show ?thesis (is "{?pre} ?t1, ?t2 {>?post}")
proof (rule relhoare_conseq_left)
show "?pre \<subseteq> ?pre'"
using l1_inv3_derived by blast
next
show "{?pre'} ?t1, ?t2 {> ?post}"
apply (auto simp add: a0i_def l1_def a0i_trans_def l1_trans_def)
prefer 2 using l1_step2_refines_a0i_running_skip_i apply (simp add: PO_rhoare_defs, blast)
prefer 2 using l1_step3_refines_a0i_commit_skip_i apply (simp add: PO_rhoare_defs, blast)
apply (blast intro!:l1_trans_refines_a0i_trans_i)+
done
qed
qed
lemma obs_consistent_med01iai [iff]:
"obs_consistent R01iai med01iai a0i l1"
by (auto simp add: obs_consistent_def R01iai_def med01iai_def)
text \<open>Refinement result.\<close>
lemma l1_refines_a0i_i [iff]:
"refines
(R01iai \<inter> (reach a0i \<times> (l1_inv1 \<inter> l1_inv2)))
med01iai a0i l1"
by (rule Refinement_using_invariants, auto)
lemma l1_implements_a0i_i [iff]: "implements med01iai a0i l1"
by (rule refinement_soundness) (fast)
(**************************************************************************************************)
subsection \<open>Derived invariants: injective agreement (@{term "Init"} authenticates @{term "Resp"})\<close>
(**************************************************************************************************)
definition
l1_iagreement_Init :: "('a l1_state_scheme) set"
where
"l1_iagreement_Init \<equiv> {s. \<forall> A B N.
signalsInit s (Commit A B N) \<le> signalsInit s (Running A B N)
}"
lemmas l1_iagreement_InitI = l1_iagreement_Init_def [THEN setc_def_to_intro, rule_format]
lemmas l1_iagreement_InitE [elim] = l1_iagreement_Init_def [THEN setc_def_to_elim, rule_format]
lemma l1_obs_iagreement_Init [iff]: "oreach l1 \<subseteq> l1_iagreement_Init"
apply (rule external_invariant_translation
[OF PO_a0i_obs_agreement _ l1_implements_a0i_i])
apply (auto simp add: med01iai_def l1_iagreement_Init_def a0i_agreement_def)
done
lemma l1_iagreement_Init [iff]: "reach l1 \<subseteq> l1_iagreement_Init"
by (rule external_to_internal_invariant [OF l1_obs_iagreement_Init], auto)
(**************************************************************************************************)
subsection \<open>Refinement: injective agreement (@{term "Resp"} authenticates @{term "Init"})\<close>
(**************************************************************************************************)
text \<open>Mediator function.\<close>
definition
med01iar :: "l1_obs \<Rightarrow> a0i_obs"
where
"med01iar t \<equiv> \<lparr>a0n_state.signals = signalsResp t\<rparr>"
text \<open>Relation between states.\<close>
definition
R01iar :: "(a0i_state * l1_state) set"
where
"R01iar \<equiv> {(s,s').
a0n_state.signals s = signalsResp s'
}"
text \<open>Protocol-independent events.\<close>
lemma l1_learn_refines_a0_ia_skip_r:
"{R01iar} Id, l1_learn m {>R01iar}"
apply (auto simp add: PO_rhoare_defs R01iar_def)
apply (simp add: l1_learn_def)
done
text \<open>Protocol events.\<close>
lemma l1_step1_refines_a0i_skip_r:
"{R01iar} Id, l1_step1 Ra A B {>R01iar}"
by (auto simp add: PO_rhoare_defs R01iar_def l1_step1_def)
lemma l1_step2_refines_a0i_skip_r:
"{R01iar} Id, l1_step2 Rb A B gnx {>R01iar}"
by (auto simp add: PO_rhoare_defs R01iar_def, auto simp add:l1_step2_def)
lemma l1_step3_refines_a0i_running_skip_r:
"{R01iar} a0i_running A B (Exp gny (NonceF (Ra$nx))) \<union> Id, l1_step3 Ra A B gny {>R01iar}"
by (auto simp add: PO_rhoare_defs R01iar_def, simp_all add: l1_step3_def a0i_running_def, auto)
lemma l1_step4_refines_a0i_commit_skip_r:
"{R01iar \<inter> UNIV\<times>l1_inv6}
a0i_commit A B (Exp gnx (NonceF (Rb$ny))) \<union> Id,
l1_step4 Rb A B gnx
{>R01iar}"
apply (auto simp add: PO_rhoare_defs R01iar_def)
apply (auto simp add: l1_step4_def a0i_commit_def)
apply (auto dest!: l1_inv6D [rotated 1])
done
text \<open>Refinement proofs.\<close>
lemmas l1_trans_refines_a0i_trans_r =
l1_learn_refines_a0_ia_skip_r
l1_step1_refines_a0i_skip_r l1_step2_refines_a0i_skip_r
l1_step3_refines_a0i_running_skip_r l1_step4_refines_a0i_commit_skip_r
lemma l1_refines_init_a0i_r [iff]:
"init l1 \<subseteq> R01iar `` (init a0i)"
by (auto simp add: R01iar_def a0i_defs l1_defs)
lemma l1_refines_trans_a0i_r [iff]:
"{R01iar \<inter> (UNIV \<times> (l1_inv4 \<inter> l1_inv5))} trans a0i, trans l1 {> R01iar}"
proof -
let ?pre' = "R01iar \<inter> (UNIV \<times> l1_inv6)"
show ?thesis (is "{?pre} ?t1, ?t2 {>?post}")
proof (rule relhoare_conseq_left)
show "?pre \<subseteq> ?pre'"
using l1_inv6_derived by blast
next
show "{?pre'} ?t1, ?t2 {> ?post}"
apply (auto simp add: a0i_def l1_def a0i_trans_def l1_trans_def)
prefer 3 using l1_step3_refines_a0i_running_skip_r apply (simp add: PO_rhoare_defs, blast)
prefer 3 using l1_step4_refines_a0i_commit_skip_r apply (simp add: PO_rhoare_defs, blast)
apply (blast intro!:l1_trans_refines_a0i_trans_r)+
done
qed
qed
lemma obs_consistent_med01iar [iff]:
"obs_consistent R01iar med01iar a0i l1"
by (auto simp add: obs_consistent_def R01iar_def med01iar_def)
text \<open>Refinement result.\<close>
lemma l1_refines_a0i_r [iff]:
"refines
(R01iar \<inter> (reach a0i \<times> (l1_inv4 \<inter> l1_inv5)))
med01iar a0i l1"
by (rule Refinement_using_invariants, auto)
lemma l1_implements_a0i_r [iff]: "implements med01iar a0i l1"
by (rule refinement_soundness) (fast)
(**************************************************************************************************)
subsection \<open>Derived invariants: injective agreement (@{term "Resp"} authenticates @{term "Init"})\<close>
(**************************************************************************************************)
definition
l1_iagreement_Resp :: "('a l1_state_scheme) set"
where
"l1_iagreement_Resp \<equiv> {s. \<forall> A B N.
signalsResp s (Commit A B N) \<le> signalsResp s (Running A B N)
}"
lemmas l1_iagreement_RespI = l1_iagreement_Resp_def [THEN setc_def_to_intro, rule_format]
lemmas l1_iagreement_RespE [elim] = l1_iagreement_Resp_def [THEN setc_def_to_elim, rule_format]
lemma l1_obs_iagreement_Resp [iff]: "oreach l1 \<subseteq> l1_iagreement_Resp"
apply (rule external_invariant_translation
[OF PO_a0i_obs_agreement _ l1_implements_a0i_r])
apply (auto simp add: med01iar_def l1_iagreement_Resp_def a0i_agreement_def)
done
lemma l1_iagreement_Resp [iff]: "reach l1 \<subseteq> l1_iagreement_Resp"
by (rule external_to_internal_invariant [OF l1_obs_iagreement_Resp], auto)
end
|
/-
Copyright (c) 2020 James Arthur. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: James Arthur, Chris Hughes, Shing Tak Lam
-/
import Mathlib.PrePort
import Mathlib.Lean3Lib.init.default
import Mathlib.analysis.special_functions.trigonometric
import Mathlib.PostPort
namespace Mathlib
/-!
# Inverse of the sinh function
In this file we prove that sinh is bijective and hence has an
inverse, arsinh.
## Main Results
- `sinh_injective`: The proof that `sinh` is injective
- `sinh_surjective`: The proof that `sinh` is surjective
- `sinh_bijective`: The proof `sinh` is bijective
- `arsinh`: The inverse function of `sinh`
## Tags
arsinh, arcsinh, argsinh, asinh, sinh injective, sinh bijective, sinh surjective
-/
namespace real
/-- `arsinh` is defined using a logarithm, `arsinh x = log (x + sqrt(1 + x^2))`. -/
def arsinh (x : ℝ) : ℝ := log (x + sqrt (1 + x ^ bit0 1))
/-- `sinh` is injective, `∀ a b, sinh a = sinh b → a = b`. -/
theorem sinh_injective : function.injective sinh := strict_mono.injective sinh_strict_mono
/-- `arsinh` is the right inverse of `sinh`. -/
theorem sinh_arsinh (x : ℝ) : sinh (arsinh x) = x := sorry
/-- `sinh` is surjective, `∀ b, ∃ a, sinh a = b`. In this case, we use `a = arsinh b`. -/
theorem sinh_surjective : function.surjective sinh := function.left_inverse.surjective sinh_arsinh
/-- `sinh` is bijective, both injective and surjective. -/
theorem sinh_bijective : function.bijective sinh :=
{ left := sinh_injective, right := sinh_surjective }
/-- A rearrangement and `sqrt` of `real.cosh_sq_sub_sinh_sq`. -/
theorem sqrt_one_add_sinh_sq (x : ℝ) : sqrt (1 + sinh x ^ bit0 1) = cosh x := sorry
/-- `arsinh` is the left inverse of `sinh`. -/
theorem arsinh_sinh (x : ℝ) : arsinh (sinh x) = x :=
function.right_inverse_of_injective_of_left_inverse sinh_injective sinh_arsinh x
end Mathlib |
From Cdcl Require Import Itauto. #[local] Tactic Notation "itauto" := itauto auto.
From stdpp Require Import prelude.
From Coq Require Import Classical.
From sets Require Import Functions.
Section sec_ensemble.
Definition Ensemble (idomain : Type) : Type := idomain -> Prop.
Definition top (idomain : Type) : Ensemble idomain := const true.
Context
[idomain : Type].
#[export] Instance pow_set_elem_of : ElemOf idomain (Ensemble idomain) := fun x A => A x.
#[export] Instance pow_set_empty : Empty (Ensemble idomain) := const False.
#[export] Instance pow_set_singleton : Singleton idomain (Ensemble idomain) :=
fun x => fun y => y = x.
#[export] Instance pow_set_union : Union (Ensemble idomain) :=
fun A B => fun x => x ∈ A \/ x ∈ B.
#[export] Instance pow_set_intersection : Intersection (Ensemble idomain) :=
fun A B => fun x => x ∈ A /\ x ∈ B.
#[export] Instance pow_set_difference : Difference (Ensemble idomain) :=
fun A B => fun x => x ∈ A /\ x ∉ B.
#[export] Instance pow_set_semiset : SemiSet idomain (Ensemble idomain).
Proof. by split; [inversion 1 |..]. Qed.
#[export] Instance pow_set_set : Set_ idomain (Ensemble idomain).
Proof. by split; [typeclasses eauto |..]. Qed.
Definition complement (A : Ensemble idomain) : Ensemble idomain := fun a => a ∉ A.
Lemma elem_of_equiv_top X : X ≡ top idomain ↔ ∀ x, x ∈ X.
Proof. set_solver. Qed.
Lemma top_subseteq_equiv A : top idomain ⊆ A <-> A ≡ top idomain.
Proof. by split; intro Hsub; [split; [done |] | intro]; apply Hsub. Qed.
Definition filtered_union
`(P : index -> Prop) (A : index -> (Ensemble idomain)) : (Ensemble idomain) :=
fun a => exists i, P i /\ a ∈ A i.
Lemma elem_of_filtered_union
a `(P : index -> Prop) (A : index -> (Ensemble idomain)) :
a ∈ filtered_union P A <-> exists i, P i /\ a ∈ A i.
Proof. done. Qed.
Lemma member_of_filtered_union `(P : index -> Prop) (A : index -> (Ensemble idomain)) i :
P i -> A i ⊆ filtered_union P A.
Proof. by intros Hi a HAi; apply elem_of_filtered_union; eexists. Qed.
Lemma empty_filtered_union `(P : index -> Prop) (A : index -> (Ensemble idomain)) :
filtered_union P A ≡ ∅ <-> forall i, P i -> A i ≡ ∅.
Proof.
split.
- intros Hunion i; rewrite elem_of_equiv_empty; intros Hi a Ha.
by apply (Hunion a), elem_of_filtered_union; eexists.
- intro Hunion; rewrite elem_of_equiv_empty; intro a.
rewrite elem_of_filtered_union; intros (? & ? & ?).
by eapply Hunion.
Qed.
Definition indexed_union {index} : (index -> (Ensemble idomain)) -> (Ensemble idomain) :=
filtered_union (const True).
Lemma elem_of_indexed_union a `(A : index -> (Ensemble idomain)) :
a ∈ indexed_union A <-> exists i, a ∈ A i.
Proof.
unfold indexed_union; rewrite elem_of_filtered_union.
by split; intros [i Hi]; exists i; [apply Hi | split].
Qed.
Lemma member_of_indexed_union `(A : index -> (Ensemble idomain)) i :
A i ⊆ indexed_union A.
Proof. by apply member_of_filtered_union. Qed.
Lemma empty_indexed_union `(A : index -> (Ensemble idomain)) :
indexed_union A ≡ ∅ <-> forall i, A i ≡ ∅.
Proof.
unfold indexed_union; rewrite empty_filtered_union.
cbn; itauto.
Qed.
Definition filtered_intersection
`(P : index -> Prop) (A : index -> (Ensemble idomain)) : (Ensemble idomain) :=
fun a => forall i, P i -> a ∈ A i.
Lemma elem_of_filtered_intersection
a `(P : index -> Prop) (A : index -> (Ensemble idomain)) :
a ∈ filtered_intersection P A <-> forall i, P i -> a ∈ A i.
Proof. done. Qed.
Lemma member_of_filtered_intersection `(P : index -> Prop) (A : index -> (Ensemble idomain)) i :
P i -> filtered_intersection P A ⊆ A i.
Proof. by intros Hi a; rewrite elem_of_filtered_intersection; intros HA; apply HA. Qed.
Lemma filtered_intersection_empty_top
`(P : index -> Prop) (A : index -> (Ensemble idomain)) :
(forall i, ~ P i) -> filtered_intersection P A ≡ top idomain.
Proof.
intros HnP; apply elem_of_equiv_top; intro a.
apply elem_of_filtered_intersection; intros i HPi.
by exfalso; eapply HnP.
Qed.
Definition indexed_intersection {index} : (index -> (Ensemble idomain)) -> (Ensemble idomain) :=
filtered_intersection (const True).
Lemma elem_of_indexed_intersection a `(A : index -> (Ensemble idomain)) :
a ∈ indexed_intersection A <-> forall i, a ∈ A i.
Proof.
unfold indexed_intersection; rewrite elem_of_filtered_intersection.
by split; intros Hall **; apply Hall.
Qed.
Lemma member_of_indexed_intersection `(A : index -> (Ensemble idomain)) i :
indexed_intersection A ⊆ A i.
Proof. by apply member_of_filtered_intersection. Qed.
Lemma filtered_intersection_subseteq_filtered_union
`(P : index -> Prop) (A : index -> (Ensemble idomain)) :
(exists i, P i) -> filtered_intersection P A ⊆ filtered_union P A.
Proof.
intros [] a; rewrite elem_of_filtered_intersection, elem_of_filtered_union.
by intros Hall; eexists; split; [| apply Hall].
Qed.
Lemma indexed_intersection_subseteq_indexed_union
`{Inhabited index} (A : index -> (Ensemble idomain)) :
indexed_intersection A ⊆ indexed_union A.
Proof.
apply filtered_intersection_subseteq_filtered_union.
by exists inhabitant.
Qed.
Definition intersection_list : list (Ensemble idomain) → Ensemble idomain :=
fold_right (∩) (top idomain).
Notation "⋂ l" := (intersection_list l) (at level 20, format "⋂ l") : stdpp_scope.
Lemma elem_of_intersection_list Xs x : x ∈ ⋂ Xs ↔ forall X, X ∈ Xs -> x ∈ X.
Proof.
split.
- induction Xs; simpl; intros HXs; [inversion 1|].
setoid_rewrite elem_of_cons. rewrite elem_of_intersection in HXs. naive_solver.
- induction Xs; intro HXs; [done |].
simpl; apply elem_of_intersection; split; [apply HXs | apply IHXs]; [left |].
by intros; apply HXs; right.
Qed.
Definition sym_diff (A B : (Ensemble idomain)) : (Ensemble idomain) := (A ∖ B) ∪ (B ∖ A).
#[export] Instance complement_subseteq_proper : Proper ((⊆) --> (⊆)) complement.
Proof.
intros B C Hbc a; unfold complement, elem_of, pow_set_elem_of.
by intro Hb; contradict Hb; apply Hbc.
Qed.
Lemma complement_subseteq_iff_classic B C : B ⊆ C <-> complement C ⊆ complement B.
Proof.
split; [apply complement_subseteq_proper |].
intros Hbc b Hb.
destruct (classic (b ∈ C)); [done |].
by contradict Hb; apply Hbc.
Qed.
#[export] Instance complement_equiv_proper : Proper ((≡) ==> (≡)) complement.
Proof.
intros B C; rewrite !set_equiv_subseteq.
intros [Hbc Hcb]; split.
- by rewrite <- Hcb.
- by rewrite <- Hbc.
Qed.
Lemma complement_equiv_proper_iff_classic B C : B ≡ C <-> complement B ≡ complement C.
Proof.
by rewrite !set_equiv_subseteq, <- !complement_subseteq_iff_classic; set_solver.
Qed.
Lemma elem_of_complement a A : a ∈ complement A <-> a ∉ A.
Proof. done. Qed.
Lemma complement_top A : complement A ≡ top idomain <-> A ≡ ∅.
Proof.
split; [| intros ->].
- intros Hcompl a; split; [| done]; intro Ha.
destruct (Hcompl a) as [_ Hcompl'].
by feed specialize Hcompl'.
- by rewrite elem_of_equiv_top; intro; apply elem_of_complement, not_elem_of_empty.
Qed.
Lemma complement_twice_classic A : complement (complement A) ≡ A.
Proof.
intro a; rewrite !elem_of_complement.
split; [| by intros ? ?].
by intro; apply NNPP.
Qed.
Lemma complement_empty_classic A : complement A ≡ ∅ <-> A ≡ top idomain.
Proof.
by rewrite <- complement_top, complement_twice_classic.
Qed.
Lemma complement_union_classic A B :
complement (A ∪ B) ≡ complement A ∩ complement B.
Proof.
intro a; rewrite elem_of_intersection, !elem_of_complement, elem_of_union.
by split; [apply not_or_and | intros [] []].
Qed.
Lemma complement_intersection_classic A B :
complement (A ∩ B) ≡ complement A ∪ complement B.
Proof.
intro a; rewrite elem_of_union, !elem_of_complement, elem_of_intersection.
by split; [apply not_and_or | intros [] []].
Qed.
Lemma complement_filtered_union `(P : index -> Prop) (A : index -> (Ensemble idomain)) :
complement (filtered_union P A) ≡ filtered_intersection P (complement ∘ A).
Proof.
intro x; rewrite elem_of_filtered_intersection; setoid_rewrite elem_of_complement;
rewrite elem_of_filtered_union.
split; [| by intros Hix (i & Hi & Hx); eapply Hix].
by intros Hnix i Hi; contradict Hnix; eexists.
Qed.
Lemma complement_indexed_union `(f : index -> (Ensemble idomain)) :
complement (indexed_union f) ≡ indexed_intersection (complement ∘ f).
Proof. by unfold indexed_union; rewrite complement_filtered_union. Qed.
Lemma complement_filtered_intersection_classic `(P : index -> Prop) `(A : index -> (Ensemble idomain)) :
complement (filtered_intersection P A) ≡ filtered_union P (complement ∘ A).
Proof.
intro x; rewrite elem_of_filtered_union; setoid_rewrite elem_of_complement;
rewrite elem_of_filtered_intersection.
split; [| by intros (i & Hi & Hx); contradict Hx; apply Hx].
intros Hnot; apply not_all_ex_not in Hnot as [i Hnot].
by eexists; apply imply_to_and in Hnot.
Qed.
Lemma complement_indexed_intersection_classic `(f : index -> (Ensemble idomain)) :
complement (indexed_intersection f) ≡ indexed_union (complement ∘ f).
Proof.
by unfold indexed_intersection; rewrite complement_filtered_intersection_classic.
Qed.
#[export] Instance intersection_empty_l : LeftId (≡@{(Ensemble idomain)}) (top idomain) (∩).
Proof. intros X. set_solver. Qed.
#[export] Instance intersection_empty_r : RightId (≡@{(Ensemble idomain)}) (top idomain) (∩).
Proof. intros X. set_solver. Qed.
Lemma top_intersection A B : A ∩ B ≡ top idomain <-> A ≡ top idomain /\ B ≡ top idomain.
Proof. set_solver. Qed.
Lemma top_filtered_intersection `(P : index -> Prop) (f : index -> (Ensemble idomain)) :
filtered_intersection P f ≡ top idomain
<->
forall B, P B -> f B ≡ top idomain.
Proof.
setoid_rewrite elem_of_equiv_top; setoid_rewrite elem_of_filtered_intersection.
itauto.
Qed.
Lemma top_indexed_intersection (f : Ensemble idomain -> Ensemble idomain) :
indexed_intersection f ≡ top idomain
<->
forall B, f B ≡ top idomain.
Proof.
unfold indexed_intersection. rewrite top_filtered_intersection; cbn; itauto.
Qed.
Lemma intersection_list_cons X Xs : ⋂ (X :: Xs) = X ∩ ⋂ Xs.
Proof. done. Qed.
Lemma top_intersection_list Xs :
⋂ Xs ≡ top idomain <-> Forall (fun X => X ≡ top idomain) Xs.
Proof.
induction Xs; [by cbn; split; [constructor |] |].
by rewrite intersection_list_cons, top_intersection, Forall_cons, IHXs.
Qed.
Lemma difference_alt A B : A ∖ B ≡ A ∩ complement B.
Proof. set_solver. Qed.
Lemma subseteq_empty_difference_classic (X Y : (Ensemble idomain)) : X ⊆ Y <-> X ∖ Y ≡ ∅.
Proof.
split; [apply subseteq_empty_difference |].
intros Hxy a Ha; destruct (Hxy a) as [Hxy' _].
rewrite elem_of_difference in Hxy'.
destruct (classic (a ∈ Y)); [done | exfalso].
by apply Hxy'.
Qed.
#[export] Instance sym_diff_proper : Proper ((≡) ==> (≡) ==> (≡)) sym_diff.
Proof. by intros A B Hab C D Hcd; unfold sym_diff; rewrite Hab, Hcd. Qed.
Lemma sym_diff_empty_classic A B : sym_diff A B ≡ ∅ <-> A ≡ B.
Proof.
unfold sym_diff; split; [| intros ->].
- intros Hab x; specialize (Hab x).
rewrite elem_of_union, !elem_of_difference in Hab; split.
+ intros Ha.
destruct (classic (x ∈ B)); [done |].
by exfalso; apply Hab; left; split.
+ intros Hb.
destruct (classic (x ∈ A)); [done |].
by exfalso; apply Hab; right; split.
- apply elem_of_equiv_empty; intro x.
rewrite elem_of_union, !elem_of_difference.
by intros [[] | []].
Qed.
Inductive CrispSet (A : Ensemble idomain) : Prop :=
| cs_empty : A ≡ ∅ -> CrispSet A
| cs_top : A ≡ top idomain -> CrispSet A.
Definition ascending_chain (C : nat -> Ensemble idomain) : Prop :=
forall n, C n ⊆ C (S n).
Lemma ascending_chain_skipping (C : nat -> Ensemble idomain) :
ascending_chain C -> forall m n, m <= n -> C m ⊆ C n.
Proof.
intros HC m n; revert m; induction n.
- by intros m Hm; replace m with 0 by lia.
- intros m Hm; destruct (decide (m = S n)); [by subst |].
etransitivity; [| apply HC].
apply IHn; lia.
Qed.
Lemma proper_compose_ascending_chain
(F : Ensemble idomain -> Ensemble idomain) `{!Proper ((⊆) ==> (⊆)) F}
(C : nat -> Ensemble idomain) :
ascending_chain C -> ascending_chain (F ∘ C).
Proof. by intros HC n; apply Proper0, HC. Qed.
Definition descending_chain (C : nat -> Ensemble idomain) : Prop :=
forall n, C (S n) ⊆ C n.
Lemma descending_chain_skipping (C : nat -> Ensemble idomain) :
descending_chain C -> forall m n, m <= n -> C n ⊆ C m.
Proof.
intros HC m n; revert m; induction n.
- by intros m Hm; replace m with 0 by lia.
- intros m Hm; destruct (decide (m = S n)); [by subst |].
etransitivity; [apply HC |].
apply IHn; lia.
Qed.
Lemma proper_compose_descending_chain
(F : Ensemble idomain -> Ensemble idomain) `{!Proper ((⊆) ==> (⊆)) F}
(C : nat -> Ensemble idomain) :
descending_chain C -> descending_chain (F ∘ C).
Proof. by intros HC n; apply Proper0, HC. Qed.
Lemma ascending_chain_descending (C : nat -> Ensemble idomain) :
ascending_chain C -> descending_chain (complement ∘ C).
Proof.
intros Hasc n; cbn; intro a; cbn; rewrite !elem_of_complement.
by unfold ascending_chain in Hasc; set_solver.
Qed.
Lemma descending_chain_ascending (C : nat -> Ensemble idomain) :
descending_chain C -> ascending_chain (complement ∘ C).
Proof.
intros Hasc n; cbn; intro a; cbn; rewrite !elem_of_complement.
by unfold descending_chain in Hasc; set_solver.
Qed.
End sec_ensemble.
Section sec_ensemble_maps.
Definition image `(F : A -> Ensemble B) (X : Ensemble A) : Ensemble B :=
filtered_union (fun x : A => x ∈ X) F.
Lemma image_singleton `(F : A -> Ensemble B) (a : A) :
F a ≡ image F {[ a ]}.
Proof.
intro x; unfold image.
rewrite elem_of_filtered_union.
setoid_rewrite elem_of_singleton.
by set_solver.
Qed.
Lemma elem_of_image `(F : A -> Ensemble B) (X : Ensemble A) (b : B) :
b ∈ image F X <-> exists a, a ∈ X /\ b ∈ F a.
Proof. by apply elem_of_filtered_union. Qed.
Definition fiber `(F : A -> Ensemble B) (y : B) : Ensemble A :=
filtered_union (fun x : A => y ∈ F x) singleton.
Lemma elem_of_fiber `(F : A -> Ensemble B) (b : B) (a : A) :
a ∈ fiber F b <-> b ∈ F a.
Proof.
unfold fiber; rewrite elem_of_filtered_union.
by set_solver.
Qed.
Definition preimage {A B : Type} : (A -> Ensemble B) -> Ensemble B -> Ensemble A :=
image ∘ fiber.
Lemma elem_of_preimage `(F : A -> Ensemble B) (Y : Ensemble B) (a : A) :
a ∈ preimage F Y <-> exists y, y ∈ Y /\ y ∈ F a.
Proof.
unfold preimage; cbn.
rewrite elem_of_image.
by setoid_rewrite elem_of_fiber.
Qed.
End sec_ensemble_maps.
Notation "⋂ l" := (intersection_list l) (at level 20, format "⋂ l") : stdpp_scope.
Section SecKnasterTarski.
Context
{idomain : Type}
(F : Ensemble idomain -> Ensemble idomain)
`{!Proper ((⊆) ==> (⊆)) F}.
Definition pre_fixpoint (B : Ensemble idomain) : Prop := F B ⊆ B.
Definition post_fixpoint (B : Ensemble idomain) : Prop := B ⊆ F B.
Definition fixpoint (B : Ensemble idomain) : Prop := F B ≡ B.
Definition lfp : Ensemble idomain := filtered_intersection pre_fixpoint id.
Lemma elem_of_lfp x : x ∈ lfp <-> forall A, pre_fixpoint A -> x ∈ A.
Proof. by apply elem_of_filtered_intersection. Qed.
Lemma knaster_tarsky_least_pre_fixpoint A :
pre_fixpoint A -> lfp ⊆ A.
Proof.
intros HA a; rewrite elem_of_lfp.
by intro Hall; apply Hall in HA.
Qed.
Lemma knaster_tarsky_lfp_least A :
fixpoint A -> lfp ⊆ A.
Proof.
intro HA; apply set_equiv_subseteq in HA as [HA _].
by apply knaster_tarsky_least_pre_fixpoint.
Qed.
Lemma knaster_tarsky_lfp_fix : fixpoint lfp.
Proof.
apply set_equiv_subseteq.
cut (pre_fixpoint lfp); [intros Hincl; split; [done |] |].
- intro a; rewrite elem_of_lfp.
by intro Hall; apply Proper0, Hall in Hincl.
- intro a; rewrite elem_of_lfp.
intros Ha B HB.
apply HB.
assert (Hincl : lfp ⊆ B)
by (apply knaster_tarsky_least_pre_fixpoint; done).
by apply Proper0 in Hincl; apply Hincl.
Qed.
Lemma knaster_tarsky_lfp_fix_sub A : A ⊆ lfp -> F A ⊆ lfp.
Proof.
intro Hincl.
transitivity (F lfp); [by apply Proper0 |].
by apply set_equiv_subseteq; symmetry; apply knaster_tarsky_lfp_fix.
Qed.
Definition gfp : Ensemble idomain := filtered_union post_fixpoint id.
Lemma elem_of_gfp x : x ∈ gfp <-> exists A, post_fixpoint A /\ x ∈ A.
Proof. by apply elem_of_filtered_union. Qed.
Lemma knaster_tarsky_greatest_post_fixpoint A :
post_fixpoint A -> A ⊆ gfp.
Proof.
by intros HA a Ha; rewrite elem_of_gfp; eexists.
Qed.
Lemma knaster_tarsky_gfp_greatest A :
fixpoint A -> A ⊆ gfp.
Proof.
intro HA; apply set_equiv_subseteq in HA as [_ HA].
by apply knaster_tarsky_greatest_post_fixpoint.
Qed.
Lemma knaster_tarsky_gfp_fix : fixpoint gfp.
Proof.
apply set_equiv_subseteq.
cut (post_fixpoint gfp); [intros Hincl; split; [| done] |].
- intros a Ha; rewrite elem_of_gfp.
by apply Proper0 in Hincl; eexists.
- intro a; rewrite elem_of_gfp.
intros (A & HA & Ha).
assert (Hincl : A ⊆ gfp)
by (apply knaster_tarsky_greatest_post_fixpoint; done).
by apply Proper0 in Hincl; apply Hincl, HA.
Qed.
Lemma knaster_tarsky_gfp_fix_sub A : gfp ⊆ A -> gfp ⊆ F A.
Proof.
intro Hincl.
transitivity (F gfp); [| by apply Proper0].
by apply set_equiv_subseteq; apply knaster_tarsky_gfp_fix.
Qed.
End SecKnasterTarski.
Section sec_fix_points_props.
Context
{idomain : Type}
(F G : Ensemble idomain -> Ensemble idomain)
(Hext : forall A, F A ≡ G A).
Lemma pre_fixpoint_equiv B :
pre_fixpoint F B <-> pre_fixpoint G B.
Proof. by unfold pre_fixpoint; rewrite Hext. Qed.
Lemma post_fixpoint_equiv B :
post_fixpoint F B <-> post_fixpoint G B.
Proof. by unfold post_fixpoint; rewrite Hext. Qed.
Lemma fixpoint_equiv B :
fixpoint F B <-> fixpoint G B.
Proof. by unfold fixpoint; rewrite Hext. Qed.
End sec_fix_points_props.
Class Continuous {idomain : Type} (F : Ensemble idomain -> Ensemble idomain) : Prop :=
{
continuous : forall (C : nat -> Ensemble idomain),
F (indexed_union C) ≡ indexed_union (F ∘ C)
}.
Class OmegaContinuous {idomain : Type} (F : Ensemble idomain -> Ensemble idomain) : Prop :=
{
omega_continuous : forall (C : nat -> Ensemble idomain),
ascending_chain C -> F (indexed_union C) ≡ indexed_union (F ∘ C)
}.
#[export] Instance ContinuousOmega `{Continuous idomain F} : OmegaContinuous F.
Proof. by constructor; intros; apply continuous. Qed.
Class CoContinuous {idomain : Type} (F : Ensemble idomain -> Ensemble idomain) : Prop :=
{
co_continuous : forall (C : nat -> Ensemble idomain),
F (indexed_intersection C) ≡ indexed_intersection (F ∘ C)
}.
Class CoOmegaContinuous {idomain : Type} (F : Ensemble idomain -> Ensemble idomain) : Prop :=
{
co_omega_continuous : forall (C : nat -> Ensemble idomain),
descending_chain C -> F (indexed_intersection C) ≡ indexed_intersection (F ∘ C)
}.
#[export] Instance CoContinuousOmega `{CoContinuous idomain F} : CoOmegaContinuous F.
Proof. by constructor; intros; apply co_continuous. Qed.
Section SecKleeneFixPoint.
Context
{idomain : Type}
(F : Ensemble idomain -> Ensemble idomain)
`{!Proper ((⊆) ==> (⊆)) F}.
#[export] Instance pow_compose_monotone n : Proper ((⊆) ==> (⊆)) (pow_compose F n).
Proof.
induction n; cbn; [by typeclasses eauto |].
by intros ? ? ?; apply Proper0, IHn.
Qed.
Lemma pre_fixpoint_pow_compose A n : pre_fixpoint F A -> pow_compose F n A ⊆ A.
Proof.
intros Hpre; induction n; [done |].
by etransitivity; [apply Proper0 | apply Hpre].
Qed.
Definition klfp : Ensemble idomain := indexed_union (fun n => pow_compose F n ∅).
Lemma elem_of_klfp x : x ∈ klfp <-> exists n, x ∈ pow_compose F n ∅.
Proof. by apply elem_of_indexed_union. Qed.
Lemma member_of_klfp n : pow_compose F n ∅ ⊆ klfp.
Proof. by apply (member_of_indexed_union (fun n => pow_compose F n ∅)). Qed.
Lemma klfp_unfold :
klfp ≡ indexed_union (F ∘ (λ n : nat, pow_compose F n ∅)).
Proof.
intro a; rewrite elem_of_indexed_union, elem_of_klfp; cbn; split.
- by intros [[] Ha]; [by contradict Ha; apply not_elem_of_empty | exists n].
- by intros [n Ha]; exists (S n).
Qed.
Lemma kleene_ascending_chain : ascending_chain (fun n => pow_compose F n ∅).
Proof. by intro n; induction n; [set_solver | apply Proper0]. Qed.
Lemma klfp_post_fixpoint : post_fixpoint F klfp.
Proof.
unfold post_fixpoint.
etransitivity; [by rewrite klfp_unfold |].
intro a; rewrite elem_of_indexed_union.
cbn; intros [n Ha].
cut (F (pow_compose F n ∅) ⊆ F klfp); [by set_solver |].
by apply Proper0, member_of_klfp.
Qed.
Lemma pow_compose_F_n_empty_subseteq_pre_fixpoint
A (HA : pre_fixpoint F A) n :
pow_compose F n ∅ ⊆ A.
Proof.
induction n; cbn; [by set_solver |].
by transitivity (F A); [apply Proper0 |].
Qed.
Lemma kleene_least_pre_fixpoint A : pre_fixpoint F A -> klfp ⊆ A.
Proof.
intros HA a; rewrite elem_of_klfp.
intros [n Ha].
by eapply pow_compose_F_n_empty_subseteq_pre_fixpoint.
Qed.
Lemma klfp_subseteq_lfp : klfp ⊆ lfp F.
Proof.
intros x Hx; apply elem_of_lfp.
by intros A HA; apply kleene_least_pre_fixpoint.
Qed.
Lemma kleene_lfp_least A :
fixpoint F A -> klfp ⊆ A.
Proof.
intro HA; etransitivity.
- by apply klfp_subseteq_lfp.
- by apply knaster_tarsky_lfp_least.
Qed.
Lemma klfp_fixpoint_elim :
pre_fixpoint F klfp -> fixpoint F klfp.
Proof.
by intro; apply set_equiv_subseteq; split; [| apply klfp_post_fixpoint].
Qed.
Lemma Omega_continuous_klfp_fixpoint `{!OmegaContinuous F} : fixpoint F klfp.
Proof.
unfold fixpoint.
etransitivity; [| by rewrite klfp_unfold].
by apply omega_continuous, kleene_ascending_chain.
Qed.
Lemma kleene_knaster_tarsky_lfp_equiv :
fixpoint F klfp -> lfp F ≡ klfp.
Proof.
intro Hfix; apply set_equiv_subseteq; split.
- by apply knaster_tarsky_lfp_least, Hfix.
- by apply klfp_subseteq_lfp.
Qed.
Definition kgfp : Ensemble idomain :=
indexed_intersection (fun n => pow_compose F n (top idomain)).
Lemma elem_of_kgfp x : x ∈ kgfp <-> forall n, x ∈ pow_compose F n (top idomain).
Proof. by apply elem_of_indexed_intersection. Qed.
Lemma member_of_kgfp n : kgfp ⊆ pow_compose F n (top idomain).
Proof. apply (member_of_indexed_intersection (fun n => pow_compose F n (top idomain))). Qed.
Lemma kleene_descending_chain : descending_chain (fun n => pow_compose F n (top idomain)).
Proof. by intro n; induction n; [set_solver | apply Proper0]. Qed.
Lemma kgfp_unfold :
kgfp ≡ indexed_intersection (F ∘ (λ n : nat, pow_compose F n (top idomain))).
Proof.
intro a; rewrite elem_of_indexed_intersection, elem_of_kgfp; cbn; split.
- by intros Hall n; apply (Hall (S n)).
- by intros Hall []; [| apply Hall].
Qed.
Lemma kgfp_pre_fixpoint : pre_fixpoint F kgfp.
Proof.
unfold pre_fixpoint.
etransitivity; [| by rewrite kgfp_unfold].
intro a; rewrite elem_of_indexed_intersection.
cbn; intros Ha n.
cut (F kgfp ⊆ F (pow_compose F n (top idomain))); [by set_solver |].
by apply Proper0, member_of_kgfp.
Qed.
Lemma kgfp_fixpoint_elim :
post_fixpoint F kgfp -> fixpoint F kgfp.
Proof.
by intro; apply set_equiv_subseteq; split; [apply kgfp_pre_fixpoint |].
Qed.
Lemma co_Omega_continuous_kgfp_fixpoint `{!CoOmegaContinuous F} :
fixpoint F kgfp.
Proof.
unfold fixpoint.
etransitivity; [| by rewrite kgfp_unfold].
by apply co_omega_continuous, kleene_descending_chain.
Qed.
Lemma kleene_greatest_post_fixpoint A : post_fixpoint F A -> A ⊆ kgfp.
Proof.
intros HA.
cut (forall n, A ⊆ pow_compose F n (top idomain)).
- by intros Hall a Ha; apply elem_of_kgfp; intro n; apply Hall.
- induction n; [by set_solver | cbn].
transitivity (F A); [done |].
by apply Proper0.
Qed.
Lemma kleene_gfp_greatest A :
fixpoint F A -> A ⊆ kgfp.
Proof.
intro HA; apply set_equiv_subseteq in HA as [_ HA].
by apply kleene_greatest_post_fixpoint.
Qed.
Lemma kleene_knaster_tarsky_gfp_equiv :
fixpoint F kgfp -> gfp F ≡ kgfp.
Proof.
intro Hfix; apply set_equiv_subseteq; split.
- by apply kleene_gfp_greatest, knaster_tarsky_gfp_fix.
- by apply knaster_tarsky_gfp_greatest, Hfix.
Qed.
End SecKleeneFixPoint.
|
-- @@stderr --
dtrace: failed to compile script test/unittest/scripting/err.D_SYNTAX.desc.d: [D_SYNTAX] line 20: syntax error near "$pid"
|
theory VecSum
imports
TwoSum
begin
subsection \<open>Implementation\<close>
fun itVecSum :: "float list \<Rightarrow> float list \<Rightarrow> float list" where
"itVecSum [] hs = rev hs" |
"itVecSum [a] hs = a # rev hs" |
"itVecSum (a1 # a2 # as) hs = (let
(s, e) = twoSum (a2, a1)
in itVecSum (s # as) (e # hs))"
fun vecSum :: "float list \<Rightarrow> float list" where
"vecSum mpf = itVecSum mpf []"
subsection \<open>Properties\<close>
lemma itVecSum_correct1:
--\<open>listsum is not available due to missing monoid properties of fadd\<close>
shows "hd (itVecSum (a # as) bs) = fold op+ as a"
apply (induction as arbitrary: a bs)
apply (simp_all add: twoSum_correct1_eq split_def del: twoSum.simps)
done
lemma vecSum_correct1_eq:
shows "hd (vecSum (a # as)) = fold op + as a"
by (simp add: itVecSum_correct1)
corollary vecSum_correct1:
assumes "Finite (fold op + as a)"
shows "hd (vecSum (a # as)) \<doteq> fold op + as a"
using assms float_eq vecSum_correct1_eq
by presburger
lemma vecSum_correct2:
assumes "list_all Finite mpf"
assumes "list_all Finite (vecSum mpf)"
shows "listsum (map Val (vecSum mpf)) = listsum (map Val mpf)"
sorry
lemma vecSum_regular:
assumes "list_all Finite a"
assumes "list_all Finite (vecSum a)"
assumes "length_ok a"
shows "regular (vecSum a)"
sorry
lemma length_cons: "length (itVecSum (a#as) b) = Suc (length as + length b)"
apply (induction as arbitrary: a b)
apply (simp_all split: prod.splits)
done
lemma length_add: "length a + length b = length (itVecSum a b)"
apply (induction a)
apply (simp_all add: length_cons)
done
end |
Formal statement is: lemma connected_componentI: "connected T \<Longrightarrow> T \<subseteq> S \<Longrightarrow> x \<in> T \<Longrightarrow> y \<in> T \<Longrightarrow> connected_component S x y" Informal statement is: If $T$ is a connected subset of $S$ and $x, y \in T$, then $x$ and $y$ are in the same connected component of $S$. |
import data.hash_map library_dev.data.list.set
namespace state
@[inline] def modify {σ : Type} : (σ → σ) → state σ unit :=
λ f s, ((), f s)
def inc : state ℕ unit := modify (λ n, n + 1)
def dec : state ℕ unit := modify (λ n, n - 1)
end state
namespace list
def dnth {α : Type*} [decidable_eq α] [inhabited α] (xs : list α) (n : ℕ) : α :=
match xs^.nth n with
| (some x) := x
| none := default α
end
def at_nth {α : Type*} (xs : list α) (idx : ℕ) (x : α) : Prop := nth xs idx = some x
def set_nth {α : Type*} : list α → ℕ → α → option (list α)
| (x::xs) 0 a := some (a :: xs)
| (x::xs) (i+1) a := do ys ← set_nth xs i a, return (x :: ys)
| [] _ _ := none
lemma at_nth_of_dnth_lt {α : Type*} [decidable_eq α] [inhabited α] {xs : list α} {idx : ℕ} :
idx < length xs → at_nth xs idx (dnth xs idx) := sorry
lemma at_nth_of_len {α : Type*} {xs ys : list α} {x : α} {k : ℕ} : k = length xs → at_nth (xs ++ x :: ys) k x := sorry
end list
namespace hash_map
def dfind {α : Type*} [decidable_eq α] {β : α → Type*} [∀ a, inhabited (β a)] (m : hash_map α β) (a : α) : β a :=
match m^.find a with
| (some b) := b
| none := default (β a)
end
end hash_map
section seq
variables {α : Type*} (rel : α → α → Prop)
inductive star : α → α → Prop
| rfl : ∀ (x : α), star x x
| rtrans : ∀ (x y z : α), rel x y → star y z → star x y
end seq
namespace star
variables {α : Type*} (rel : α → α → Prop)
lemma trans (x y z : α) : star rel x y → star rel y z → star rel x z := sorry
end star
namespace compiler
open tactic list
structure var : Type := (id : ℕ)
namespace var
instance : decidable_eq var := by mk_dec_eq_instance
end var
@[reducible] def vstate : Type := hash_map var (λ v : var, ℕ)
def empty_vstate : vstate := mk_hash_map (λ v : var, v^.id)
inductive aexp : Type
| aconst : ℕ → aexp
| avar : var → aexp
| aadd : aexp → aexp → aexp
| asub : aexp → aexp → aexp
| amul : aexp → aexp → aexp
inductive bexp : Type
| btrue : bexp
| bfalse : bexp
| bnot : bexp → bexp
| band : bexp → bexp → bexp
| beq : aexp → aexp → bexp
| ble : aexp → aexp → bexp
def aeval (st : vstate) : aexp → ℕ
| (aexp.aconst n) := n
| (aexp.avar v) := st^.dfind v
| (aexp.aadd e₁ e₂) := aeval e₁ + aeval e₂
| (aexp.asub e₁ e₂) := aeval e₁ - aeval e₂
| (aexp.amul e₁ e₂) := aeval e₁ * aeval e₂
def beval (st : vstate) : bexp → bool
| (bexp.btrue) := tt
| (bexp.bfalse) := ff
| (bexp.bnot b) := bnot (beval b)
| (bexp.band b₁ b₂) := beval b₁ && beval b₂
| (bexp.beq e₁ e₂) := aeval st e₁ = aeval st e₂
| (bexp.ble e₁ e₂) := aeval st e₁ ≤ aeval st e₂
inductive com : Type
| cskip : com
| cass : var → aexp → com
| cseq : com → com → com
| cif : bexp → com → com → com
| cwhile : bexp → com → com
open com
inductive ceval : com → vstate → vstate → Prop
| eskip : ∀ st, ceval cskip st st
| eass : ∀ st a n x, aeval st a = n → ceval (cass x a) st (st^.insert x n)
| eseq : ∀ c₁ c₂ st₁ st₂ st₃, ceval c₁ st₁ st₂ → ceval c₂ st₂ st₃ → ceval (cseq c₁ c₂) st₁ st₃
| eift : ∀ st₁ st₂ b c₁ c₂, beval st₁ b = tt → ceval c₁ st₁ st₂ → ceval (cif b c₁ c₂) st₁ st₂
| eiff : ∀ st₁ st₂ b c₁ c₂, beval st₁ b = ff → ceval c₂ st₁ st₂ → ceval (cif b c₁ c₂) st₁ st₂
| ewhilet : ∀ st₁ st₂ st₃ b c, beval st₁ b = tt → ceval c st₁ st₂ → ceval (cwhile b c) st₂ st₃ → ceval (cwhile b c) st₁ st₃
| ewhilef : ∀ st b c, beval st b = ff → ceval (cwhile b c) st st
open ceval
inductive instruction : Type
| iconst : ℕ → instruction
| iget : ℕ → instruction
| iset : ℕ → instruction
| iadd : instruction
| isub : instruction
| imul : instruction
| ibf : ℕ → instruction
| ibb : ℕ → instruction
| ibeq : ℕ → instruction
| ibne : ℕ → instruction
| ible : ℕ → instruction
| ibgt : ℕ → instruction
| ihalt : instruction
open instruction
@[reducible] def code := list instruction.
@[reducible] def stack : Type := list ℕ
@[reducible] def config : Type := ℕ × stack
inductive veval (c : code) : config -> config -> Prop
| vconst : ∀ pc stk n, at_nth c pc (iconst n) → veval (pc, stk) (pc + 1, n :: stk)
| vget : ∀ pc stk n v, at_nth c pc (iget n) → at_nth stk n v → veval (pc, stk) (pc + 1, v :: stk)
| vset : ∀ pc stk n v stk', at_nth c pc (iset n) → set_nth stk n v = some stk' → veval (pc, v :: stk) (pc + 1, stk')
| vadd : ∀ pc stk n n₁ n₂, at_nth c pc iadd → n = n₁ + n₂ → veval (pc, n₂ :: n₁ :: stk) (pc + 1, n :: stk)
| vsub : ∀ pc stk n₁ n₂, at_nth c pc iadd → veval (pc, n₂ :: n₁ :: stk) (pc + 1, (n₁ - n₂) :: stk)
| vmul : ∀ pc stk n₁ n₂, at_nth c pc iadd → veval (pc, n₂ :: n₁ :: stk) (pc + 1, (n₁ * n₂) :: stk)
| vbf : ∀ pc stk ofs pc', at_nth c pc (ibf ofs) → pc' = (pc + ofs) + 1 → veval (pc, stk) (pc', stk)
| vbb : ∀ pc stk ofs pc', at_nth c pc (ibf ofs) → pc' + ofs = pc + 1 → veval (pc, stk) (pc', stk)
| vbeq : ∀ pc stk ofs n₁ n₂ pc', at_nth c pc (ibeq ofs) → pc' = (if n₁ = n₂ then (pc + ofs) + 1 else pc + 1) → veval (pc, n₂ :: n₁ :: stk) (pc', stk)
| vbne : ∀ pc stk ofs n₁ n₂ pc', at_nth c pc (ibne ofs) → pc' = (if n₁ = n₂ then pc + 1 else (pc + ofs) + 1) → veval (pc, n₂ :: n₁ :: stk) (pc', stk)
| vble : ∀ pc stk ofs n₁ n₂ pc', at_nth c pc (ible ofs) → pc' = (if n₁ ≤ n₂ then (pc + ofs) + 1 else pc + 1) → veval (pc, n₂ :: n₁ :: stk) (pc', stk)
| vbgt : ∀ pc stk ofs n₁ n₂ pc', at_nth c pc (ibgt ofs) → pc' = (if n₁ ≤ n₂ then pc + 1 else (pc + ofs) + 1) → veval (pc, n₂ :: n₁ :: stk) (pc', stk)
def vhalts (c : code) (stk_init stk_fin : stack) : Prop :=
∃ pc, at_nth c pc ihalt ∧ star (veval c) (0, stk_init) (pc, stk_fin)
def collect_assigned_vars : com → list var
| (cskip) := []
| (cass v _) := [v]
| (cseq c₁ c₂) := collect_assigned_vars c₁ ∪ collect_assigned_vars c₂
| (cif b c₁ c₂) := collect_assigned_vars c₁ ∪ collect_assigned_vars c₂
| (cwhile b c) := collect_assigned_vars c
@[reducible] def stack_offsets : Type := hash_map var (λ v : var, ℕ)
def compute_stack_offsets_core : list var → stack_offsets → stack_offsets
| [] s := s
| (v :: vs) s := compute_stack_offsets_core vs (s^.insert v (length vs))
def compute_stack_offsets (c : com) : stack_offsets :=
compute_stack_offsets_core (collect_assigned_vars c) (mk_hash_map (λ (v : var), v^.id))
-- TODO(dhs): not sure if this is the best way to do it
def agree (offsets : stack_offsets) (vofs : ℕ) (st : vstate) (stk : stack) : Prop :=
∀ (v : var), st^.dfind v = dnth stk (offsets^.dfind v + vofs)
lemma agree_push {offsets : stack_offsets} {vofs : ℕ} {st : vstate} {stk : stack} {n : ℕ} :
agree offsets vofs st stk → agree offsets (vofs + 1) st (n :: stk) := sorry
lemma agree_insert {offsets : stack_offsets} {vofs : ℕ} {st : vstate} {stk : stack} :
agree offsets vofs st stk →
∀ v n,
agree offsets vofs (hash_map.insert st v n) (update_nth stk (hash_map.dfind offsets v) n) := sorry
inductive codeseq_at : code → ℕ → code → Prop
| intro : ∀ code₁ code₂ code₃ pc, pc = length code₁ → codeseq_at (code₁ ++ code₂ ++ code₃) pc code₂
def compile_aexp_core (offsets : stack_offsets) : aexp → ℕ → code
| (aexp.aconst n) vofs := [iconst n]
| (aexp.avar v) vofs := [iget $ offsets^.dfind v + vofs]
| (aexp.aadd e₁ e₂) vofs := compile_aexp_core e₂ vofs ++ compile_aexp_core e₁ (vofs + 1) ++ [iadd]
| (aexp.asub e₁ e₂) vofs := compile_aexp_core e₂ vofs ++ compile_aexp_core e₁ (vofs + 1) ++ [isub]
| (aexp.amul e₁ e₂) vofs := compile_aexp_core e₂ vofs ++ compile_aexp_core e₁ (vofs + 1) ++ [imul]
def compile_aexp (offsets : stack_offsets) (e : aexp) := compile_aexp_core offsets e 0
-- TODO(dhs): weaken the forall?
def astack_contains_vars (offsets : stack_offsets) : stack → ℕ → aexp → Prop
| stk vofs (aexp.aconst n) := true
| stk vofs (aexp.avar v) := offsets^.dfind v + vofs < length stk
| stk vofs (aexp.aadd e₁ e₂) := astack_contains_vars stk vofs e₂ ∧ ∀ x, astack_contains_vars (x :: stk) (vofs + 1) e₁
| stk vofs (aexp.asub e₁ e₂) := astack_contains_vars stk vofs e₂ ∧ ∀ x, astack_contains_vars (x :: stk) (vofs + 1) e₁
| stk vofs (aexp.amul e₁ e₂) := astack_contains_vars stk vofs e₂ ∧ ∀ x, astack_contains_vars (x :: stk) (vofs + 1) e₁
lemma compile_aexp_core_correct :
∀ code st e pc stk offsets vofs,
codeseq_at code pc (compile_aexp_core offsets e vofs)
→ agree offsets vofs st stk
→ astack_contains_vars offsets stk vofs e
→ star (veval code) (pc, stk) (pc + length (compile_aexp_core offsets e vofs), aeval st e :: stk)
| .(_) st (aexp.aconst n) .(pc) stk offsets vofs (codeseq_at.intro code₁ ._ code₃ pc H_pc) H_agree H_astack :=
begin
simp [compile_aexp_core, length, aeval],
apply star.rtrans,
apply veval.vconst,
apply at_nth_of_len H_pc,
apply star.rfl
end
| .(_) st (aexp.avar v) .(pc) stk offsets vofs (codeseq_at.intro code₁ ._ code₃ pc H_pc) H_agree H_astack :=
begin
simp [compile_aexp_core, length, aeval],
apply star.rtrans,
apply veval.vget,
apply at_nth_of_len H_pc,
simp [agree] at H_agree,
simp [astack_contains_vars] at H_astack,
rw H_agree,
apply at_nth_of_dnth_lt H_astack,
apply star.rfl
end
| .(_) st (aexp.aadd e₁ e₂) .(pc) stk offsets vofs (codeseq_at.intro code₁ ._ code₃ pc H_pc) H_agree H_astack :=
begin
simp [compile_aexp_core, length, aeval],
apply star.trans,
-- Compile e₂
apply compile_aexp_core_correct _ st e₂ _ _ offsets vofs _ H_agree (and.left H_astack),
rw ← append_assoc,
apply codeseq_at.intro _ _ _ _ H_pc,
-- Compile e₁
apply star.trans,
apply compile_aexp_core_correct _ st e₁ _ _ offsets (vofs+1) _ (agree_push H_agree) (and.right H_astack _),
have H_assoc :
(code₁ ++ (compile_aexp_core offsets e₂ vofs ++ (compile_aexp_core offsets e₁ (vofs + 1) ++ iadd :: code₃)))
=
(code₁ ++ compile_aexp_core offsets e₂ vofs) ++ (compile_aexp_core offsets e₁ (vofs + 1)) ++ iadd :: code₃ := sorry,
rw H_assoc, clear H_assoc,
apply codeseq_at.intro _ _ _ _,
simp [H_pc, length_append],
-- Add instruction
apply star.rtrans,
have H_assoc :
code₁ ++ (compile_aexp_core offsets e₂ vofs ++ (compile_aexp_core offsets e₁ (vofs + 1) ++ iadd :: code₃))
=
(code₁ ++ compile_aexp_core offsets e₂ vofs ++ compile_aexp_core offsets e₁ (vofs + 1)) ++ [iadd] ++ code₃ := sorry,
rw H_assoc, clear H_assoc,
have H_one_at_end :
pc + (1 + (length (compile_aexp_core offsets e₂ vofs) + length (compile_aexp_core offsets e₁ (vofs + 1))))
=
(pc + length (compile_aexp_core offsets e₂ vofs) + length (compile_aexp_core offsets e₁ (vofs + 1))) + 1 := sorry,
rw H_one_at_end, clear H_one_at_end,
apply veval.vadd,
have H_cons :
code₁ ++ compile_aexp_core offsets e₂ vofs ++ compile_aexp_core offsets e₁ (vofs + 1) ++ [iadd] ++ code₃
=
(code₁ ++ compile_aexp_core offsets e₂ vofs ++ compile_aexp_core offsets e₁ (vofs + 1)) ++ (iadd :: code₃) := sorry,
rw H_cons, clear H_cons,
apply at_nth_of_len,
simp [H_pc, length_append],
simp,
apply star.rfl,
end
def compile_bexp (offsets : stack_offsets) : bexp → bool → ℕ → code
| (bexp.btrue) cond ofs := if cond then [ibf ofs] else []
| (bexp.bfalse) cond ofs := if cond then [] else [ibf ofs]
| (bexp.bnot b) cond ofs := compile_bexp b (bnot cond) ofs
| (bexp.band b₁ b₂) cond ofs := let code₂ := compile_bexp b₂ cond ofs,
code₁ := compile_bexp b₁ ff (if cond then length code₂ else ofs + length code₂)
in code₁ ++ code₂
| (bexp.beq e₁ e₂) cond ofs := compile_aexp_core offsets e₂ 0 ++ compile_aexp_core offsets e₁ 1 ++ (if cond then [ibeq ofs] else [ibne ofs])
| (bexp.ble e₁ e₂) cond ofs := compile_aexp_core offsets e₂ 0 ++ compile_aexp_core offsets e₁ 1 ++ (if cond then [ible ofs] else [ibgt ofs])
-- TODO(dhs): weaken the forall?
-- TODO(dhs): is this even right? We'll see soon.
def bstack_contains_vars (offsets : stack_offsets) : stack → bexp → Prop
| stk (bexp.btrue) := true
| stk (bexp.bfalse) := true
| stk (bexp.bnot b) := bstack_contains_vars stk b
| stk (bexp.band b₁ b₂) := bstack_contains_vars stk b₁ ∧ bstack_contains_vars stk b₂
| stk (bexp.beq e₁ e₂) := astack_contains_vars offsets stk 0 e₂ ∧ ∀ x, astack_contains_vars offsets (x::stk) 1 e₁
| stk (bexp.ble e₁ e₂) := astack_contains_vars offsets stk 0 e₂ ∧ ∀ x, astack_contains_vars offsets (x::stk) 1 e₁
--set_option pp.all true
--set_option trace.type_context.is_def_eq true
--set_option trace.type_context.is_def_eq_detail true
lemma compile_bexp_correct :
∀ code st b cond ofs pc stk offsets,
codeseq_at code pc (compile_bexp offsets b cond ofs)
→ agree offsets 0 st stk
→ bstack_contains_vars offsets stk b
→ star (veval code) (pc, stk)
(pc + (length (compile_bexp offsets b cond ofs) + ite (beval st b = cond) ofs 0), stk)
/-
| .(_) st (bexp.btrue) cond ofs .(pc) stk offsets (codeseq_at.intro code₁ ._ code₃ pc H_pc) H_agree H_bstack :=
begin
simp [compile_bexp, compile_aexp_core, length, aeval, beval],
cases cond,
{ simp, apply star.rfl },
simp,
apply star.rtrans,
apply veval.vbf _ _ ofs,
apply at_nth_of_len H_pc,
simp,
apply star.rfl
end
| .(_) st (bexp.bfalse) cond ofs .(pc) stk offsets (codeseq_at.intro code₁ ._ code₃ pc H_pc) H_agree H_bstack :=
begin
simp [compile_bexp, compile_aexp_core, length, aeval, beval],
cases cond,
{ simp, apply star.rtrans, apply veval.vbf _ _ ofs, apply at_nth_of_len H_pc, simp, apply star.rfl },
{ simp, apply star.rfl },
end
| .(_) st (bexp.bnot b) cond ofs .(pc) stk offsets (codeseq_at.intro code₁ ._ code₃ pc H_pc) H_agree H_bstack :=
begin
simp [compile_bexp, compile_aexp_core, length, aeval, beval],
-- TODO(dhs): come on, Lean
have H_bnot : ∀ beq, (@ite (bnot (beval st b) = cond) beq _ ofs 0) = (ite (beval st b = bnot cond) ofs 0) := sorry,
rw H_bnot, clear H_bnot,
apply compile_bexp_correct (code₁ ++ (compile_bexp offsets b (bnot cond) ofs ++ code₃)) st b (bnot cond) ofs pc stk offsets _ H_agree H_bstack,
rw ← append_assoc,
apply codeseq_at.intro _ _ _ _ H_pc,
end
-/
| .(_) st (bexp.band b₁ b₂) cond ofs .(pc) stk offsets (codeseq_at.intro code₁ ._ code₃ pc H_pc) H_agree H_bstack :=
begin
simp [compile_bexp, compile_aexp_core, length, aeval, beval],
-- b₁
apply star.trans,
have H_assoc :
(code₁ ++
(compile_bexp offsets b₁ ff
(ite ↑cond (length (compile_bexp offsets b₂ cond ofs))
(ofs + length (compile_bexp offsets b₂ cond ofs))) ++
(compile_bexp offsets b₂ cond ofs ++ code₃)))
=
(code₁ ++
(compile_bexp offsets b₁ ff
(ite ↑cond (length (compile_bexp offsets b₂ cond ofs))
(ofs + length (compile_bexp offsets b₂ cond ofs)))) ++
(compile_bexp offsets b₂ cond ofs ++ code₃)) := sorry,
rw H_assoc, clear H_assoc,
apply compile_bexp_correct _ st b₁ ff _ pc stk offsets _ H_agree (and.left H_bstack),
tactic.rotate 1,
apply codeseq_at.intro _ _ _ _ H_pc,
--
cases cond,
simp,
have H_em : (beval st b₁ = ff ∨ beval st b₁ = tt) := sorry,
cases H_em with H_ff H_tt,
simp [H_ff],
apply star.rfl,
simp [H_tt],
have H_assoc :
(code₁ ++
(compile_bexp offsets b₁ ff (ofs + length (compile_bexp offsets b₂ ff ofs)) ++
(compile_bexp offsets b₂ ff ofs ++ code₃)))
=
(code₁ ++ compile_bexp offsets b₁ ff (ofs + length (compile_bexp offsets b₂ ff ofs)) ++ (compile_bexp offsets b₂ ff ofs ++ code₃)) := sorry,
rw H_assoc, clear H_assoc,
-- TODO(dhs): why won't it unify?
have H_come_on_lean : ∀ bdec, @ite (beval st b₂ = ff) bdec _ ofs 0 = ite (beval st b₂ = ff) ofs 0 := sorry,
have H_rec₂ := compile_bexp_correct (code₁ ++ compile_bexp offsets b₁ ff (ofs + length (compile_bexp offsets b₂ ff ofs)) ++
(compile_bexp offsets b₂ ff ofs ++ code₃)) st b₂ ff ofs (pc + length (compile_bexp offsets b₁ ff (ofs + length (compile_bexp offsets b₂ ff ofs)))) stk offsets,
simp [H_come_on_lean] at H_rec₂,
simp [H_come_on_lean],
apply H_rec₂,
clear H_rec₂,
have H_assoc :
(code₁ ++
(compile_bexp offsets b₁ ff (ofs + length (compile_bexp offsets b₂ ff ofs)) ++
(compile_bexp offsets b₂ ff ofs ++ code₃)))
=
(code₁ ++ compile_bexp offsets b₁ ff (ofs + length (compile_bexp offsets b₂ ff ofs))) ++
compile_bexp offsets b₂ ff ofs ++ code₃ := sorry,
rw H_assoc, clear H_assoc,
apply codeseq_at.intro,
simp [H_pc],
exact H_agree,
exact and.right H_bstack,
-- cond = tt
exact sorry
end
-- Example program
---------------------------
-- (cass `x 1)
-- (cass `y (+ x x))
-- (cass `z (+ x (+ y x))
-- Want
--------------------------
-- Initial stack: [x:=0, y:=0, z:=0]
-- cass `x 1 ==> push 1, iset 1 ==> [x:=1, y:=0, z:=0]
-- cass `y (+ x x) ==> iget 0, iget 1, iadd, iset 2 ==> [x:=2, y:=4, z:=0]
-- cass `z (+ x (+ y x)) ==> iget 0, iget 2, iget 2, iadd, iadd, iset 3
definition compile_com (offsets : stack_offsets) : com → code
| cskip := []
| (cass v e) := compile_aexp offsets e ++ [iset $ offsets^.dfind v]
| (cseq c₁ c₂) := compile_com c₁ ++ compile_com c₂
| (cif b c₁ c₂) := let code₁ := compile_com c₁,
code₂ := compile_com c₂
in compile_bexp offsets b false (length code₁ + 1) ++ code₁ ++ [ibf (length code₂)] ++ code₂
| (cwhile b c) := let code_body := compile_com c,
code_test := compile_bexp offsets b ff (length code_body + 1)
in code_test ++ code_body ++ [ibb (length code_test + length code_body + 1)]
-- TODO(dhs): is this _strong_ enough, with `offsets` an argument?
-- TODO(dhs): is this _weak_ enough, to prove?
theorem compile_correct_terminating_alt :
∀ code st c st',
ceval c st st' →
∀ offsets stk pc, codeseq_at code pc (compile_com offsets c) →
agree offsets 0 st stk →
∃ stk', star (veval code) (pc, stk) (pc + length (compile_com offsets c), stk')
∧ agree offsets 0 st' stk'
| code ._ ._ ._ (eskip st) :=
begin
simp [compile_com, length],
intros offsets stk pc H_codeseq H_agree,
apply exists.intro stk,
split,
exact H_agree,
apply star.rfl
end
| code ._ ._ ._ (eass st a n x H_aeval) :=
begin
simp [compile_com, length],
intros offsets stk pc H_codeseq H_agree,
apply exists.intro (update_nth stk (offsets^.dfind x) n),
split,
apply agree_insert H_agree,
apply compile_aexp_core_correct,
end
| code ._ ._ ._ (eseq c₁ c₂ st₁ st₂ st₃ H_c₁ H_c₂) :=
begin
end
| code ._ ._ ._ (eift st₁ st₂ b c₁ c₂ H_beval_t H_ceval₁) :=
begin
end
| code ._ ._ ._ (eiff st₁ st₂ b c₁ c₂ H_beval_f H_ceval₂) :=
begin
end
| code ._ ._ ._ (ewhilet st₁ st₂ st₃ b c H_beval_t H_ceval_step H_ceval_loop) :=
begin
end
| code ._ ._ ._ (ewhilef st b c H_beval_f) :=
begin
end
end compiler
|
/*
* external_rotation_estimator.cc
*
* Created on: Jul 8, 2016
* Author: LeonMing
*/
#include "theia/sfm/global_pose_estimation/external_rotation_estimator.h"
#include <ceres/rotation.h>
#include <ceres/ceres.h>
#include <Eigen/Core>
#include <Eigen/SparseCore>
#include <Eigen/SparseQR>
#include <unordered_map>
#include <vector>
#include <string>
#include <iostream>
#include <fstream>
#include "theia/sfm/pose/util.h"
#include "theia/sfm/twoview_info.h"
#include "theia/sfm/types.h"
#include "theia/util/hash.h"
#include "theia/util/map_util.h"
namespace theia {
using Eigen::Matrix;
using Eigen::Matrix3d;
using Eigen::MatrixXd;
bool ExternalRotationEstimator::EstimateRotations(
const std::unordered_map<ViewIdPair, TwoViewInfo>& view_pairs,
std::unordered_map<ViewId, Eigen::Vector3d>* orientations) {
// Read in the global rotations file
std::ifstream ifs(global_rotations_file_.c_str(), std::ios::in);
if (!ifs.is_open()) {
LOG(ERROR) << "Cannot read the global rotations file from " << global_rotations_file_;
return false;
}
// Loop through the file. For every ten numbers, the first number is a view_id
// and the next nine numbers are a rotation matrix
while (!ifs.eof()) {
ViewId view_id;
ifs >> view_id;
// Add rotation matrix values to a Matrix3d
Eigen::Matrix3d rotation;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
ifs >> rotation(j, i);
}
}
// Declare an angle-axis Vector3d
Eigen::Vector3d angleaxis;
// Convert rotation matrix values to angle-axis vector
ceres::RotationMatrixToAngleAxis(rotation.data(), angleaxis.data());
// Place corresponding view ids and angle-axis vectors in orientations
orientations->emplace(view_id, angleaxis);
}
return true;
}
} // namespace theia
|
/**
* Fast map matching.
*
* Configuration of reading gps data
*
* @author Can Yang
*/
#ifndef FMM_SRC_CONFIG_GPS_CONFIG_HPP_
#define FMM_SRC_CONFIG_GPS_CONFIG_HPP_
#include <string>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include "cxxopts/cxxopts.hpp"
namespace FMM {
/**
* Classes related with configuration
*/
namespace CONFIG {
/**
* GPS configuration class for reading data from a file.
*/
struct GPSConfig{
std::string file; /**< filename */
std::string id; /**< id field/column name */
std::string geom; /**< geometry field/column name */
std::string x; /**< x field/column name */
std::string y; /**< y field/column name */
std::string timestamp; /**< timestamp field/column name */
bool gps_point = false; /**< gps point stored or not */
/**
* Validate the GPS configuration for file existence, parameter validation
* @return true if validate success, otherwise false returned
*/
bool validate() const;
/**
* Print members of the GPS configuration.
*/
void print() const;
/**
* Find the GPS format.
*
* @return 0 for GDAL trajectory file, 1 for CSV trajectory file
* and 2 for CSV point file, otherwise -1 is returned for unknown
* format.
*/
int get_gps_format() const;
/**
* Load GPSConfig from XML data.
*
* @param xml_data
* @return
*/
static GPSConfig load_from_xml(const boost::property_tree::ptree &xml_data);
/**
* Load GPSConfig from argument parsed data.
*
* @param arg_data
* @return
*/
static GPSConfig load_from_arg(const cxxopts::ParseResult &arg_data);
};
} // CONFIG
} // FMM
#endif //FMM_SRC_CONFIG_GPS_CONFIG_HPP_
|
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
n : ℕ
⊢ (iteratedFDeriv 𝕜 n fun x => 0) = 0
[PROOFSTEP]
induction' n with n IH
[GOAL]
case zero
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
⊢ (iteratedFDeriv 𝕜 Nat.zero fun x => 0) = 0
[PROOFSTEP]
ext m
[GOAL]
case zero.h.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
m : E
x✝ : Fin Nat.zero → E
⊢ ↑(iteratedFDeriv 𝕜 Nat.zero (fun x => 0) m) x✝ = ↑(OfNat.ofNat 0 m) x✝
[PROOFSTEP]
simp
[GOAL]
case succ
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
n : ℕ
IH : (iteratedFDeriv 𝕜 n fun x => 0) = 0
⊢ (iteratedFDeriv 𝕜 (Nat.succ n) fun x => 0) = 0
[PROOFSTEP]
ext x m
[GOAL]
case succ.h.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
n : ℕ
IH : (iteratedFDeriv 𝕜 n fun x => 0) = 0
x : E
m : Fin (Nat.succ n) → E
⊢ ↑(iteratedFDeriv 𝕜 (Nat.succ n) (fun x => 0) x) m = ↑(OfNat.ofNat 0 x) m
[PROOFSTEP]
rw [iteratedFDeriv_succ_apply_left, IH]
[GOAL]
case succ.h.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
n : ℕ
IH : (iteratedFDeriv 𝕜 n fun x => 0) = 0
x : E
m : Fin (Nat.succ n) → E
⊢ ↑(↑(fderiv 𝕜 0 x) (m 0)) (tail m) = ↑(OfNat.ofNat 0 x) m
[PROOFSTEP]
change (fderiv 𝕜 (fun _ : E => (0 : E[×n]→L[𝕜] F)) x : E → E[×n]→L[𝕜] F) (m 0) (tail m) = _
[GOAL]
case succ.h.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
n : ℕ
IH : (iteratedFDeriv 𝕜 n fun x => 0) = 0
x : E
m : Fin (Nat.succ n) → E
⊢ ↑(↑(fderiv 𝕜 (fun x => 0) x) (m 0)) (tail m) = ↑(OfNat.ofNat 0 x) m
[PROOFSTEP]
rw [fderiv_const]
[GOAL]
case succ.h.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
n : ℕ
IH : (iteratedFDeriv 𝕜 n fun x => 0) = 0
x : E
m : Fin (Nat.succ n) → E
⊢ ↑(↑(OfNat.ofNat 0 x) (m 0)) (tail m) = ↑(OfNat.ofNat 0 x) m
[PROOFSTEP]
rfl
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
m : ℕ
x✝ : ↑m ≤ n
⊢ Differentiable 𝕜 (iteratedFDeriv 𝕜 m fun x => 0)
[PROOFSTEP]
rw [iteratedFDeriv_zero_fun]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
m : ℕ
x✝ : ↑m ≤ n
⊢ Differentiable 𝕜 0
[PROOFSTEP]
exact differentiable_const (0 : E[×m]→L[𝕜] F)
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
c : F
⊢ ContDiff 𝕜 n fun x => c
[PROOFSTEP]
suffices h : ContDiff 𝕜 ∞ fun _ : E => c
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
c : F
h : ContDiff 𝕜 ⊤ fun x => c
⊢ ContDiff 𝕜 n fun x => c
[PROOFSTEP]
exact h.of_le le_top
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
c : F
⊢ ContDiff 𝕜 ⊤ fun x => c
[PROOFSTEP]
rw [contDiff_top_iff_fderiv]
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
c : F
⊢ (Differentiable 𝕜 fun x => c) ∧ ContDiff 𝕜 ⊤ fun y => fderiv 𝕜 (fun x => c) y
[PROOFSTEP]
refine' ⟨differentiable_const c, _⟩
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
c : F
⊢ ContDiff 𝕜 ⊤ fun y => fderiv 𝕜 (fun x => c) y
[PROOFSTEP]
rw [fderiv_const]
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
c : F
⊢ ContDiff 𝕜 ⊤ fun y => OfNat.ofNat 0 y
[PROOFSTEP]
exact contDiff_zero_fun
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : Subsingleton F
⊢ ContDiff 𝕜 n f
[PROOFSTEP]
rw [Subsingleton.elim f fun _ => 0]
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : Subsingleton F
⊢ ContDiff 𝕜 n fun x => 0
[PROOFSTEP]
exact contDiff_const
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : Subsingleton F
⊢ ContDiffAt 𝕜 n f x
[PROOFSTEP]
rw [Subsingleton.elim f fun _ => 0]
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : Subsingleton F
⊢ ContDiffAt 𝕜 n (fun x => 0) x
[PROOFSTEP]
exact contDiffAt_const
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : Subsingleton F
⊢ ContDiffWithinAt 𝕜 n f s x
[PROOFSTEP]
rw [Subsingleton.elim f fun _ => 0]
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : Subsingleton F
⊢ ContDiffWithinAt 𝕜 n (fun x => 0) s x
[PROOFSTEP]
exact contDiffWithinAt_const
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : Subsingleton F
⊢ ContDiffOn 𝕜 n f s
[PROOFSTEP]
rw [Subsingleton.elim f fun _ => 0]
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : Subsingleton F
⊢ ContDiffOn 𝕜 n (fun x => 0) s
[PROOFSTEP]
exact contDiffOn_const
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
n : ℕ
c : F
⊢ (iteratedFDeriv 𝕜 (n + 1) fun x => c) = 0
[PROOFSTEP]
ext x
[GOAL]
case h.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
n : ℕ
c : F
x : E
x✝ : Fin (n + 1) → E
⊢ ↑(iteratedFDeriv 𝕜 (n + 1) (fun x => c) x) x✝ = ↑(OfNat.ofNat 0 x) x✝
[PROOFSTEP]
simp only [iteratedFDeriv_succ_eq_comp_right, fderiv_const, Pi.zero_apply, iteratedFDeriv_zero_fun, comp_apply,
LinearIsometryEquiv.map_zero]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
n : ℕ
hn : n ≠ 0
c : F
⊢ (iteratedFDeriv 𝕜 n fun x => c) = 0
[PROOFSTEP]
cases' Nat.exists_eq_succ_of_ne_zero hn with k hk
[GOAL]
case intro
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
n : ℕ
hn : n ≠ 0
c : F
k : ℕ
hk : n = Nat.succ k
⊢ (iteratedFDeriv 𝕜 n fun x => c) = 0
[PROOFSTEP]
rw [hk, iteratedFDeriv_succ_const]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : IsBoundedLinearMap 𝕜 f
⊢ ContDiff 𝕜 n f
[PROOFSTEP]
suffices h : ContDiff 𝕜 ∞ f
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : IsBoundedLinearMap 𝕜 f
h : ContDiff 𝕜 ⊤ f
⊢ ContDiff 𝕜 n f
[PROOFSTEP]
exact h.of_le le_top
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : IsBoundedLinearMap 𝕜 f
⊢ ContDiff 𝕜 ⊤ f
[PROOFSTEP]
rw [contDiff_top_iff_fderiv]
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : IsBoundedLinearMap 𝕜 f
⊢ Differentiable 𝕜 f ∧ ContDiff 𝕜 ⊤ fun y => _root_.fderiv 𝕜 f y
[PROOFSTEP]
refine' ⟨hf.differentiable, _⟩
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : IsBoundedLinearMap 𝕜 f
⊢ ContDiff 𝕜 ⊤ fun y => _root_.fderiv 𝕜 f y
[PROOFSTEP]
simp_rw [hf.fderiv]
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : IsBoundedLinearMap 𝕜 f
⊢ ContDiff 𝕜 ⊤ fun y => toContinuousLinearMap hf
[PROOFSTEP]
exact contDiff_const
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hb : IsBoundedBilinearMap 𝕜 b
⊢ ContDiff 𝕜 n b
[PROOFSTEP]
suffices h : ContDiff 𝕜 ∞ b
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hb : IsBoundedBilinearMap 𝕜 b
h : ContDiff 𝕜 ⊤ b
⊢ ContDiff 𝕜 n b
[PROOFSTEP]
exact h.of_le le_top
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hb : IsBoundedBilinearMap 𝕜 b
⊢ ContDiff 𝕜 ⊤ b
[PROOFSTEP]
rw [contDiff_top_iff_fderiv]
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hb : IsBoundedBilinearMap 𝕜 b
⊢ Differentiable 𝕜 b ∧ ContDiff 𝕜 ⊤ fun y => fderiv 𝕜 b y
[PROOFSTEP]
refine' ⟨hb.differentiable, _⟩
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hb : IsBoundedBilinearMap 𝕜 b
⊢ ContDiff 𝕜 ⊤ fun y => fderiv 𝕜 b y
[PROOFSTEP]
simp only [hb.fderiv]
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hb : IsBoundedBilinearMap 𝕜 b
⊢ ContDiff 𝕜 ⊤ fun y => deriv hb y
[PROOFSTEP]
exact hb.isBoundedLinearMap_deriv.contDiff
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F →L[𝕜] G
hf : ContDiffWithinAt 𝕜 n f s x
m : ℕ
hm : ↑m ≤ n
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (↑g ∘ f) p u
[PROOFSTEP]
rcases hf m hm with ⟨u, hu, p, hp⟩
[GOAL]
case intro.intro.intro
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F →L[𝕜] G
hf : ContDiffWithinAt 𝕜 n f s x
m : ℕ
hm : ↑m ≤ n
u : Set E
hu : u ∈ 𝓝[insert x s] x
p : E → FormalMultilinearSeries 𝕜 E F
hp : HasFTaylorSeriesUpToOn (↑m) f p u
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (↑g ∘ f) p u
[PROOFSTEP]
exact ⟨u, hu, _, hp.continuousLinearMap_comp g⟩
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F
g : F →L[𝕜] G
hf : ContDiff 𝕜 n f
x : E
i : ℕ
hi : ↑i ≤ n
⊢ iteratedFDeriv 𝕜 i (↑g ∘ f) x = compContinuousMultilinearMap g (iteratedFDeriv 𝕜 i f x)
[PROOFSTEP]
simp only [← iteratedFDerivWithin_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F
g : F →L[𝕜] G
hf : ContDiff 𝕜 n f
x : E
i : ℕ
hi : ↑i ≤ n
⊢ iteratedFDerivWithin 𝕜 i (↑g ∘ f) univ x = compContinuousMultilinearMap g (iteratedFDerivWithin 𝕜 i f univ x)
[PROOFSTEP]
exact g.iteratedFDerivWithin_comp_left hf.contDiffOn uniqueDiffOn_univ (mem_univ x) hi
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F ≃L[𝕜] G
f : E → F
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
i : ℕ
⊢ iteratedFDerivWithin 𝕜 i (↑g ∘ f) s x =
ContinuousLinearMap.compContinuousMultilinearMap (↑g) (iteratedFDerivWithin 𝕜 i f s x)
[PROOFSTEP]
induction' i with i IH generalizing x
[GOAL]
case zero
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F ≃L[𝕜] G
f : E → F
hs : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
x : E
hx : x ∈ s
⊢ iteratedFDerivWithin 𝕜 Nat.zero (↑g ∘ f) s x =
ContinuousLinearMap.compContinuousMultilinearMap (↑g) (iteratedFDerivWithin 𝕜 Nat.zero f s x)
[PROOFSTEP]
ext1 m
[GOAL]
case zero.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F ≃L[𝕜] G
f : E → F
hs : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
x : E
hx : x ∈ s
m : Fin Nat.zero → E
⊢ ↑(iteratedFDerivWithin 𝕜 Nat.zero (↑g ∘ f) s x) m =
↑(ContinuousLinearMap.compContinuousMultilinearMap (↑g) (iteratedFDerivWithin 𝕜 Nat.zero f s x)) m
[PROOFSTEP]
simp only [Nat.zero_eq, iteratedFDerivWithin_zero_apply, comp_apply,
ContinuousLinearMap.compContinuousMultilinearMap_coe, coe_coe]
[GOAL]
case succ
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F ≃L[𝕜] G
f : E → F
hs : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
i : ℕ
IH :
∀ {x : E},
x ∈ s →
iteratedFDerivWithin 𝕜 i (↑g ∘ f) s x =
ContinuousLinearMap.compContinuousMultilinearMap (↑g) (iteratedFDerivWithin 𝕜 i f s x)
x : E
hx : x ∈ s
⊢ iteratedFDerivWithin 𝕜 (Nat.succ i) (↑g ∘ f) s x =
ContinuousLinearMap.compContinuousMultilinearMap (↑g) (iteratedFDerivWithin 𝕜 (Nat.succ i) f s x)
[PROOFSTEP]
ext1 m
[GOAL]
case succ.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F ≃L[𝕜] G
f : E → F
hs : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
i : ℕ
IH :
∀ {x : E},
x ∈ s →
iteratedFDerivWithin 𝕜 i (↑g ∘ f) s x =
ContinuousLinearMap.compContinuousMultilinearMap (↑g) (iteratedFDerivWithin 𝕜 i f s x)
x : E
hx : x ∈ s
m : Fin (Nat.succ i) → E
⊢ ↑(iteratedFDerivWithin 𝕜 (Nat.succ i) (↑g ∘ f) s x) m =
↑(ContinuousLinearMap.compContinuousMultilinearMap (↑g) (iteratedFDerivWithin 𝕜 (Nat.succ i) f s x)) m
[PROOFSTEP]
rw [iteratedFDerivWithin_succ_apply_left]
[GOAL]
case succ.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F ≃L[𝕜] G
f : E → F
hs : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
i : ℕ
IH :
∀ {x : E},
x ∈ s →
iteratedFDerivWithin 𝕜 i (↑g ∘ f) s x =
ContinuousLinearMap.compContinuousMultilinearMap (↑g) (iteratedFDerivWithin 𝕜 i f s x)
x : E
hx : x ∈ s
m : Fin (Nat.succ i) → E
⊢ ↑(↑(fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i (↑g ∘ f) s) s x) (m 0)) (tail m) =
↑(ContinuousLinearMap.compContinuousMultilinearMap (↑g) (iteratedFDerivWithin 𝕜 (Nat.succ i) f s x)) m
[PROOFSTEP]
have Z :
fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i (g ∘ f) s) s x =
fderivWithin 𝕜 (g.compContinuousMultilinearMapL (fun _ : Fin i => E) ∘ iteratedFDerivWithin 𝕜 i f s) s x :=
fderivWithin_congr' (@IH) hx
[GOAL]
case succ.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F ≃L[𝕜] G
f : E → F
hs : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
i : ℕ
IH :
∀ {x : E},
x ∈ s →
iteratedFDerivWithin 𝕜 i (↑g ∘ f) s x =
ContinuousLinearMap.compContinuousMultilinearMap (↑g) (iteratedFDerivWithin 𝕜 i f s x)
x : E
hx : x ∈ s
m : Fin (Nat.succ i) → E
Z :
fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i (↑g ∘ f) s) s x =
fderivWithin 𝕜 (↑(compContinuousMultilinearMapL (fun x => E) g) ∘ iteratedFDerivWithin 𝕜 i f s) s x
⊢ ↑(↑(fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i (↑g ∘ f) s) s x) (m 0)) (tail m) =
↑(ContinuousLinearMap.compContinuousMultilinearMap (↑g) (iteratedFDerivWithin 𝕜 (Nat.succ i) f s x)) m
[PROOFSTEP]
simp_rw [Z]
[GOAL]
case succ.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F ≃L[𝕜] G
f : E → F
hs : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
i : ℕ
IH :
∀ {x : E},
x ∈ s →
iteratedFDerivWithin 𝕜 i (↑g ∘ f) s x =
ContinuousLinearMap.compContinuousMultilinearMap (↑g) (iteratedFDerivWithin 𝕜 i f s x)
x : E
hx : x ∈ s
m : Fin (Nat.succ i) → E
Z :
fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i (↑g ∘ f) s) s x =
fderivWithin 𝕜 (↑(compContinuousMultilinearMapL (fun x => E) g) ∘ iteratedFDerivWithin 𝕜 i f s) s x
⊢ ↑(↑(fderivWithin 𝕜 (↑(compContinuousMultilinearMapL (fun x => E) g) ∘ iteratedFDerivWithin 𝕜 i f s) s x) (m 0))
(tail m) =
↑(ContinuousLinearMap.compContinuousMultilinearMap (↑g) (iteratedFDerivWithin 𝕜 (Nat.succ i) f s x)) m
[PROOFSTEP]
rw [(g.compContinuousMultilinearMapL fun _ : Fin i => E).comp_fderivWithin (hs x hx)]
[GOAL]
case succ.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F ≃L[𝕜] G
f : E → F
hs : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
i : ℕ
IH :
∀ {x : E},
x ∈ s →
iteratedFDerivWithin 𝕜 i (↑g ∘ f) s x =
ContinuousLinearMap.compContinuousMultilinearMap (↑g) (iteratedFDerivWithin 𝕜 i f s x)
x : E
hx : x ∈ s
m : Fin (Nat.succ i) → E
Z :
fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i (↑g ∘ f) s) s x =
fderivWithin 𝕜 (↑(compContinuousMultilinearMapL (fun x => E) g) ∘ iteratedFDerivWithin 𝕜 i f s) s x
⊢ ↑(↑(ContinuousLinearMap.comp (↑(compContinuousMultilinearMapL (fun x => E) g))
(fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i f s) s x))
(m 0))
(tail m) =
↑(ContinuousLinearMap.compContinuousMultilinearMap (↑g) (iteratedFDerivWithin 𝕜 (Nat.succ i) f s x)) m
[PROOFSTEP]
simp only [ContinuousLinearMap.coe_comp', ContinuousLinearEquiv.coe_coe, comp_apply,
ContinuousLinearEquiv.compContinuousMultilinearMapL_apply, ContinuousLinearMap.compContinuousMultilinearMap_coe,
EmbeddingLike.apply_eq_iff_eq]
[GOAL]
case succ.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F ≃L[𝕜] G
f : E → F
hs : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
i : ℕ
IH :
∀ {x : E},
x ∈ s →
iteratedFDerivWithin 𝕜 i (↑g ∘ f) s x =
ContinuousLinearMap.compContinuousMultilinearMap (↑g) (iteratedFDerivWithin 𝕜 i f s x)
x : E
hx : x ∈ s
m : Fin (Nat.succ i) → E
Z :
fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i (↑g ∘ f) s) s x =
fderivWithin 𝕜 (↑(compContinuousMultilinearMapL (fun x => E) g) ∘ iteratedFDerivWithin 𝕜 i f s) s x
⊢ ↑(↑(fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i f s) s x) (m 0)) (tail m) =
↑(iteratedFDerivWithin 𝕜 (Nat.succ i) f s x) m
[PROOFSTEP]
rw [iteratedFDerivWithin_succ_apply_left]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F
g : F →ₗᵢ[𝕜] G
hf : ContDiffOn 𝕜 n f s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
i : ℕ
hi : ↑i ≤ n
⊢ ‖iteratedFDerivWithin 𝕜 i (↑g ∘ f) s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
[PROOFSTEP]
have :
iteratedFDerivWithin 𝕜 i (g ∘ f) s x =
g.toContinuousLinearMap.compContinuousMultilinearMap (iteratedFDerivWithin 𝕜 i f s x) :=
g.toContinuousLinearMap.iteratedFDerivWithin_comp_left hf hs hx hi
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F
g : F →ₗᵢ[𝕜] G
hf : ContDiffOn 𝕜 n f s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
i : ℕ
hi : ↑i ≤ n
this :
iteratedFDerivWithin 𝕜 i (↑g ∘ f) s x =
ContinuousLinearMap.compContinuousMultilinearMap (toContinuousLinearMap g) (iteratedFDerivWithin 𝕜 i f s x)
⊢ ‖iteratedFDerivWithin 𝕜 i (↑g ∘ f) s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
[PROOFSTEP]
rw [this]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F
g : F →ₗᵢ[𝕜] G
hf : ContDiffOn 𝕜 n f s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
i : ℕ
hi : ↑i ≤ n
this :
iteratedFDerivWithin 𝕜 i (↑g ∘ f) s x =
ContinuousLinearMap.compContinuousMultilinearMap (toContinuousLinearMap g) (iteratedFDerivWithin 𝕜 i f s x)
⊢ ‖ContinuousLinearMap.compContinuousMultilinearMap (toContinuousLinearMap g) (iteratedFDerivWithin 𝕜 i f s x)‖ =
‖iteratedFDerivWithin 𝕜 i f s x‖
[PROOFSTEP]
apply LinearIsometry.norm_compContinuousMultilinearMap
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F
g : F →ₗᵢ[𝕜] G
hf : ContDiff 𝕜 n f
x : E
i : ℕ
hi : ↑i ≤ n
⊢ ‖iteratedFDeriv 𝕜 i (↑g ∘ f) x‖ = ‖iteratedFDeriv 𝕜 i f x‖
[PROOFSTEP]
simp only [← iteratedFDerivWithin_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F
g : F →ₗᵢ[𝕜] G
hf : ContDiff 𝕜 n f
x : E
i : ℕ
hi : ↑i ≤ n
⊢ ‖iteratedFDerivWithin 𝕜 i (↑g ∘ f) univ x‖ = ‖iteratedFDerivWithin 𝕜 i f univ x‖
[PROOFSTEP]
exact g.norm_iteratedFDerivWithin_comp_left hf.contDiffOn uniqueDiffOn_univ (mem_univ x) hi
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F ≃ₗᵢ[𝕜] G
f : E → F
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
i : ℕ
⊢ ‖iteratedFDerivWithin 𝕜 i (↑g ∘ f) s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
[PROOFSTEP]
have :
iteratedFDerivWithin 𝕜 i (g ∘ f) s x =
(g : F →L[𝕜] G).compContinuousMultilinearMap (iteratedFDerivWithin 𝕜 i f s x) :=
g.toContinuousLinearEquiv.iteratedFDerivWithin_comp_left f hs hx i
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F ≃ₗᵢ[𝕜] G
f : E → F
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
i : ℕ
this :
iteratedFDerivWithin 𝕜 i (↑g ∘ f) s x =
ContinuousLinearMap.compContinuousMultilinearMap (↑(ContinuousLinearEquiv.mk g.toLinearEquiv))
(iteratedFDerivWithin 𝕜 i f s x)
⊢ ‖iteratedFDerivWithin 𝕜 i (↑g ∘ f) s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
[PROOFSTEP]
rw [this]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F ≃ₗᵢ[𝕜] G
f : E → F
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
i : ℕ
this :
iteratedFDerivWithin 𝕜 i (↑g ∘ f) s x =
ContinuousLinearMap.compContinuousMultilinearMap (↑(ContinuousLinearEquiv.mk g.toLinearEquiv))
(iteratedFDerivWithin 𝕜 i f s x)
⊢ ‖ContinuousLinearMap.compContinuousMultilinearMap (↑(ContinuousLinearEquiv.mk g.toLinearEquiv))
(iteratedFDerivWithin 𝕜 i f s x)‖ =
‖iteratedFDerivWithin 𝕜 i f s x‖
[PROOFSTEP]
apply LinearIsometry.norm_compContinuousMultilinearMap g.toLinearIsometry
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F ≃ₗᵢ[𝕜] G
f : E → F
x : E
i : ℕ
⊢ ‖iteratedFDeriv 𝕜 i (↑g ∘ f) x‖ = ‖iteratedFDeriv 𝕜 i f x‖
[PROOFSTEP]
rw [← iteratedFDerivWithin_univ, ← iteratedFDerivWithin_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F ≃ₗᵢ[𝕜] G
f : E → F
x : E
i : ℕ
⊢ ‖iteratedFDerivWithin 𝕜 i (↑g ∘ f) univ x‖ = ‖iteratedFDerivWithin 𝕜 i f univ x‖
[PROOFSTEP]
apply g.norm_iteratedFDerivWithin_comp_left f uniqueDiffOn_univ (mem_univ x) i
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : F ≃L[𝕜] G
H : ContDiffWithinAt 𝕜 n (↑e ∘ f) s x
⊢ ContDiffWithinAt 𝕜 n f s x
[PROOFSTEP]
simpa only [(· ∘ ·), e.symm.coe_coe, e.symm_apply_apply] using H.continuousLinearMap_comp (e.symm : G →L[𝕜] F)
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : F ≃L[𝕜] G
⊢ ContDiffAt 𝕜 n (↑e ∘ f) x ↔ ContDiffAt 𝕜 n f x
[PROOFSTEP]
simp only [← contDiffWithinAt_univ, e.comp_contDiffWithinAt_iff]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : F ≃L[𝕜] G
⊢ ContDiffOn 𝕜 n (↑e ∘ f) s ↔ ContDiffOn 𝕜 n f s
[PROOFSTEP]
simp [ContDiffOn, e.comp_contDiffWithinAt_iff]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : F ≃L[𝕜] G
⊢ ContDiff 𝕜 n (↑e ∘ f) ↔ ContDiff 𝕜 n f
[PROOFSTEP]
simp only [← contDiffOn_univ, e.comp_contDiffOn_iff]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : G →L[𝕜] E
⊢ HasFTaylorSeriesUpToOn n (f ∘ ↑g)
(fun x k => ContinuousMultilinearMap.compContinuousLinearMap (p (↑g x) k) fun x => g) (↑g ⁻¹' s)
[PROOFSTEP]
let A : ∀ m : ℕ, (E[×m]→L[𝕜] F) → G[×m]→L[𝕜] F := fun m h => h.compContinuousLinearMap fun _ => g
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : G →L[𝕜] E
A : (m : ℕ) → ContinuousMultilinearMap 𝕜 (fun i => E) F → ContinuousMultilinearMap 𝕜 (fun i => G) F :=
fun m h => ContinuousMultilinearMap.compContinuousLinearMap h fun x => g
⊢ HasFTaylorSeriesUpToOn n (f ∘ ↑g)
(fun x k => ContinuousMultilinearMap.compContinuousLinearMap (p (↑g x) k) fun x => g) (↑g ⁻¹' s)
[PROOFSTEP]
have hA : ∀ m, IsBoundedLinearMap 𝕜 (A m) := fun m => isBoundedLinearMap_continuousMultilinearMap_comp_linear g
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : G →L[𝕜] E
A : (m : ℕ) → ContinuousMultilinearMap 𝕜 (fun i => E) F → ContinuousMultilinearMap 𝕜 (fun i => G) F :=
fun m h => ContinuousMultilinearMap.compContinuousLinearMap h fun x => g
hA : ∀ (m : ℕ), IsBoundedLinearMap 𝕜 (A m)
⊢ HasFTaylorSeriesUpToOn n (f ∘ ↑g)
(fun x k => ContinuousMultilinearMap.compContinuousLinearMap (p (↑g x) k) fun x => g) (↑g ⁻¹' s)
[PROOFSTEP]
constructor
[GOAL]
case zero_eq
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : G →L[𝕜] E
A : (m : ℕ) → ContinuousMultilinearMap 𝕜 (fun i => E) F → ContinuousMultilinearMap 𝕜 (fun i => G) F :=
fun m h => ContinuousMultilinearMap.compContinuousLinearMap h fun x => g
hA : ∀ (m : ℕ), IsBoundedLinearMap 𝕜 (A m)
⊢ ∀ (x : G),
x ∈ ↑g ⁻¹' s →
ContinuousMultilinearMap.uncurry0 (ContinuousMultilinearMap.compContinuousLinearMap (p (↑g x) 0) fun x => g) =
(f ∘ ↑g) x
[PROOFSTEP]
intro x hx
[GOAL]
case zero_eq
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : G →L[𝕜] E
A : (m : ℕ) → ContinuousMultilinearMap 𝕜 (fun i => E) F → ContinuousMultilinearMap 𝕜 (fun i => G) F :=
fun m h => ContinuousMultilinearMap.compContinuousLinearMap h fun x => g
hA : ∀ (m : ℕ), IsBoundedLinearMap 𝕜 (A m)
x : G
hx : x ∈ ↑g ⁻¹' s
⊢ ContinuousMultilinearMap.uncurry0 (ContinuousMultilinearMap.compContinuousLinearMap (p (↑g x) 0) fun x => g) =
(f ∘ ↑g) x
[PROOFSTEP]
simp only [(hf.zero_eq (g x) hx).symm, Function.comp_apply]
[GOAL]
case zero_eq
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : G →L[𝕜] E
A : (m : ℕ) → ContinuousMultilinearMap 𝕜 (fun i => E) F → ContinuousMultilinearMap 𝕜 (fun i => G) F :=
fun m h => ContinuousMultilinearMap.compContinuousLinearMap h fun x => g
hA : ∀ (m : ℕ), IsBoundedLinearMap 𝕜 (A m)
x : G
hx : x ∈ ↑g ⁻¹' s
⊢ ContinuousMultilinearMap.uncurry0 (ContinuousMultilinearMap.compContinuousLinearMap (p (↑g x) 0) fun x => g) =
ContinuousMultilinearMap.uncurry0 (p (↑g x) 0)
[PROOFSTEP]
change (p (g x) 0 fun _ : Fin 0 => g 0) = p (g x) 0 0
[GOAL]
case zero_eq
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : G →L[𝕜] E
A : (m : ℕ) → ContinuousMultilinearMap 𝕜 (fun i => E) F → ContinuousMultilinearMap 𝕜 (fun i => G) F :=
fun m h => ContinuousMultilinearMap.compContinuousLinearMap h fun x => g
hA : ∀ (m : ℕ), IsBoundedLinearMap 𝕜 (A m)
x : G
hx : x ∈ ↑g ⁻¹' s
⊢ (↑(p (↑g x) 0) fun x => ↑g 0) = ↑(p (↑g x) 0) 0
[PROOFSTEP]
rw [ContinuousLinearMap.map_zero]
[GOAL]
case zero_eq
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : G →L[𝕜] E
A : (m : ℕ) → ContinuousMultilinearMap 𝕜 (fun i => E) F → ContinuousMultilinearMap 𝕜 (fun i => G) F :=
fun m h => ContinuousMultilinearMap.compContinuousLinearMap h fun x => g
hA : ∀ (m : ℕ), IsBoundedLinearMap 𝕜 (A m)
x : G
hx : x ∈ ↑g ⁻¹' s
⊢ (↑(p (↑g x) 0) fun x => 0) = ↑(p (↑g x) 0) 0
[PROOFSTEP]
rfl
[GOAL]
case fderivWithin
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : G →L[𝕜] E
A : (m : ℕ) → ContinuousMultilinearMap 𝕜 (fun i => E) F → ContinuousMultilinearMap 𝕜 (fun i => G) F :=
fun m h => ContinuousMultilinearMap.compContinuousLinearMap h fun x => g
hA : ∀ (m : ℕ), IsBoundedLinearMap 𝕜 (A m)
⊢ ∀ (m : ℕ),
↑m < n →
∀ (x : G),
x ∈ ↑g ⁻¹' s →
HasFDerivWithinAt (fun x => ContinuousMultilinearMap.compContinuousLinearMap (p (↑g x) m) fun x => g)
(ContinuousMultilinearMap.curryLeft
(ContinuousMultilinearMap.compContinuousLinearMap (p (↑g x) (Nat.succ m)) fun x => g))
(↑g ⁻¹' s) x
[PROOFSTEP]
intro m hm x hx
[GOAL]
case fderivWithin
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : G →L[𝕜] E
A : (m : ℕ) → ContinuousMultilinearMap 𝕜 (fun i => E) F → ContinuousMultilinearMap 𝕜 (fun i => G) F :=
fun m h => ContinuousMultilinearMap.compContinuousLinearMap h fun x => g
hA : ∀ (m : ℕ), IsBoundedLinearMap 𝕜 (A m)
m : ℕ
hm : ↑m < n
x : G
hx : x ∈ ↑g ⁻¹' s
⊢ HasFDerivWithinAt (fun x => ContinuousMultilinearMap.compContinuousLinearMap (p (↑g x) m) fun x => g)
(ContinuousMultilinearMap.curryLeft
(ContinuousMultilinearMap.compContinuousLinearMap (p (↑g x) (Nat.succ m)) fun x => g))
(↑g ⁻¹' s) x
[PROOFSTEP]
convert
(hA m).hasFDerivAt.comp_hasFDerivWithinAt x
((hf.fderivWithin m hm (g x) hx).comp x g.hasFDerivWithinAt (Subset.refl _))
[GOAL]
case h.e'_10.h.h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : G →L[𝕜] E
A : (m : ℕ) → ContinuousMultilinearMap 𝕜 (fun i => E) F → ContinuousMultilinearMap 𝕜 (fun i => G) F :=
fun m h => ContinuousMultilinearMap.compContinuousLinearMap h fun x => g
hA : ∀ (m : ℕ), IsBoundedLinearMap 𝕜 (A m)
m : ℕ
hm : ↑m < n
x : G
hx : x ∈ ↑g ⁻¹' s
e_7✝ : ContinuousMultilinearMap.normedAddCommGroup = ContinuousMultilinearMap.normedAddCommGroup'
he✝ : ContinuousMultilinearMap.normedSpace' = ContinuousMultilinearMap.normedSpace'
⊢ ContinuousMultilinearMap.curryLeft
(ContinuousMultilinearMap.compContinuousLinearMap (p (↑g x) (Nat.succ m)) fun x => g) =
ContinuousLinearMap.comp (IsBoundedLinearMap.toContinuousLinearMap (_ : IsBoundedLinearMap 𝕜 (A m)))
(ContinuousLinearMap.comp (ContinuousMultilinearMap.curryLeft (p (↑g x) (Nat.succ m))) g)
[PROOFSTEP]
ext y v
[GOAL]
case h.e'_10.h.h.h.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : G →L[𝕜] E
A : (m : ℕ) → ContinuousMultilinearMap 𝕜 (fun i => E) F → ContinuousMultilinearMap 𝕜 (fun i => G) F :=
fun m h => ContinuousMultilinearMap.compContinuousLinearMap h fun x => g
hA : ∀ (m : ℕ), IsBoundedLinearMap 𝕜 (A m)
m : ℕ
hm : ↑m < n
x : G
hx : x ∈ ↑g ⁻¹' s
e_7✝ : ContinuousMultilinearMap.normedAddCommGroup = ContinuousMultilinearMap.normedAddCommGroup'
he✝ : ContinuousMultilinearMap.normedSpace' = ContinuousMultilinearMap.normedSpace'
y : G
v : Fin m → G
⊢ ↑(↑(ContinuousMultilinearMap.curryLeft
(ContinuousMultilinearMap.compContinuousLinearMap (p (↑g x) (Nat.succ m)) fun x => g))
y)
v =
↑(↑(ContinuousLinearMap.comp (IsBoundedLinearMap.toContinuousLinearMap (_ : IsBoundedLinearMap 𝕜 (A m)))
(ContinuousLinearMap.comp (ContinuousMultilinearMap.curryLeft (p (↑g x) (Nat.succ m))) g))
y)
v
[PROOFSTEP]
change p (g x) (Nat.succ m) (g ∘ cons y v) = p (g x) m.succ (cons (g y) (g ∘ v))
[GOAL]
case h.e'_10.h.h.h.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : G →L[𝕜] E
A : (m : ℕ) → ContinuousMultilinearMap 𝕜 (fun i => E) F → ContinuousMultilinearMap 𝕜 (fun i => G) F :=
fun m h => ContinuousMultilinearMap.compContinuousLinearMap h fun x => g
hA : ∀ (m : ℕ), IsBoundedLinearMap 𝕜 (A m)
m : ℕ
hm : ↑m < n
x : G
hx : x ∈ ↑g ⁻¹' s
e_7✝ : ContinuousMultilinearMap.normedAddCommGroup = ContinuousMultilinearMap.normedAddCommGroup'
he✝ : ContinuousMultilinearMap.normedSpace' = ContinuousMultilinearMap.normedSpace'
y : G
v : Fin m → G
⊢ ↑(p (↑g x) (Nat.succ m)) (↑g ∘ cons y v) = ↑(p (↑g x) (Nat.succ m)) (cons (↑g y) (↑g ∘ v))
[PROOFSTEP]
rw [comp_cons]
[GOAL]
case cont
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : G →L[𝕜] E
A : (m : ℕ) → ContinuousMultilinearMap 𝕜 (fun i => E) F → ContinuousMultilinearMap 𝕜 (fun i => G) F :=
fun m h => ContinuousMultilinearMap.compContinuousLinearMap h fun x => g
hA : ∀ (m : ℕ), IsBoundedLinearMap 𝕜 (A m)
⊢ ∀ (m : ℕ),
↑m ≤ n → ContinuousOn (fun x => ContinuousMultilinearMap.compContinuousLinearMap (p (↑g x) m) fun x => g) (↑g ⁻¹' s)
[PROOFSTEP]
intro m hm
[GOAL]
case cont
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : G →L[𝕜] E
A : (m : ℕ) → ContinuousMultilinearMap 𝕜 (fun i => E) F → ContinuousMultilinearMap 𝕜 (fun i => G) F :=
fun m h => ContinuousMultilinearMap.compContinuousLinearMap h fun x => g
hA : ∀ (m : ℕ), IsBoundedLinearMap 𝕜 (A m)
m : ℕ
hm : ↑m ≤ n
⊢ ContinuousOn (fun x => ContinuousMultilinearMap.compContinuousLinearMap (p (↑g x) m) fun x => g) (↑g ⁻¹' s)
[PROOFSTEP]
exact (hA m).continuous.comp_continuousOn <| (hf.cont m hm).comp g.continuous.continuousOn <| Subset.refl _
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
x : G
g : G →L[𝕜] E
hf : ContDiffWithinAt 𝕜 n f s (↑g x)
⊢ ContDiffWithinAt 𝕜 n (f ∘ ↑g) (↑g ⁻¹' s) x
[PROOFSTEP]
intro m hm
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
x : G
g : G →L[𝕜] E
hf : ContDiffWithinAt 𝕜 n f s (↑g x)
m : ℕ
hm : ↑m ≤ n
⊢ ∃ u, u ∈ 𝓝[insert x (↑g ⁻¹' s)] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (f ∘ ↑g) p u
[PROOFSTEP]
rcases hf m hm with ⟨u, hu, p, hp⟩
[GOAL]
case intro.intro.intro
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
x : G
g : G →L[𝕜] E
hf : ContDiffWithinAt 𝕜 n f s (↑g x)
m : ℕ
hm : ↑m ≤ n
u : Set E
hu : u ∈ 𝓝[insert (↑g x) s] ↑g x
p : E → FormalMultilinearSeries 𝕜 E F
hp : HasFTaylorSeriesUpToOn (↑m) f p u
⊢ ∃ u, u ∈ 𝓝[insert x (↑g ⁻¹' s)] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (f ∘ ↑g) p u
[PROOFSTEP]
refine ⟨g ⁻¹' u, ?_, _, hp.compContinuousLinearMap g⟩
[GOAL]
case intro.intro.intro
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
x : G
g : G →L[𝕜] E
hf : ContDiffWithinAt 𝕜 n f s (↑g x)
m : ℕ
hm : ↑m ≤ n
u : Set E
hu : u ∈ 𝓝[insert (↑g x) s] ↑g x
p : E → FormalMultilinearSeries 𝕜 E F
hp : HasFTaylorSeriesUpToOn (↑m) f p u
⊢ ↑g ⁻¹' u ∈ 𝓝[insert x (↑g ⁻¹' s)] x
[PROOFSTEP]
refine g.continuous.continuousWithinAt.tendsto_nhdsWithin ?_ hu
[GOAL]
case intro.intro.intro
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
x : G
g : G →L[𝕜] E
hf : ContDiffWithinAt 𝕜 n f s (↑g x)
m : ℕ
hm : ↑m ≤ n
u : Set E
hu : u ∈ 𝓝[insert (↑g x) s] ↑g x
p : E → FormalMultilinearSeries 𝕜 E F
hp : HasFTaylorSeriesUpToOn (↑m) f p u
⊢ MapsTo (↑g) (insert x (↑g ⁻¹' s)) (insert (↑g x) s)
[PROOFSTEP]
exact (mapsTo_singleton.2 <| mem_singleton _).union_union (mapsTo_preimage _ _)
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : G ≃L[𝕜] E
f : E → F
hs : UniqueDiffOn 𝕜 s
x : G
hx : ↑g x ∈ s
i : ℕ
⊢ iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s) x =
ContinuousMultilinearMap.compContinuousLinearMap (iteratedFDerivWithin 𝕜 i f s (↑g x)) fun x => ↑g
[PROOFSTEP]
induction' i with i IH generalizing x
[GOAL]
case zero
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : G ≃L[𝕜] E
f : E → F
hs : UniqueDiffOn 𝕜 s
x✝ : G
hx✝ : ↑g x✝ ∈ s
x : G
hx : ↑g x ∈ s
⊢ iteratedFDerivWithin 𝕜 Nat.zero (f ∘ ↑g) (↑g ⁻¹' s) x =
ContinuousMultilinearMap.compContinuousLinearMap (iteratedFDerivWithin 𝕜 Nat.zero f s (↑g x)) fun x => ↑g
[PROOFSTEP]
ext1
[GOAL]
case zero.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : G ≃L[𝕜] E
f : E → F
hs : UniqueDiffOn 𝕜 s
x✝¹ : G
hx✝ : ↑g x✝¹ ∈ s
x : G
hx : ↑g x ∈ s
x✝ : Fin Nat.zero → G
⊢ ↑(iteratedFDerivWithin 𝕜 Nat.zero (f ∘ ↑g) (↑g ⁻¹' s) x) x✝ =
↑(ContinuousMultilinearMap.compContinuousLinearMap (iteratedFDerivWithin 𝕜 Nat.zero f s (↑g x)) fun x => ↑g) x✝
[PROOFSTEP]
simp only [Nat.zero_eq, iteratedFDerivWithin_zero_apply, comp_apply,
ContinuousMultilinearMap.compContinuousLinearMap_apply]
[GOAL]
case succ
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : G ≃L[𝕜] E
f : E → F
hs : UniqueDiffOn 𝕜 s
x✝ : G
hx✝ : ↑g x✝ ∈ s
i : ℕ
IH :
∀ {x : G},
↑g x ∈ s →
iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s) x =
ContinuousMultilinearMap.compContinuousLinearMap (iteratedFDerivWithin 𝕜 i f s (↑g x)) fun x => ↑g
x : G
hx : ↑g x ∈ s
⊢ iteratedFDerivWithin 𝕜 (Nat.succ i) (f ∘ ↑g) (↑g ⁻¹' s) x =
ContinuousMultilinearMap.compContinuousLinearMap (iteratedFDerivWithin 𝕜 (Nat.succ i) f s (↑g x)) fun x => ↑g
[PROOFSTEP]
ext1 m
[GOAL]
case succ.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : G ≃L[𝕜] E
f : E → F
hs : UniqueDiffOn 𝕜 s
x✝ : G
hx✝ : ↑g x✝ ∈ s
i : ℕ
IH :
∀ {x : G},
↑g x ∈ s →
iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s) x =
ContinuousMultilinearMap.compContinuousLinearMap (iteratedFDerivWithin 𝕜 i f s (↑g x)) fun x => ↑g
x : G
hx : ↑g x ∈ s
m : Fin (Nat.succ i) → G
⊢ ↑(iteratedFDerivWithin 𝕜 (Nat.succ i) (f ∘ ↑g) (↑g ⁻¹' s) x) m =
↑(ContinuousMultilinearMap.compContinuousLinearMap (iteratedFDerivWithin 𝕜 (Nat.succ i) f s (↑g x)) fun x => ↑g) m
[PROOFSTEP]
simp only [ContinuousMultilinearMap.compContinuousLinearMap_apply, ContinuousLinearEquiv.coe_coe,
iteratedFDerivWithin_succ_apply_left]
[GOAL]
case succ.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : G ≃L[𝕜] E
f : E → F
hs : UniqueDiffOn 𝕜 s
x✝ : G
hx✝ : ↑g x✝ ∈ s
i : ℕ
IH :
∀ {x : G},
↑g x ∈ s →
iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s) x =
ContinuousMultilinearMap.compContinuousLinearMap (iteratedFDerivWithin 𝕜 i f s (↑g x)) fun x => ↑g
x : G
hx : ↑g x ∈ s
m : Fin (Nat.succ i) → G
⊢ ↑(↑(fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s)) (↑g ⁻¹' s) x) (m 0)) (tail m) =
↑(↑(fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i f s) s (↑g x)) (↑g (m 0))) (tail fun i => ↑g (m i))
[PROOFSTEP]
have :
fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i (f ∘ g) (g ⁻¹' s)) (g ⁻¹' s) x =
fderivWithin 𝕜
(ContinuousMultilinearMap.compContinuousLinearMapEquivL _ (fun _x : Fin i => g) ∘
(iteratedFDerivWithin 𝕜 i f s ∘ g))
(g ⁻¹' s) x :=
fderivWithin_congr' (@IH) hx
[GOAL]
case succ.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : G ≃L[𝕜] E
f : E → F
hs : UniqueDiffOn 𝕜 s
x✝ : G
hx✝ : ↑g x✝ ∈ s
i : ℕ
IH :
∀ {x : G},
↑g x ∈ s →
iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s) x =
ContinuousMultilinearMap.compContinuousLinearMap (iteratedFDerivWithin 𝕜 i f s (↑g x)) fun x => ↑g
x : G
hx : ↑g x ∈ s
m : Fin (Nat.succ i) → G
this :
fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s)) (↑g ⁻¹' s) x =
fderivWithin 𝕜
(↑(ContinuousMultilinearMap.compContinuousLinearMapEquivL F fun _x => g) ∘ iteratedFDerivWithin 𝕜 i f s ∘ ↑g)
(↑g ⁻¹' s) x
⊢ ↑(↑(fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s)) (↑g ⁻¹' s) x) (m 0)) (tail m) =
↑(↑(fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i f s) s (↑g x)) (↑g (m 0))) (tail fun i => ↑g (m i))
[PROOFSTEP]
rw [this, ContinuousLinearEquiv.comp_fderivWithin _ (g.uniqueDiffOn_preimage_iff.2 hs x hx)]
[GOAL]
case succ.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : G ≃L[𝕜] E
f : E → F
hs : UniqueDiffOn 𝕜 s
x✝ : G
hx✝ : ↑g x✝ ∈ s
i : ℕ
IH :
∀ {x : G},
↑g x ∈ s →
iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s) x =
ContinuousMultilinearMap.compContinuousLinearMap (iteratedFDerivWithin 𝕜 i f s (↑g x)) fun x => ↑g
x : G
hx : ↑g x ∈ s
m : Fin (Nat.succ i) → G
this :
fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s)) (↑g ⁻¹' s) x =
fderivWithin 𝕜
(↑(ContinuousMultilinearMap.compContinuousLinearMapEquivL F fun _x => g) ∘ iteratedFDerivWithin 𝕜 i f s ∘ ↑g)
(↑g ⁻¹' s) x
⊢ ↑(↑(ContinuousLinearMap.comp (↑(ContinuousMultilinearMap.compContinuousLinearMapEquivL F fun _x => g))
(fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i f s ∘ ↑g) (↑g ⁻¹' s) x))
(m 0))
(tail m) =
↑(↑(fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i f s) s (↑g x)) (↑g (m 0))) (tail fun i => ↑g (m i))
[PROOFSTEP]
simp only [ContinuousLinearMap.coe_comp', ContinuousLinearEquiv.coe_coe, comp_apply,
ContinuousMultilinearMap.compContinuousLinearMapEquivL_apply, ContinuousMultilinearMap.compContinuousLinearMap_apply]
[GOAL]
case succ.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : G ≃L[𝕜] E
f : E → F
hs : UniqueDiffOn 𝕜 s
x✝ : G
hx✝ : ↑g x✝ ∈ s
i : ℕ
IH :
∀ {x : G},
↑g x ∈ s →
iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s) x =
ContinuousMultilinearMap.compContinuousLinearMap (iteratedFDerivWithin 𝕜 i f s (↑g x)) fun x => ↑g
x : G
hx : ↑g x ∈ s
m : Fin (Nat.succ i) → G
this :
fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s)) (↑g ⁻¹' s) x =
fderivWithin 𝕜
(↑(ContinuousMultilinearMap.compContinuousLinearMapEquivL F fun _x => g) ∘ iteratedFDerivWithin 𝕜 i f s ∘ ↑g)
(↑g ⁻¹' s) x
⊢ (↑(↑(fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i f s ∘ ↑g) (↑g ⁻¹' s) x) (m 0)) fun i_1 => ↑g (tail m i_1)) =
↑(↑(fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i f s) s (↑g x)) (↑g (m 0))) (tail fun i => ↑g (m i))
[PROOFSTEP]
rw [ContinuousLinearEquiv.comp_right_fderivWithin _ (g.uniqueDiffOn_preimage_iff.2 hs x hx)]
[GOAL]
case succ.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : G ≃L[𝕜] E
f : E → F
hs : UniqueDiffOn 𝕜 s
x✝ : G
hx✝ : ↑g x✝ ∈ s
i : ℕ
IH :
∀ {x : G},
↑g x ∈ s →
iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s) x =
ContinuousMultilinearMap.compContinuousLinearMap (iteratedFDerivWithin 𝕜 i f s (↑g x)) fun x => ↑g
x : G
hx : ↑g x ∈ s
m : Fin (Nat.succ i) → G
this :
fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s)) (↑g ⁻¹' s) x =
fderivWithin 𝕜
(↑(ContinuousMultilinearMap.compContinuousLinearMapEquivL F fun _x => g) ∘ iteratedFDerivWithin 𝕜 i f s ∘ ↑g)
(↑g ⁻¹' s) x
⊢ (↑(↑(ContinuousLinearMap.comp (fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i f s) s (↑g x)) ↑g) (m 0)) fun i_1 =>
↑g (tail m i_1)) =
↑(↑(fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i f s) s (↑g x)) (↑g (m 0))) (tail fun i => ↑g (m i))
[PROOFSTEP]
rfl
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : G →L[𝕜] E
f : E → F
hf : ContDiff 𝕜 n f
x : G
i : ℕ
hi : ↑i ≤ n
⊢ iteratedFDeriv 𝕜 i (f ∘ ↑g) x =
ContinuousMultilinearMap.compContinuousLinearMap (iteratedFDeriv 𝕜 i f (↑g x)) fun x => g
[PROOFSTEP]
simp only [← iteratedFDerivWithin_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : G →L[𝕜] E
f : E → F
hf : ContDiff 𝕜 n f
x : G
i : ℕ
hi : ↑i ≤ n
⊢ iteratedFDerivWithin 𝕜 i (f ∘ ↑g) univ x =
ContinuousMultilinearMap.compContinuousLinearMap (iteratedFDerivWithin 𝕜 i f univ (↑g x)) fun x => g
[PROOFSTEP]
exact g.iteratedFDerivWithin_comp_right hf.contDiffOn uniqueDiffOn_univ uniqueDiffOn_univ (mem_univ _) hi
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : G ≃ₗᵢ[𝕜] E
f : E → F
hs : UniqueDiffOn 𝕜 s
x : G
hx : ↑g x ∈ s
i : ℕ
⊢ ‖iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s) x‖ = ‖iteratedFDerivWithin 𝕜 i f s (↑g x)‖
[PROOFSTEP]
have :
iteratedFDerivWithin 𝕜 i (f ∘ g) (g ⁻¹' s) x =
(iteratedFDerivWithin 𝕜 i f s (g x)).compContinuousLinearMap fun _ => g :=
g.toContinuousLinearEquiv.iteratedFDerivWithin_comp_right f hs hx i
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : G ≃ₗᵢ[𝕜] E
f : E → F
hs : UniqueDiffOn 𝕜 s
x : G
hx : ↑g x ∈ s
i : ℕ
this :
iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s) x =
ContinuousMultilinearMap.compContinuousLinearMap (iteratedFDerivWithin 𝕜 i f s (↑g x)) fun x =>
↑(ContinuousLinearEquiv.mk g.toLinearEquiv)
⊢ ‖iteratedFDerivWithin 𝕜 i (f ∘ ↑g) (↑g ⁻¹' s) x‖ = ‖iteratedFDerivWithin 𝕜 i f s (↑g x)‖
[PROOFSTEP]
rw [this, ContinuousMultilinearMap.norm_compContinuous_linearIsometryEquiv]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : G ≃ₗᵢ[𝕜] E
f : E → F
x : G
i : ℕ
⊢ ‖iteratedFDeriv 𝕜 i (f ∘ ↑g) x‖ = ‖iteratedFDeriv 𝕜 i f (↑g x)‖
[PROOFSTEP]
simp only [← iteratedFDerivWithin_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : G ≃ₗᵢ[𝕜] E
f : E → F
x : G
i : ℕ
⊢ ‖iteratedFDerivWithin 𝕜 i (f ∘ ↑g) univ x‖ = ‖iteratedFDerivWithin 𝕜 i f univ (↑g x)‖
[PROOFSTEP]
apply g.norm_iteratedFDerivWithin_comp_right f uniqueDiffOn_univ (mem_univ (g x)) i
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : G ≃L[𝕜] E
⊢ ContDiffWithinAt 𝕜 n (f ∘ ↑e) (↑e ⁻¹' s) (↑(ContinuousLinearEquiv.symm e) x) ↔ ContDiffWithinAt 𝕜 n f s x
[PROOFSTEP]
constructor
[GOAL]
case mp
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : G ≃L[𝕜] E
⊢ ContDiffWithinAt 𝕜 n (f ∘ ↑e) (↑e ⁻¹' s) (↑(ContinuousLinearEquiv.symm e) x) → ContDiffWithinAt 𝕜 n f s x
[PROOFSTEP]
intro H
[GOAL]
case mp
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : G ≃L[𝕜] E
H : ContDiffWithinAt 𝕜 n (f ∘ ↑e) (↑e ⁻¹' s) (↑(ContinuousLinearEquiv.symm e) x)
⊢ ContDiffWithinAt 𝕜 n f s x
[PROOFSTEP]
simpa [← preimage_comp, (· ∘ ·)] using H.comp_continuousLinearMap (e.symm : E →L[𝕜] G)
[GOAL]
case mpr
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : G ≃L[𝕜] E
⊢ ContDiffWithinAt 𝕜 n f s x → ContDiffWithinAt 𝕜 n (f ∘ ↑e) (↑e ⁻¹' s) (↑(ContinuousLinearEquiv.symm e) x)
[PROOFSTEP]
intro H
[GOAL]
case mpr
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : G ≃L[𝕜] E
H : ContDiffWithinAt 𝕜 n f s x
⊢ ContDiffWithinAt 𝕜 n (f ∘ ↑e) (↑e ⁻¹' s) (↑(ContinuousLinearEquiv.symm e) x)
[PROOFSTEP]
rw [← e.apply_symm_apply x, ← e.coe_coe] at H
[GOAL]
case mpr
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : G ≃L[𝕜] E
H : ContDiffWithinAt 𝕜 n f s (↑↑e (↑(ContinuousLinearEquiv.symm e) x))
⊢ ContDiffWithinAt 𝕜 n (f ∘ ↑e) (↑e ⁻¹' s) (↑(ContinuousLinearEquiv.symm e) x)
[PROOFSTEP]
exact H.comp_continuousLinearMap _
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : G ≃L[𝕜] E
⊢ ContDiffAt 𝕜 n (f ∘ ↑e) (↑(ContinuousLinearEquiv.symm e) x) ↔ ContDiffAt 𝕜 n f x
[PROOFSTEP]
rw [← contDiffWithinAt_univ, ← contDiffWithinAt_univ, ← preimage_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : G ≃L[𝕜] E
⊢ ContDiffWithinAt 𝕜 n (f ∘ ↑e) (?m.505075 ⁻¹' univ) (↑(ContinuousLinearEquiv.symm e) x) ↔ ContDiffWithinAt 𝕜 n f univ x
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : G ≃L[𝕜] E
⊢ Type ?u.505072
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : G ≃L[𝕜] E
⊢ G → ?m.505074
[PROOFSTEP]
exact e.contDiffWithinAt_comp_iff
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : G ≃L[𝕜] E
H : ContDiffOn 𝕜 n (f ∘ ↑e) (↑e ⁻¹' s)
⊢ ContDiffOn 𝕜 n f s
[PROOFSTEP]
simpa [(· ∘ ·)] using H.comp_continuousLinearMap (e.symm : E →L[𝕜] G)
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : G ≃L[𝕜] E
⊢ ContDiff 𝕜 n (f ∘ ↑e) ↔ ContDiff 𝕜 n f
[PROOFSTEP]
rw [← contDiffOn_univ, ← contDiffOn_univ, ← preimage_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : G ≃L[𝕜] E
⊢ ContDiffOn 𝕜 n (f ∘ ↑e) (?m.518842 ⁻¹' univ) ↔ ContDiffOn 𝕜 n f univ
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : G ≃L[𝕜] E
⊢ Type ?u.518839
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
e : G ≃L[𝕜] E
⊢ G → ?m.518841
[PROOFSTEP]
exact e.contDiffOn_comp_iff
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : E → G
q : E → FormalMultilinearSeries 𝕜 E G
hg : HasFTaylorSeriesUpToOn n g q s
⊢ HasFTaylorSeriesUpToOn n (fun y => (f y, g y)) (fun y k => ContinuousMultilinearMap.prod (p y k) (q y k)) s
[PROOFSTEP]
set L := fun m => ContinuousMultilinearMap.prodL 𝕜 (fun _ : Fin m => E) F G
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : E → G
q : E → FormalMultilinearSeries 𝕜 E G
hg : HasFTaylorSeriesUpToOn n g q s
L : (m : ℕ) →
ContinuousMultilinearMap 𝕜 (fun x => E) F × ContinuousMultilinearMap 𝕜 (fun x => E) G ≃ₗᵢ[𝕜]
ContinuousMultilinearMap 𝕜 (fun x => E) (F × G) :=
fun m => ContinuousMultilinearMap.prodL 𝕜 (fun x => E) F G
⊢ HasFTaylorSeriesUpToOn n (fun y => (f y, g y)) (fun y k => ContinuousMultilinearMap.prod (p y k) (q y k)) s
[PROOFSTEP]
constructor
[GOAL]
case zero_eq
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : E → G
q : E → FormalMultilinearSeries 𝕜 E G
hg : HasFTaylorSeriesUpToOn n g q s
L : (m : ℕ) →
ContinuousMultilinearMap 𝕜 (fun x => E) F × ContinuousMultilinearMap 𝕜 (fun x => E) G ≃ₗᵢ[𝕜]
ContinuousMultilinearMap 𝕜 (fun x => E) (F × G) :=
fun m => ContinuousMultilinearMap.prodL 𝕜 (fun x => E) F G
⊢ ∀ (x : E), x ∈ s → ContinuousMultilinearMap.uncurry0 (ContinuousMultilinearMap.prod (p x 0) (q x 0)) = (f x, g x)
[PROOFSTEP]
intro x hx
[GOAL]
case zero_eq
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : E → G
q : E → FormalMultilinearSeries 𝕜 E G
hg : HasFTaylorSeriesUpToOn n g q s
L : (m : ℕ) →
ContinuousMultilinearMap 𝕜 (fun x => E) F × ContinuousMultilinearMap 𝕜 (fun x => E) G ≃ₗᵢ[𝕜]
ContinuousMultilinearMap 𝕜 (fun x => E) (F × G) :=
fun m => ContinuousMultilinearMap.prodL 𝕜 (fun x => E) F G
x : E
hx : x ∈ s
⊢ ContinuousMultilinearMap.uncurry0 (ContinuousMultilinearMap.prod (p x 0) (q x 0)) = (f x, g x)
[PROOFSTEP]
rw [← hf.zero_eq x hx, ← hg.zero_eq x hx]
[GOAL]
case zero_eq
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : E → G
q : E → FormalMultilinearSeries 𝕜 E G
hg : HasFTaylorSeriesUpToOn n g q s
L : (m : ℕ) →
ContinuousMultilinearMap 𝕜 (fun x => E) F × ContinuousMultilinearMap 𝕜 (fun x => E) G ≃ₗᵢ[𝕜]
ContinuousMultilinearMap 𝕜 (fun x => E) (F × G) :=
fun m => ContinuousMultilinearMap.prodL 𝕜 (fun x => E) F G
x : E
hx : x ∈ s
⊢ ContinuousMultilinearMap.uncurry0 (ContinuousMultilinearMap.prod (p x 0) (q x 0)) =
(ContinuousMultilinearMap.uncurry0 (p x 0), ContinuousMultilinearMap.uncurry0 (q x 0))
[PROOFSTEP]
rfl
[GOAL]
case fderivWithin
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : E → G
q : E → FormalMultilinearSeries 𝕜 E G
hg : HasFTaylorSeriesUpToOn n g q s
L : (m : ℕ) →
ContinuousMultilinearMap 𝕜 (fun x => E) F × ContinuousMultilinearMap 𝕜 (fun x => E) G ≃ₗᵢ[𝕜]
ContinuousMultilinearMap 𝕜 (fun x => E) (F × G) :=
fun m => ContinuousMultilinearMap.prodL 𝕜 (fun x => E) F G
⊢ ∀ (m : ℕ),
↑m < n →
∀ (x : E),
x ∈ s →
HasFDerivWithinAt (fun x => ContinuousMultilinearMap.prod (p x m) (q x m))
(ContinuousMultilinearMap.curryLeft (ContinuousMultilinearMap.prod (p x (Nat.succ m)) (q x (Nat.succ m)))) s
x
[PROOFSTEP]
intro m hm x hx
[GOAL]
case fderivWithin
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : E → G
q : E → FormalMultilinearSeries 𝕜 E G
hg : HasFTaylorSeriesUpToOn n g q s
L : (m : ℕ) →
ContinuousMultilinearMap 𝕜 (fun x => E) F × ContinuousMultilinearMap 𝕜 (fun x => E) G ≃ₗᵢ[𝕜]
ContinuousMultilinearMap 𝕜 (fun x => E) (F × G) :=
fun m => ContinuousMultilinearMap.prodL 𝕜 (fun x => E) F G
m : ℕ
hm : ↑m < n
x : E
hx : x ∈ s
⊢ HasFDerivWithinAt (fun x => ContinuousMultilinearMap.prod (p x m) (q x m))
(ContinuousMultilinearMap.curryLeft (ContinuousMultilinearMap.prod (p x (Nat.succ m)) (q x (Nat.succ m)))) s x
[PROOFSTEP]
convert (L m).hasFDerivAt.comp_hasFDerivWithinAt x ((hf.fderivWithin m hm x hx).prod (hg.fderivWithin m hm x hx))
[GOAL]
case cont
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : E → G
q : E → FormalMultilinearSeries 𝕜 E G
hg : HasFTaylorSeriesUpToOn n g q s
L : (m : ℕ) →
ContinuousMultilinearMap 𝕜 (fun x => E) F × ContinuousMultilinearMap 𝕜 (fun x => E) G ≃ₗᵢ[𝕜]
ContinuousMultilinearMap 𝕜 (fun x => E) (F × G) :=
fun m => ContinuousMultilinearMap.prodL 𝕜 (fun x => E) F G
⊢ ∀ (m : ℕ), ↑m ≤ n → ContinuousOn (fun x => ContinuousMultilinearMap.prod (p x m) (q x m)) s
[PROOFSTEP]
intro m hm
[GOAL]
case cont
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : HasFTaylorSeriesUpToOn n f p s
g : E → G
q : E → FormalMultilinearSeries 𝕜 E G
hg : HasFTaylorSeriesUpToOn n g q s
L : (m : ℕ) →
ContinuousMultilinearMap 𝕜 (fun x => E) F × ContinuousMultilinearMap 𝕜 (fun x => E) G ≃ₗᵢ[𝕜]
ContinuousMultilinearMap 𝕜 (fun x => E) (F × G) :=
fun m => ContinuousMultilinearMap.prodL 𝕜 (fun x => E) F G
m : ℕ
hm : ↑m ≤ n
⊢ ContinuousOn (fun x => ContinuousMultilinearMap.prod (p x m) (q x m)) s
[PROOFSTEP]
exact (L m).continuous.comp_continuousOn ((hf.cont m hm).prod (hg.cont m hm))
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
f : E → F
g : E → G
hf : ContDiffWithinAt 𝕜 n f s x
hg : ContDiffWithinAt 𝕜 n g s x
⊢ ContDiffWithinAt 𝕜 n (fun x => (f x, g x)) s x
[PROOFSTEP]
intro m hm
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
f : E → F
g : E → G
hf : ContDiffWithinAt 𝕜 n f s x
hg : ContDiffWithinAt 𝕜 n g s x
m : ℕ
hm : ↑m ≤ n
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (fun x => (f x, g x)) p u
[PROOFSTEP]
rcases hf m hm with ⟨u, hu, p, hp⟩
[GOAL]
case intro.intro.intro
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
f : E → F
g : E → G
hf : ContDiffWithinAt 𝕜 n f s x
hg : ContDiffWithinAt 𝕜 n g s x
m : ℕ
hm : ↑m ≤ n
u : Set E
hu : u ∈ 𝓝[insert x s] x
p : E → FormalMultilinearSeries 𝕜 E F
hp : HasFTaylorSeriesUpToOn (↑m) f p u
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (fun x => (f x, g x)) p u
[PROOFSTEP]
rcases hg m hm with ⟨v, hv, q, hq⟩
[GOAL]
case intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
f : E → F
g : E → G
hf : ContDiffWithinAt 𝕜 n f s x
hg : ContDiffWithinAt 𝕜 n g s x
m : ℕ
hm : ↑m ≤ n
u : Set E
hu : u ∈ 𝓝[insert x s] x
p : E → FormalMultilinearSeries 𝕜 E F
hp : HasFTaylorSeriesUpToOn (↑m) f p u
v : Set E
hv : v ∈ 𝓝[insert x s] x
q : E → FormalMultilinearSeries 𝕜 E G
hq : HasFTaylorSeriesUpToOn (↑m) g q v
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (fun x => (f x, g x)) p u
[PROOFSTEP]
exact ⟨u ∩ v, Filter.inter_mem hu hv, _, (hp.mono (inter_subset_left u v)).prod (hq.mono (inter_subset_right u v))⟩
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁵ : NormedAddCommGroup D
inst✝¹⁴ : NormedSpace 𝕜 D
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
⊢ ContDiffOn 𝕜 n (g ∘ f) s
[PROOFSTEP]
induction' n using ENat.nat_induction with n IH Itop generalizing Eu Fu Gu
[GOAL]
case h0
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n g✝ t✝
hf✝ : ContDiffOn 𝕜 n f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg : ContDiffOn 𝕜 0 g t
hf : ContDiffOn 𝕜 0 f s
st : s ⊆ f ⁻¹' t
⊢ ContDiffOn 𝕜 0 (g ∘ f) s
[PROOFSTEP]
rw [contDiffOn_zero] at hf hg ⊢
[GOAL]
case h0
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n g✝ t✝
hf✝ : ContDiffOn 𝕜 n f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg : ContinuousOn g t
hf : ContinuousOn f s
st : s ⊆ f ⁻¹' t
⊢ ContinuousOn (g ∘ f) s
[PROOFSTEP]
exact ContinuousOn.comp hg hf st
[GOAL]
case hsuc
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
⊢ ContDiffOn 𝕜 (↑(Nat.succ n)) (g ∘ f) s
[PROOFSTEP]
rw [contDiffOn_succ_iff_hasFDerivWithinAt] at hg ⊢
[GOAL]
case hsuc
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
⊢ ∀ (x : Eu),
x ∈ s →
∃ u,
u ∈ 𝓝[insert x s] x ∧ ∃ f', (∀ (x : Eu), x ∈ u → HasFDerivWithinAt (g ∘ f) (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
[PROOFSTEP]
intro x hx
[GOAL]
case hsuc
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ f', (∀ (x : Eu), x ∈ u → HasFDerivWithinAt (g ∘ f) (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
[PROOFSTEP]
rcases(contDiffOn_succ_iff_hasFDerivWithinAt.1 hf) x hx with ⟨u, hu, f', hf', f'_diff⟩
[GOAL]
case hsuc.intro.intro.intro.intro
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[insert x s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ f', (∀ (x : Eu), x ∈ u → HasFDerivWithinAt (g ∘ f) (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
[PROOFSTEP]
rcases hg (f x) (st hx) with ⟨v, hv, g', hg', g'_diff⟩
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[insert x s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ f', (∀ (x : Eu), x ∈ u → HasFDerivWithinAt (g ∘ f) (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
[PROOFSTEP]
rw [insert_eq_of_mem hx] at hu ⊢
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
⊢ ∃ u, u ∈ 𝓝[s] x ∧ ∃ f', (∀ (x : Eu), x ∈ u → HasFDerivWithinAt (g ∘ f) (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
[PROOFSTEP]
have xu : x ∈ u := mem_of_mem_nhdsWithin hx hu
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
⊢ ∃ u, u ∈ 𝓝[s] x ∧ ∃ f', (∀ (x : Eu), x ∈ u → HasFDerivWithinAt (g ∘ f) (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
[PROOFSTEP]
let w := s ∩ (u ∩ f ⁻¹' v)
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
⊢ ∃ u, u ∈ 𝓝[s] x ∧ ∃ f', (∀ (x : Eu), x ∈ u → HasFDerivWithinAt (g ∘ f) (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
[PROOFSTEP]
have wv : w ⊆ f ⁻¹' v := fun y hy => hy.2.2
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
⊢ ∃ u, u ∈ 𝓝[s] x ∧ ∃ f', (∀ (x : Eu), x ∈ u → HasFDerivWithinAt (g ∘ f) (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
[PROOFSTEP]
have wu : w ⊆ u := fun y hy => hy.2.1
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
⊢ ∃ u, u ∈ 𝓝[s] x ∧ ∃ f', (∀ (x : Eu), x ∈ u → HasFDerivWithinAt (g ∘ f) (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
[PROOFSTEP]
have ws : w ⊆ s := fun y hy => hy.1
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
⊢ ∃ u, u ∈ 𝓝[s] x ∧ ∃ f', (∀ (x : Eu), x ∈ u → HasFDerivWithinAt (g ∘ f) (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
[PROOFSTEP]
refine' ⟨w, _, fun y => (g' (f y)).comp (f' y), _, _⟩
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_1
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
⊢ w ∈ 𝓝[s] x
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_2
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
⊢ ∀ (x : Eu), x ∈ w → HasFDerivWithinAt (g ∘ f) ((fun y => ContinuousLinearMap.comp (g' (f y)) (f' y)) x) w x
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_3
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
⊢ ContDiffOn 𝕜 (↑n) (fun y => ContinuousLinearMap.comp (g' (f y)) (f' y)) w
[PROOFSTEP]
show w ∈ 𝓝[s] x
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_1
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
⊢ w ∈ 𝓝[s] x
[PROOFSTEP]
apply Filter.inter_mem self_mem_nhdsWithin
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_1
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
⊢ u ∩ f ⁻¹' v ∈ 𝓝[s] x
[PROOFSTEP]
apply Filter.inter_mem hu
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_1
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
⊢ f ⁻¹' v ∈ 𝓝[s] x
[PROOFSTEP]
apply ContinuousWithinAt.preimage_mem_nhdsWithin'
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_1.h
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
⊢ ContinuousWithinAt f s x
[PROOFSTEP]
rw [← continuousWithinAt_inter' hu]
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_1.h
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
⊢ ContinuousWithinAt f (s ∩ u) x
[PROOFSTEP]
exact (hf' x xu).differentiableWithinAt.continuousWithinAt.mono (inter_subset_right _ _)
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_1.ht
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
⊢ v ∈ 𝓝[f '' s] f x
[PROOFSTEP]
apply nhdsWithin_mono _ _ hv
[GOAL]
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
⊢ f '' s ⊆ insert (f x) t
[PROOFSTEP]
exact Subset.trans (image_subset_iff.mpr st) (subset_insert (f x) t)
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_2
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
⊢ ∀ (x : Eu), x ∈ w → HasFDerivWithinAt (g ∘ f) ((fun y => ContinuousLinearMap.comp (g' (f y)) (f' y)) x) w x
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_3
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
⊢ ContDiffOn 𝕜 (↑n) (fun y => ContinuousLinearMap.comp (g' (f y)) (f' y)) w
[PROOFSTEP]
show ∀ y ∈ w, HasFDerivWithinAt (g ∘ f) ((g' (f y)).comp (f' y)) w y
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_2
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
⊢ ∀ (y : Eu), y ∈ w → HasFDerivWithinAt (g ∘ f) (ContinuousLinearMap.comp (g' (f y)) (f' y)) w y
[PROOFSTEP]
rintro y ⟨-, yu, yv⟩
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_2.intro.intro
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
y : Eu
yu : y ∈ u
yv : y ∈ f ⁻¹' v
⊢ HasFDerivWithinAt (g ∘ f) (ContinuousLinearMap.comp (g' (f y)) (f' y)) w y
[PROOFSTEP]
exact (hg' (f y) yv).comp y ((hf' y yu).mono wu) wv
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_3
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
⊢ ContDiffOn 𝕜 (↑n) (fun y => ContinuousLinearMap.comp (g' (f y)) (f' y)) w
[PROOFSTEP]
show ContDiffOn 𝕜 n (fun y => (g' (f y)).comp (f' y)) w
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_3
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
⊢ ContDiffOn 𝕜 (↑n) (fun y => ContinuousLinearMap.comp (g' (f y)) (f' y)) w
[PROOFSTEP]
have A : ContDiffOn 𝕜 n (fun y => g' (f y)) w :=
IH g'_diff ((hf.of_le (WithTop.coe_le_coe.2 (Nat.le_succ n))).mono ws) wv
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_3
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
A : ContDiffOn 𝕜 (↑n) (fun y => g' (f y)) w
⊢ ContDiffOn 𝕜 (↑n) (fun y => ContinuousLinearMap.comp (g' (f y)) (f' y)) w
[PROOFSTEP]
have B : ContDiffOn 𝕜 n f' w := f'_diff.mono wu
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_3
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
A : ContDiffOn 𝕜 (↑n) (fun y => g' (f y)) w
B : ContDiffOn 𝕜 (↑n) f' w
⊢ ContDiffOn 𝕜 (↑n) (fun y => ContinuousLinearMap.comp (g' (f y)) (f' y)) w
[PROOFSTEP]
have C : ContDiffOn 𝕜 n (fun y => (g' (f y), f' y)) w := A.prod B
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_3
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
A : ContDiffOn 𝕜 (↑n) (fun y => g' (f y)) w
B : ContDiffOn 𝕜 (↑n) f' w
C : ContDiffOn 𝕜 (↑n) (fun y => (g' (f y), f' y)) w
⊢ ContDiffOn 𝕜 (↑n) (fun y => ContinuousLinearMap.comp (g' (f y)) (f' y)) w
[PROOFSTEP]
have D : ContDiffOn 𝕜 n (fun p : (Fu →L[𝕜] Gu) × (Eu →L[𝕜] Fu) => p.1.comp p.2) univ :=
isBoundedBilinearMap_comp.contDiff.contDiffOn
[GOAL]
case hsuc.intro.intro.intro.intro.intro.intro.intro.intro.refine'_3
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝²¹ : NormedAddCommGroup D✝
inst✝²⁰ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n✝ g✝ t✝
hf✝ : ContDiffOn 𝕜 n✝ f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
n : ℕ
IH :
∀ {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg :
∀ (x : Fu),
x ∈ t →
∃ u, u ∈ 𝓝[insert x t] x ∧ ∃ f', (∀ (x : Fu), x ∈ u → HasFDerivWithinAt g (f' x) u x) ∧ ContDiffOn 𝕜 (↑n) f' u
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
st : s ⊆ f ⁻¹' t
x : Eu
hx : x ∈ s
u : Set Eu
hu : u ∈ 𝓝[s] x
f' : Eu → Eu →L[𝕜] Fu
hf' : ∀ (x : Eu), x ∈ u → HasFDerivWithinAt f (f' x) u x
f'_diff : ContDiffOn 𝕜 (↑n) f' u
v : Set Fu
hv : v ∈ 𝓝[insert (f x) t] f x
g' : Fu → Fu →L[𝕜] Gu
hg' : ∀ (x : Fu), x ∈ v → HasFDerivWithinAt g (g' x) v x
g'_diff : ContDiffOn 𝕜 (↑n) g' v
xu : x ∈ u
w : Set Eu := s ∩ (u ∩ f ⁻¹' v)
wv : w ⊆ f ⁻¹' v
wu : w ⊆ u
ws : w ⊆ s
A : ContDiffOn 𝕜 (↑n) (fun y => g' (f y)) w
B : ContDiffOn 𝕜 (↑n) f' w
C : ContDiffOn 𝕜 (↑n) (fun y => (g' (f y), f' y)) w
D : ContDiffOn 𝕜 (↑n) (fun p => ContinuousLinearMap.comp p.fst p.snd) univ
⊢ ContDiffOn 𝕜 (↑n) (fun y => ContinuousLinearMap.comp (g' (f y)) (f' y)) w
[PROOFSTEP]
exact IH D C (subset_univ _)
[GOAL]
case htop
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n g✝ t✝
hf✝ : ContDiffOn 𝕜 n f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
Itop :
∀ (n : ℕ) {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg : ContDiffOn 𝕜 ⊤ g t
hf : ContDiffOn 𝕜 ⊤ f s
st : s ⊆ f ⁻¹' t
⊢ ContDiffOn 𝕜 ⊤ (g ∘ f) s
[PROOFSTEP]
rw [contDiffOn_top] at hf hg ⊢
[GOAL]
case htop
𝕜 : Type u_1
inst✝²² : NontriviallyNormedField 𝕜
D : Type uD
inst✝²¹ : NormedAddCommGroup D
inst✝²⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁹ : NormedAddCommGroup E
inst✝¹⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁷ : NormedAddCommGroup F
inst✝¹⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁵ : NormedAddCommGroup G
inst✝¹⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹³ : NormedAddCommGroup X
inst✝¹² : 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
Eu✝ : Type u
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
Fu✝ : Type u
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
Gu✝ : Type u
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
s✝ : Set Eu✝
t✝ : Set Fu✝
g✝ : Fu✝ → Gu✝
f✝ : Eu✝ → Fu✝
hg✝ : ContDiffOn 𝕜 n g✝ t✝
hf✝ : ContDiffOn 𝕜 n f✝ s✝
st✝ : s✝ ⊆ f✝ ⁻¹' t✝
Itop :
∀ (n : ℕ) {Eu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] {Fu : Type u}
[inst_2 : NormedAddCommGroup Fu] [inst_3 : NormedSpace 𝕜 Fu] {Gu : Type u} [inst_4 : NormedAddCommGroup Gu]
[inst_5 : NormedSpace 𝕜 Gu] {s : Set Eu} {t : Set Fu} {g : Fu → Gu} {f : Eu → Fu},
ContDiffOn 𝕜 (↑n) g t → ContDiffOn 𝕜 (↑n) f s → s ⊆ f ⁻¹' t → ContDiffOn 𝕜 (↑n) (g ∘ f) s
Eu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
s : Set Eu
t : Set Fu
g : Fu → Gu
f : Eu → Fu
hg : ∀ (n : ℕ), ContDiffOn 𝕜 (↑n) g t
hf : ∀ (n : ℕ), ContDiffOn 𝕜 (↑n) f s
st : s ⊆ f ⁻¹' t
⊢ ∀ (n : ℕ), ContDiffOn 𝕜 (↑n) (g ∘ f) s
[PROOFSTEP]
exact fun n => Itop n (hg n) (hf n) st
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
⊢ ContDiffOn 𝕜 n (g ∘ f) s
[PROOFSTEP]
let Eu : Type max uE uF uG := ULift.{max uF uG} E
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
⊢ ContDiffOn 𝕜 n (g ∘ f) s
[PROOFSTEP]
let Fu : Type max uE uF uG := ULift.{max uE uG} F
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
⊢ ContDiffOn 𝕜 n (g ∘ f) s
[PROOFSTEP]
let Gu : Type max uE uF uG := ULift.{max uE uF} G
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
⊢ ContDiffOn 𝕜 n (g ∘ f) s
[PROOFSTEP]
have isoE : Eu ≃L[𝕜] E := ContinuousLinearEquiv.ulift
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
⊢ ContDiffOn 𝕜 n (g ∘ f) s
[PROOFSTEP]
have isoF : Fu ≃L[𝕜] F := ContinuousLinearEquiv.ulift
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
isoF : Fu ≃L[𝕜] F
⊢ ContDiffOn 𝕜 n (g ∘ f) s
[PROOFSTEP]
have isoG : Gu ≃L[𝕜] G := ContinuousLinearEquiv.ulift
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
isoF : Fu ≃L[𝕜] F
isoG : Gu ≃L[𝕜] G
⊢ ContDiffOn 𝕜 n (g ∘ f) s
[PROOFSTEP]
let fu : Eu → Fu := (isoF.symm ∘ f) ∘ isoE
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
isoF : Fu ≃L[𝕜] F
isoG : Gu ≃L[𝕜] G
fu : Eu → Fu := (↑(ContinuousLinearEquiv.symm isoF) ∘ f) ∘ ↑isoE
⊢ ContDiffOn 𝕜 n (g ∘ f) s
[PROOFSTEP]
have fu_diff : ContDiffOn 𝕜 n fu (isoE ⁻¹' s) := by rwa [isoE.contDiffOn_comp_iff, isoF.symm.comp_contDiffOn_iff]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
isoF : Fu ≃L[𝕜] F
isoG : Gu ≃L[𝕜] G
fu : Eu → Fu := (↑(ContinuousLinearEquiv.symm isoF) ∘ f) ∘ ↑isoE
⊢ ContDiffOn 𝕜 n fu (↑isoE ⁻¹' s)
[PROOFSTEP]
rwa [isoE.contDiffOn_comp_iff, isoF.symm.comp_contDiffOn_iff]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
isoF : Fu ≃L[𝕜] F
isoG : Gu ≃L[𝕜] G
fu : Eu → Fu := (↑(ContinuousLinearEquiv.symm isoF) ∘ f) ∘ ↑isoE
fu_diff : ContDiffOn 𝕜 n fu (↑isoE ⁻¹' s)
⊢ ContDiffOn 𝕜 n (g ∘ f) s
[PROOFSTEP]
let gu : Fu → Gu := (isoG.symm ∘ g) ∘ isoF
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
isoF : Fu ≃L[𝕜] F
isoG : Gu ≃L[𝕜] G
fu : Eu → Fu := (↑(ContinuousLinearEquiv.symm isoF) ∘ f) ∘ ↑isoE
fu_diff : ContDiffOn 𝕜 n fu (↑isoE ⁻¹' s)
gu : Fu → Gu := (↑(ContinuousLinearEquiv.symm isoG) ∘ g) ∘ ↑isoF
⊢ ContDiffOn 𝕜 n (g ∘ f) s
[PROOFSTEP]
have gu_diff : ContDiffOn 𝕜 n gu (isoF ⁻¹' t) := by rwa [isoF.contDiffOn_comp_iff, isoG.symm.comp_contDiffOn_iff]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
isoF : Fu ≃L[𝕜] F
isoG : Gu ≃L[𝕜] G
fu : Eu → Fu := (↑(ContinuousLinearEquiv.symm isoF) ∘ f) ∘ ↑isoE
fu_diff : ContDiffOn 𝕜 n fu (↑isoE ⁻¹' s)
gu : Fu → Gu := (↑(ContinuousLinearEquiv.symm isoG) ∘ g) ∘ ↑isoF
⊢ ContDiffOn 𝕜 n gu (↑isoF ⁻¹' t)
[PROOFSTEP]
rwa [isoF.contDiffOn_comp_iff, isoG.symm.comp_contDiffOn_iff]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
isoF : Fu ≃L[𝕜] F
isoG : Gu ≃L[𝕜] G
fu : Eu → Fu := (↑(ContinuousLinearEquiv.symm isoF) ∘ f) ∘ ↑isoE
fu_diff : ContDiffOn 𝕜 n fu (↑isoE ⁻¹' s)
gu : Fu → Gu := (↑(ContinuousLinearEquiv.symm isoG) ∘ g) ∘ ↑isoF
gu_diff : ContDiffOn 𝕜 n gu (↑isoF ⁻¹' t)
⊢ ContDiffOn 𝕜 n (g ∘ f) s
[PROOFSTEP]
have main : ContDiffOn 𝕜 n (gu ∘ fu) (isoE ⁻¹' s) :=
by
apply ContDiffOn.comp_same_univ gu_diff fu_diff
intro y hy
simp only [ContinuousLinearEquiv.coe_apply, Function.comp_apply, mem_preimage]
rw [isoF.apply_symm_apply (f (isoE y))]
exact st hy
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
isoF : Fu ≃L[𝕜] F
isoG : Gu ≃L[𝕜] G
fu : Eu → Fu := (↑(ContinuousLinearEquiv.symm isoF) ∘ f) ∘ ↑isoE
fu_diff : ContDiffOn 𝕜 n fu (↑isoE ⁻¹' s)
gu : Fu → Gu := (↑(ContinuousLinearEquiv.symm isoG) ∘ g) ∘ ↑isoF
gu_diff : ContDiffOn 𝕜 n gu (↑isoF ⁻¹' t)
⊢ ContDiffOn 𝕜 n (gu ∘ fu) (↑isoE ⁻¹' s)
[PROOFSTEP]
apply ContDiffOn.comp_same_univ gu_diff fu_diff
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
isoF : Fu ≃L[𝕜] F
isoG : Gu ≃L[𝕜] G
fu : Eu → Fu := (↑(ContinuousLinearEquiv.symm isoF) ∘ f) ∘ ↑isoE
fu_diff : ContDiffOn 𝕜 n fu (↑isoE ⁻¹' s)
gu : Fu → Gu := (↑(ContinuousLinearEquiv.symm isoG) ∘ g) ∘ ↑isoF
gu_diff : ContDiffOn 𝕜 n gu (↑isoF ⁻¹' t)
⊢ ↑isoE ⁻¹' s ⊆ fu ⁻¹' (↑isoF ⁻¹' t)
[PROOFSTEP]
intro y hy
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
isoF : Fu ≃L[𝕜] F
isoG : Gu ≃L[𝕜] G
fu : Eu → Fu := (↑(ContinuousLinearEquiv.symm isoF) ∘ f) ∘ ↑isoE
fu_diff : ContDiffOn 𝕜 n fu (↑isoE ⁻¹' s)
gu : Fu → Gu := (↑(ContinuousLinearEquiv.symm isoG) ∘ g) ∘ ↑isoF
gu_diff : ContDiffOn 𝕜 n gu (↑isoF ⁻¹' t)
y : Eu
hy : y ∈ ↑isoE ⁻¹' s
⊢ y ∈ fu ⁻¹' (↑isoF ⁻¹' t)
[PROOFSTEP]
simp only [ContinuousLinearEquiv.coe_apply, Function.comp_apply, mem_preimage]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
isoF : Fu ≃L[𝕜] F
isoG : Gu ≃L[𝕜] G
fu : Eu → Fu := (↑(ContinuousLinearEquiv.symm isoF) ∘ f) ∘ ↑isoE
fu_diff : ContDiffOn 𝕜 n fu (↑isoE ⁻¹' s)
gu : Fu → Gu := (↑(ContinuousLinearEquiv.symm isoG) ∘ g) ∘ ↑isoF
gu_diff : ContDiffOn 𝕜 n gu (↑isoF ⁻¹' t)
y : Eu
hy : y ∈ ↑isoE ⁻¹' s
⊢ ↑isoF (↑(ContinuousLinearEquiv.symm isoF) (f (↑isoE y))) ∈ t
[PROOFSTEP]
rw [isoF.apply_symm_apply (f (isoE y))]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
isoF : Fu ≃L[𝕜] F
isoG : Gu ≃L[𝕜] G
fu : Eu → Fu := (↑(ContinuousLinearEquiv.symm isoF) ∘ f) ∘ ↑isoE
fu_diff : ContDiffOn 𝕜 n fu (↑isoE ⁻¹' s)
gu : Fu → Gu := (↑(ContinuousLinearEquiv.symm isoG) ∘ g) ∘ ↑isoF
gu_diff : ContDiffOn 𝕜 n gu (↑isoF ⁻¹' t)
y : Eu
hy : y ∈ ↑isoE ⁻¹' s
⊢ f (↑isoE y) ∈ t
[PROOFSTEP]
exact st hy
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
isoF : Fu ≃L[𝕜] F
isoG : Gu ≃L[𝕜] G
fu : Eu → Fu := (↑(ContinuousLinearEquiv.symm isoF) ∘ f) ∘ ↑isoE
fu_diff : ContDiffOn 𝕜 n fu (↑isoE ⁻¹' s)
gu : Fu → Gu := (↑(ContinuousLinearEquiv.symm isoG) ∘ g) ∘ ↑isoF
gu_diff : ContDiffOn 𝕜 n gu (↑isoF ⁻¹' t)
main : ContDiffOn 𝕜 n (gu ∘ fu) (↑isoE ⁻¹' s)
⊢ ContDiffOn 𝕜 n (g ∘ f) s
[PROOFSTEP]
have : gu ∘ fu = (isoG.symm ∘ g ∘ f) ∘ isoE := by
ext y
simp only [Function.comp_apply]
rw [isoF.apply_symm_apply (f (isoE y))]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
isoF : Fu ≃L[𝕜] F
isoG : Gu ≃L[𝕜] G
fu : Eu → Fu := (↑(ContinuousLinearEquiv.symm isoF) ∘ f) ∘ ↑isoE
fu_diff : ContDiffOn 𝕜 n fu (↑isoE ⁻¹' s)
gu : Fu → Gu := (↑(ContinuousLinearEquiv.symm isoG) ∘ g) ∘ ↑isoF
gu_diff : ContDiffOn 𝕜 n gu (↑isoF ⁻¹' t)
main : ContDiffOn 𝕜 n (gu ∘ fu) (↑isoE ⁻¹' s)
⊢ gu ∘ fu = (↑(ContinuousLinearEquiv.symm isoG) ∘ g ∘ f) ∘ ↑isoE
[PROOFSTEP]
ext y
[GOAL]
case h.h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
isoF : Fu ≃L[𝕜] F
isoG : Gu ≃L[𝕜] G
fu : Eu → Fu := (↑(ContinuousLinearEquiv.symm isoF) ∘ f) ∘ ↑isoE
fu_diff : ContDiffOn 𝕜 n fu (↑isoE ⁻¹' s)
gu : Fu → Gu := (↑(ContinuousLinearEquiv.symm isoG) ∘ g) ∘ ↑isoF
gu_diff : ContDiffOn 𝕜 n gu (↑isoF ⁻¹' t)
main : ContDiffOn 𝕜 n (gu ∘ fu) (↑isoE ⁻¹' s)
y : Eu
⊢ ((gu ∘ fu) y).down = (((↑(ContinuousLinearEquiv.symm isoG) ∘ g ∘ f) ∘ ↑isoE) y).down
[PROOFSTEP]
simp only [Function.comp_apply]
[GOAL]
case h.h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
isoF : Fu ≃L[𝕜] F
isoG : Gu ≃L[𝕜] G
fu : Eu → Fu := (↑(ContinuousLinearEquiv.symm isoF) ∘ f) ∘ ↑isoE
fu_diff : ContDiffOn 𝕜 n fu (↑isoE ⁻¹' s)
gu : Fu → Gu := (↑(ContinuousLinearEquiv.symm isoG) ∘ g) ∘ ↑isoF
gu_diff : ContDiffOn 𝕜 n gu (↑isoF ⁻¹' t)
main : ContDiffOn 𝕜 n (gu ∘ fu) (↑isoE ⁻¹' s)
y : Eu
⊢ (↑(ContinuousLinearEquiv.symm isoG) (g (↑isoF (↑(ContinuousLinearEquiv.symm isoF) (f (↑isoE y)))))).down =
(↑(ContinuousLinearEquiv.symm isoG) (g (f (↑isoE y)))).down
[PROOFSTEP]
rw [isoF.apply_symm_apply (f (isoE y))]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
hg : ContDiffOn 𝕜 n g t
hf : ContDiffOn 𝕜 n f s
st : s ⊆ f ⁻¹' t
Eu : Type (max uE uF uG) := ULift E
Fu : Type (max uE uF uG) := ULift F
Gu : Type (max uE uF uG) := ULift G
isoE : Eu ≃L[𝕜] E
isoF : Fu ≃L[𝕜] F
isoG : Gu ≃L[𝕜] G
fu : Eu → Fu := (↑(ContinuousLinearEquiv.symm isoF) ∘ f) ∘ ↑isoE
fu_diff : ContDiffOn 𝕜 n fu (↑isoE ⁻¹' s)
gu : Fu → Gu := (↑(ContinuousLinearEquiv.symm isoG) ∘ g) ∘ ↑isoF
gu_diff : ContDiffOn 𝕜 n gu (↑isoF ⁻¹' t)
main : ContDiffOn 𝕜 n (gu ∘ fu) (↑isoE ⁻¹' s)
this : gu ∘ fu = (↑(ContinuousLinearEquiv.symm isoG) ∘ g ∘ f) ∘ ↑isoE
⊢ ContDiffOn 𝕜 n (g ∘ f) s
[PROOFSTEP]
rwa [this, isoE.contDiffOn_comp_iff, isoG.symm.comp_contDiffOn_iff] at main
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
x : E
hg : ContDiffWithinAt 𝕜 n g t (f x)
hf : ContDiffWithinAt 𝕜 n f s x
st : s ⊆ f ⁻¹' t
⊢ ContDiffWithinAt 𝕜 n (g ∘ f) s x
[PROOFSTEP]
intro m hm
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
x : E
hg : ContDiffWithinAt 𝕜 n g t (f x)
hf : ContDiffWithinAt 𝕜 n f s x
st : s ⊆ f ⁻¹' t
m : ℕ
hm : ↑m ≤ n
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (g ∘ f) p u
[PROOFSTEP]
rcases hg.contDiffOn hm with ⟨u, u_nhd, _, hu⟩
[GOAL]
case intro.intro.intro
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
x : E
hg : ContDiffWithinAt 𝕜 n g t (f x)
hf : ContDiffWithinAt 𝕜 n f s x
st : s ⊆ f ⁻¹' t
m : ℕ
hm : ↑m ≤ n
u : Set F
u_nhd : u ∈ 𝓝[insert (f x) t] f x
left✝ : u ⊆ insert (f x) t
hu : ContDiffOn 𝕜 (↑m) g u
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (g ∘ f) p u
[PROOFSTEP]
rcases hf.contDiffOn hm with ⟨v, v_nhd, vs, hv⟩
[GOAL]
case intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
x : E
hg : ContDiffWithinAt 𝕜 n g t (f x)
hf : ContDiffWithinAt 𝕜 n f s x
st : s ⊆ f ⁻¹' t
m : ℕ
hm : ↑m ≤ n
u : Set F
u_nhd : u ∈ 𝓝[insert (f x) t] f x
left✝ : u ⊆ insert (f x) t
hu : ContDiffOn 𝕜 (↑m) g u
v : Set E
v_nhd : v ∈ 𝓝[insert x s] x
vs : v ⊆ insert x s
hv : ContDiffOn 𝕜 (↑m) f v
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (g ∘ f) p u
[PROOFSTEP]
have xmem : x ∈ f ⁻¹' u ∩ v :=
⟨(mem_of_mem_nhdsWithin (mem_insert (f x) _) u_nhd : _), mem_of_mem_nhdsWithin (mem_insert x s) v_nhd⟩
[GOAL]
case intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
x : E
hg : ContDiffWithinAt 𝕜 n g t (f x)
hf : ContDiffWithinAt 𝕜 n f s x
st : s ⊆ f ⁻¹' t
m : ℕ
hm : ↑m ≤ n
u : Set F
u_nhd : u ∈ 𝓝[insert (f x) t] f x
left✝ : u ⊆ insert (f x) t
hu : ContDiffOn 𝕜 (↑m) g u
v : Set E
v_nhd : v ∈ 𝓝[insert x s] x
vs : v ⊆ insert x s
hv : ContDiffOn 𝕜 (↑m) f v
xmem : x ∈ f ⁻¹' u ∩ v
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (g ∘ f) p u
[PROOFSTEP]
have : f ⁻¹' u ∈ 𝓝[insert x s] x :=
by
apply hf.continuousWithinAt.insert_self.preimage_mem_nhdsWithin'
apply nhdsWithin_mono _ _ u_nhd
rw [image_insert_eq]
exact insert_subset_insert (image_subset_iff.mpr st)
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
x : E
hg : ContDiffWithinAt 𝕜 n g t (f x)
hf : ContDiffWithinAt 𝕜 n f s x
st : s ⊆ f ⁻¹' t
m : ℕ
hm : ↑m ≤ n
u : Set F
u_nhd : u ∈ 𝓝[insert (f x) t] f x
left✝ : u ⊆ insert (f x) t
hu : ContDiffOn 𝕜 (↑m) g u
v : Set E
v_nhd : v ∈ 𝓝[insert x s] x
vs : v ⊆ insert x s
hv : ContDiffOn 𝕜 (↑m) f v
xmem : x ∈ f ⁻¹' u ∩ v
⊢ f ⁻¹' u ∈ 𝓝[insert x s] x
[PROOFSTEP]
apply hf.continuousWithinAt.insert_self.preimage_mem_nhdsWithin'
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
x : E
hg : ContDiffWithinAt 𝕜 n g t (f x)
hf : ContDiffWithinAt 𝕜 n f s x
st : s ⊆ f ⁻¹' t
m : ℕ
hm : ↑m ≤ n
u : Set F
u_nhd : u ∈ 𝓝[insert (f x) t] f x
left✝ : u ⊆ insert (f x) t
hu : ContDiffOn 𝕜 (↑m) g u
v : Set E
v_nhd : v ∈ 𝓝[insert x s] x
vs : v ⊆ insert x s
hv : ContDiffOn 𝕜 (↑m) f v
xmem : x ∈ f ⁻¹' u ∩ v
⊢ u ∈ 𝓝[f '' insert x s] f x
[PROOFSTEP]
apply nhdsWithin_mono _ _ u_nhd
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
x : E
hg : ContDiffWithinAt 𝕜 n g t (f x)
hf : ContDiffWithinAt 𝕜 n f s x
st : s ⊆ f ⁻¹' t
m : ℕ
hm : ↑m ≤ n
u : Set F
u_nhd : u ∈ 𝓝[insert (f x) t] f x
left✝ : u ⊆ insert (f x) t
hu : ContDiffOn 𝕜 (↑m) g u
v : Set E
v_nhd : v ∈ 𝓝[insert x s] x
vs : v ⊆ insert x s
hv : ContDiffOn 𝕜 (↑m) f v
xmem : x ∈ f ⁻¹' u ∩ v
⊢ f '' insert x s ⊆ insert (f x) t
[PROOFSTEP]
rw [image_insert_eq]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
x : E
hg : ContDiffWithinAt 𝕜 n g t (f x)
hf : ContDiffWithinAt 𝕜 n f s x
st : s ⊆ f ⁻¹' t
m : ℕ
hm : ↑m ≤ n
u : Set F
u_nhd : u ∈ 𝓝[insert (f x) t] f x
left✝ : u ⊆ insert (f x) t
hu : ContDiffOn 𝕜 (↑m) g u
v : Set E
v_nhd : v ∈ 𝓝[insert x s] x
vs : v ⊆ insert x s
hv : ContDiffOn 𝕜 (↑m) f v
xmem : x ∈ f ⁻¹' u ∩ v
⊢ insert (f x) (f '' s) ⊆ insert (f x) t
[PROOFSTEP]
exact insert_subset_insert (image_subset_iff.mpr st)
[GOAL]
case intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
x : E
hg : ContDiffWithinAt 𝕜 n g t (f x)
hf : ContDiffWithinAt 𝕜 n f s x
st : s ⊆ f ⁻¹' t
m : ℕ
hm : ↑m ≤ n
u : Set F
u_nhd : u ∈ 𝓝[insert (f x) t] f x
left✝ : u ⊆ insert (f x) t
hu : ContDiffOn 𝕜 (↑m) g u
v : Set E
v_nhd : v ∈ 𝓝[insert x s] x
vs : v ⊆ insert x s
hv : ContDiffOn 𝕜 (↑m) f v
xmem : x ∈ f ⁻¹' u ∩ v
this : f ⁻¹' u ∈ 𝓝[insert x s] x
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (g ∘ f) p u
[PROOFSTEP]
have Z := (hu.comp (hv.mono (inter_subset_right (f ⁻¹' u) v)) (inter_subset_left _ _)).contDiffWithinAt xmem m le_rfl
[GOAL]
case intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
x : E
hg : ContDiffWithinAt 𝕜 n g t (f x)
hf : ContDiffWithinAt 𝕜 n f s x
st : s ⊆ f ⁻¹' t
m : ℕ
hm : ↑m ≤ n
u : Set F
u_nhd : u ∈ 𝓝[insert (f x) t] f x
left✝ : u ⊆ insert (f x) t
hu : ContDiffOn 𝕜 (↑m) g u
v : Set E
v_nhd : v ∈ 𝓝[insert x s] x
vs : v ⊆ insert x s
hv : ContDiffOn 𝕜 (↑m) f v
xmem : x ∈ f ⁻¹' u ∩ v
this : f ⁻¹' u ∈ 𝓝[insert x s] x
Z : ∃ u_1, u_1 ∈ 𝓝[insert x (f ⁻¹' u ∩ v)] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (g ∘ f) p u_1
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (g ∘ f) p u
[PROOFSTEP]
have : 𝓝[f ⁻¹' u ∩ v] x = 𝓝[insert x s] x :=
by
have A : f ⁻¹' u ∩ v = insert x s ∩ (f ⁻¹' u ∩ v) :=
by
apply Subset.antisymm _ (inter_subset_right _ _)
rintro y ⟨hy1, hy2⟩
simpa only [mem_inter_iff, mem_preimage, hy2, and_true, true_and, vs hy2] using hy1
rw [A, ← nhdsWithin_restrict'']
exact Filter.inter_mem this v_nhd
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
x : E
hg : ContDiffWithinAt 𝕜 n g t (f x)
hf : ContDiffWithinAt 𝕜 n f s x
st : s ⊆ f ⁻¹' t
m : ℕ
hm : ↑m ≤ n
u : Set F
u_nhd : u ∈ 𝓝[insert (f x) t] f x
left✝ : u ⊆ insert (f x) t
hu : ContDiffOn 𝕜 (↑m) g u
v : Set E
v_nhd : v ∈ 𝓝[insert x s] x
vs : v ⊆ insert x s
hv : ContDiffOn 𝕜 (↑m) f v
xmem : x ∈ f ⁻¹' u ∩ v
this : f ⁻¹' u ∈ 𝓝[insert x s] x
Z : ∃ u_1, u_1 ∈ 𝓝[insert x (f ⁻¹' u ∩ v)] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (g ∘ f) p u_1
⊢ 𝓝[f ⁻¹' u ∩ v] x = 𝓝[insert x s] x
[PROOFSTEP]
have A : f ⁻¹' u ∩ v = insert x s ∩ (f ⁻¹' u ∩ v) :=
by
apply Subset.antisymm _ (inter_subset_right _ _)
rintro y ⟨hy1, hy2⟩
simpa only [mem_inter_iff, mem_preimage, hy2, and_true, true_and, vs hy2] using hy1
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
x : E
hg : ContDiffWithinAt 𝕜 n g t (f x)
hf : ContDiffWithinAt 𝕜 n f s x
st : s ⊆ f ⁻¹' t
m : ℕ
hm : ↑m ≤ n
u : Set F
u_nhd : u ∈ 𝓝[insert (f x) t] f x
left✝ : u ⊆ insert (f x) t
hu : ContDiffOn 𝕜 (↑m) g u
v : Set E
v_nhd : v ∈ 𝓝[insert x s] x
vs : v ⊆ insert x s
hv : ContDiffOn 𝕜 (↑m) f v
xmem : x ∈ f ⁻¹' u ∩ v
this : f ⁻¹' u ∈ 𝓝[insert x s] x
Z : ∃ u_1, u_1 ∈ 𝓝[insert x (f ⁻¹' u ∩ v)] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (g ∘ f) p u_1
⊢ f ⁻¹' u ∩ v = insert x s ∩ (f ⁻¹' u ∩ v)
[PROOFSTEP]
apply Subset.antisymm _ (inter_subset_right _ _)
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
x : E
hg : ContDiffWithinAt 𝕜 n g t (f x)
hf : ContDiffWithinAt 𝕜 n f s x
st : s ⊆ f ⁻¹' t
m : ℕ
hm : ↑m ≤ n
u : Set F
u_nhd : u ∈ 𝓝[insert (f x) t] f x
left✝ : u ⊆ insert (f x) t
hu : ContDiffOn 𝕜 (↑m) g u
v : Set E
v_nhd : v ∈ 𝓝[insert x s] x
vs : v ⊆ insert x s
hv : ContDiffOn 𝕜 (↑m) f v
xmem : x ∈ f ⁻¹' u ∩ v
this : f ⁻¹' u ∈ 𝓝[insert x s] x
Z : ∃ u_1, u_1 ∈ 𝓝[insert x (f ⁻¹' u ∩ v)] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (g ∘ f) p u_1
⊢ f ⁻¹' u ∩ v ⊆ insert x s ∩ (f ⁻¹' u ∩ v)
[PROOFSTEP]
rintro y ⟨hy1, hy2⟩
[GOAL]
case intro
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
x : E
hg : ContDiffWithinAt 𝕜 n g t (f x)
hf : ContDiffWithinAt 𝕜 n f s x
st : s ⊆ f ⁻¹' t
m : ℕ
hm : ↑m ≤ n
u : Set F
u_nhd : u ∈ 𝓝[insert (f x) t] f x
left✝ : u ⊆ insert (f x) t
hu : ContDiffOn 𝕜 (↑m) g u
v : Set E
v_nhd : v ∈ 𝓝[insert x s] x
vs : v ⊆ insert x s
hv : ContDiffOn 𝕜 (↑m) f v
xmem : x ∈ f ⁻¹' u ∩ v
this : f ⁻¹' u ∈ 𝓝[insert x s] x
Z : ∃ u_1, u_1 ∈ 𝓝[insert x (f ⁻¹' u ∩ v)] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (g ∘ f) p u_1
y : E
hy1 : y ∈ f ⁻¹' u
hy2 : y ∈ v
⊢ y ∈ insert x s ∩ (f ⁻¹' u ∩ v)
[PROOFSTEP]
simpa only [mem_inter_iff, mem_preimage, hy2, and_true, true_and, vs hy2] using hy1
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
x : E
hg : ContDiffWithinAt 𝕜 n g t (f x)
hf : ContDiffWithinAt 𝕜 n f s x
st : s ⊆ f ⁻¹' t
m : ℕ
hm : ↑m ≤ n
u : Set F
u_nhd : u ∈ 𝓝[insert (f x) t] f x
left✝ : u ⊆ insert (f x) t
hu : ContDiffOn 𝕜 (↑m) g u
v : Set E
v_nhd : v ∈ 𝓝[insert x s] x
vs : v ⊆ insert x s
hv : ContDiffOn 𝕜 (↑m) f v
xmem : x ∈ f ⁻¹' u ∩ v
this : f ⁻¹' u ∈ 𝓝[insert x s] x
Z : ∃ u_1, u_1 ∈ 𝓝[insert x (f ⁻¹' u ∩ v)] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (g ∘ f) p u_1
A : f ⁻¹' u ∩ v = insert x s ∩ (f ⁻¹' u ∩ v)
⊢ 𝓝[f ⁻¹' u ∩ v] x = 𝓝[insert x s] x
[PROOFSTEP]
rw [A, ← nhdsWithin_restrict'']
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
x : E
hg : ContDiffWithinAt 𝕜 n g t (f x)
hf : ContDiffWithinAt 𝕜 n f s x
st : s ⊆ f ⁻¹' t
m : ℕ
hm : ↑m ≤ n
u : Set F
u_nhd : u ∈ 𝓝[insert (f x) t] f x
left✝ : u ⊆ insert (f x) t
hu : ContDiffOn 𝕜 (↑m) g u
v : Set E
v_nhd : v ∈ 𝓝[insert x s] x
vs : v ⊆ insert x s
hv : ContDiffOn 𝕜 (↑m) f v
xmem : x ∈ f ⁻¹' u ∩ v
this : f ⁻¹' u ∈ 𝓝[insert x s] x
Z : ∃ u_1, u_1 ∈ 𝓝[insert x (f ⁻¹' u ∩ v)] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (g ∘ f) p u_1
A : f ⁻¹' u ∩ v = insert x s ∩ (f ⁻¹' u ∩ v)
⊢ f ⁻¹' u ∩ v ∈ 𝓝[insert x s] x
[PROOFSTEP]
exact Filter.inter_mem this v_nhd
[GOAL]
case intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
t : Set F
g : F → G
f : E → F
x : E
hg : ContDiffWithinAt 𝕜 n g t (f x)
hf : ContDiffWithinAt 𝕜 n f s x
st : s ⊆ f ⁻¹' t
m : ℕ
hm : ↑m ≤ n
u : Set F
u_nhd : u ∈ 𝓝[insert (f x) t] f x
left✝ : u ⊆ insert (f x) t
hu : ContDiffOn 𝕜 (↑m) g u
v : Set E
v_nhd : v ∈ 𝓝[insert x s] x
vs : v ⊆ insert x s
hv : ContDiffOn 𝕜 (↑m) f v
xmem : x ∈ f ⁻¹' u ∩ v
this✝ : f ⁻¹' u ∈ 𝓝[insert x s] x
Z : ∃ u_1, u_1 ∈ 𝓝[insert x (f ⁻¹' u ∩ v)] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (g ∘ f) p u_1
this : 𝓝[f ⁻¹' u ∩ v] x = 𝓝[insert x s] x
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) (g ∘ f) p u
[PROOFSTEP]
rwa [insert_eq_of_mem xmem, this] at Z
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ
x₀ : E
hf : ContDiffWithinAt 𝕜 (↑n + 1) (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 (↑n) g s x₀
hgt : t ∈ 𝓝[g '' s] g x₀
⊢ ∃ v,
v ∈ 𝓝[insert x₀ s] x₀ ∧
v ⊆ insert x₀ s ∧
∃ f', (∀ (x : E), x ∈ v → HasFDerivWithinAt (f x) (f' x) t (g x)) ∧ ContDiffWithinAt 𝕜 (↑n) (fun x => f' x) s x₀
[PROOFSTEP]
have hst : insert x₀ s ×ˢ t ∈ 𝓝[(fun x => (x, g x)) '' s] (x₀, g x₀) :=
by
refine' nhdsWithin_mono _ _ (nhdsWithin_prod self_mem_nhdsWithin hgt)
simp_rw [image_subset_iff, mk_preimage_prod, preimage_id', subset_inter_iff, subset_insert, true_and_iff,
subset_preimage_image]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ
x₀ : E
hf : ContDiffWithinAt 𝕜 (↑n + 1) (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 (↑n) g s x₀
hgt : t ∈ 𝓝[g '' s] g x₀
⊢ insert x₀ s ×ˢ t ∈ 𝓝[(fun x => (x, g x)) '' s] (x₀, g x₀)
[PROOFSTEP]
refine' nhdsWithin_mono _ _ (nhdsWithin_prod self_mem_nhdsWithin hgt)
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ
x₀ : E
hf : ContDiffWithinAt 𝕜 (↑n + 1) (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 (↑n) g s x₀
hgt : t ∈ 𝓝[g '' s] g x₀
⊢ (fun x => (x, g x)) '' s ⊆ insert x₀ s ×ˢ (g '' s)
[PROOFSTEP]
simp_rw [image_subset_iff, mk_preimage_prod, preimage_id', subset_inter_iff, subset_insert, true_and_iff,
subset_preimage_image]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ
x₀ : E
hf : ContDiffWithinAt 𝕜 (↑n + 1) (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 (↑n) g s x₀
hgt : t ∈ 𝓝[g '' s] g x₀
hst : insert x₀ s ×ˢ t ∈ 𝓝[(fun x => (x, g x)) '' s] (x₀, g x₀)
⊢ ∃ v,
v ∈ 𝓝[insert x₀ s] x₀ ∧
v ⊆ insert x₀ s ∧
∃ f', (∀ (x : E), x ∈ v → HasFDerivWithinAt (f x) (f' x) t (g x)) ∧ ContDiffWithinAt 𝕜 (↑n) (fun x => f' x) s x₀
[PROOFSTEP]
obtain ⟨v, hv, hvs, f', hvf', hf'⟩ := contDiffWithinAt_succ_iff_hasFDerivWithinAt'.mp hf
[GOAL]
case intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ
x₀ : E
hf : ContDiffWithinAt 𝕜 (↑n + 1) (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 (↑n) g s x₀
hgt : t ∈ 𝓝[g '' s] g x₀
hst : insert x₀ s ×ˢ t ∈ 𝓝[(fun x => (x, g x)) '' s] (x₀, g x₀)
v : Set (E × F)
hv : v ∈ 𝓝[insert (x₀, g x₀) (insert x₀ s ×ˢ t)] (x₀, g x₀)
hvs : v ⊆ insert (x₀, g x₀) (insert x₀ s ×ˢ t)
f' : E × F → E × F →L[𝕜] G
hvf' : ∀ (x : E × F), x ∈ v → HasFDerivWithinAt (uncurry f) (f' x) (insert x₀ s ×ˢ t) x
hf' : ContDiffWithinAt 𝕜 (↑↑n) f' (insert x₀ s ×ˢ t) (x₀, g x₀)
⊢ ∃ v,
v ∈ 𝓝[insert x₀ s] x₀ ∧
v ⊆ insert x₀ s ∧
∃ f', (∀ (x : E), x ∈ v → HasFDerivWithinAt (f x) (f' x) t (g x)) ∧ ContDiffWithinAt 𝕜 (↑n) (fun x => f' x) s x₀
[PROOFSTEP]
refine'
⟨(fun z => (z, g z)) ⁻¹' v ∩ insert x₀ s, _, inter_subset_right _ _, fun z =>
(f' (z, g z)).comp (ContinuousLinearMap.inr 𝕜 E F), _, _⟩
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ
x₀ : E
hf : ContDiffWithinAt 𝕜 (↑n + 1) (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 (↑n) g s x₀
hgt : t ∈ 𝓝[g '' s] g x₀
hst : insert x₀ s ×ˢ t ∈ 𝓝[(fun x => (x, g x)) '' s] (x₀, g x₀)
v : Set (E × F)
hv : v ∈ 𝓝[insert (x₀, g x₀) (insert x₀ s ×ˢ t)] (x₀, g x₀)
hvs : v ⊆ insert (x₀, g x₀) (insert x₀ s ×ˢ t)
f' : E × F → E × F →L[𝕜] G
hvf' : ∀ (x : E × F), x ∈ v → HasFDerivWithinAt (uncurry f) (f' x) (insert x₀ s ×ˢ t) x
hf' : ContDiffWithinAt 𝕜 (↑↑n) f' (insert x₀ s ×ˢ t) (x₀, g x₀)
⊢ (fun z => (z, g z)) ⁻¹' v ∩ insert x₀ s ∈ 𝓝[insert x₀ s] x₀
[PROOFSTEP]
refine' inter_mem _ self_mem_nhdsWithin
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ
x₀ : E
hf : ContDiffWithinAt 𝕜 (↑n + 1) (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 (↑n) g s x₀
hgt : t ∈ 𝓝[g '' s] g x₀
hst : insert x₀ s ×ˢ t ∈ 𝓝[(fun x => (x, g x)) '' s] (x₀, g x₀)
v : Set (E × F)
hv : v ∈ 𝓝[insert (x₀, g x₀) (insert x₀ s ×ˢ t)] (x₀, g x₀)
hvs : v ⊆ insert (x₀, g x₀) (insert x₀ s ×ˢ t)
f' : E × F → E × F →L[𝕜] G
hvf' : ∀ (x : E × F), x ∈ v → HasFDerivWithinAt (uncurry f) (f' x) (insert x₀ s ×ˢ t) x
hf' : ContDiffWithinAt 𝕜 (↑↑n) f' (insert x₀ s ×ˢ t) (x₀, g x₀)
⊢ (fun z => (z, g z)) ⁻¹' v ∈ 𝓝[insert x₀ s] x₀
[PROOFSTEP]
have := mem_of_mem_nhdsWithin (mem_insert _ _) hv
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ
x₀ : E
hf : ContDiffWithinAt 𝕜 (↑n + 1) (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 (↑n) g s x₀
hgt : t ∈ 𝓝[g '' s] g x₀
hst : insert x₀ s ×ˢ t ∈ 𝓝[(fun x => (x, g x)) '' s] (x₀, g x₀)
v : Set (E × F)
hv : v ∈ 𝓝[insert (x₀, g x₀) (insert x₀ s ×ˢ t)] (x₀, g x₀)
hvs : v ⊆ insert (x₀, g x₀) (insert x₀ s ×ˢ t)
f' : E × F → E × F →L[𝕜] G
hvf' : ∀ (x : E × F), x ∈ v → HasFDerivWithinAt (uncurry f) (f' x) (insert x₀ s ×ˢ t) x
hf' : ContDiffWithinAt 𝕜 (↑↑n) f' (insert x₀ s ×ˢ t) (x₀, g x₀)
this : (x₀, g x₀) ∈ v
⊢ (fun z => (z, g z)) ⁻¹' v ∈ 𝓝[insert x₀ s] x₀
[PROOFSTEP]
refine' mem_nhdsWithin_insert.mpr ⟨this, _⟩
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ
x₀ : E
hf : ContDiffWithinAt 𝕜 (↑n + 1) (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 (↑n) g s x₀
hgt : t ∈ 𝓝[g '' s] g x₀
hst : insert x₀ s ×ˢ t ∈ 𝓝[(fun x => (x, g x)) '' s] (x₀, g x₀)
v : Set (E × F)
hv : v ∈ 𝓝[insert (x₀, g x₀) (insert x₀ s ×ˢ t)] (x₀, g x₀)
hvs : v ⊆ insert (x₀, g x₀) (insert x₀ s ×ˢ t)
f' : E × F → E × F →L[𝕜] G
hvf' : ∀ (x : E × F), x ∈ v → HasFDerivWithinAt (uncurry f) (f' x) (insert x₀ s ×ˢ t) x
hf' : ContDiffWithinAt 𝕜 (↑↑n) f' (insert x₀ s ×ˢ t) (x₀, g x₀)
this : (x₀, g x₀) ∈ v
⊢ (fun z => (z, g z)) ⁻¹' v ∈ 𝓝[s] x₀
[PROOFSTEP]
refine' (continuousWithinAt_id.prod hg.continuousWithinAt).preimage_mem_nhdsWithin' _
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ
x₀ : E
hf : ContDiffWithinAt 𝕜 (↑n + 1) (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 (↑n) g s x₀
hgt : t ∈ 𝓝[g '' s] g x₀
hst : insert x₀ s ×ˢ t ∈ 𝓝[(fun x => (x, g x)) '' s] (x₀, g x₀)
v : Set (E × F)
hv : v ∈ 𝓝[insert (x₀, g x₀) (insert x₀ s ×ˢ t)] (x₀, g x₀)
hvs : v ⊆ insert (x₀, g x₀) (insert x₀ s ×ˢ t)
f' : E × F → E × F →L[𝕜] G
hvf' : ∀ (x : E × F), x ∈ v → HasFDerivWithinAt (uncurry f) (f' x) (insert x₀ s ×ˢ t) x
hf' : ContDiffWithinAt 𝕜 (↑↑n) f' (insert x₀ s ×ˢ t) (x₀, g x₀)
this : (x₀, g x₀) ∈ v
⊢ v ∈ 𝓝[(fun x => (id x, g x)) '' s] (id x₀, g x₀)
[PROOFSTEP]
rw [← nhdsWithin_le_iff] at hst hv ⊢
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ
x₀ : E
hf : ContDiffWithinAt 𝕜 (↑n + 1) (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 (↑n) g s x₀
hgt : t ∈ 𝓝[g '' s] g x₀
hst : 𝓝[(fun x => (x, g x)) '' s] (x₀, g x₀) ≤ 𝓝[insert x₀ s ×ˢ t] (x₀, g x₀)
v : Set (E × F)
hv : 𝓝[insert (x₀, g x₀) (insert x₀ s ×ˢ t)] (x₀, g x₀) ≤ 𝓝[v] (x₀, g x₀)
hvs : v ⊆ insert (x₀, g x₀) (insert x₀ s ×ˢ t)
f' : E × F → E × F →L[𝕜] G
hvf' : ∀ (x : E × F), x ∈ v → HasFDerivWithinAt (uncurry f) (f' x) (insert x₀ s ×ˢ t) x
hf' : ContDiffWithinAt 𝕜 (↑↑n) f' (insert x₀ s ×ˢ t) (x₀, g x₀)
this : (x₀, g x₀) ∈ v
⊢ 𝓝[(fun x => (id x, g x)) '' s] (id x₀, g x₀) ≤ 𝓝[v] (id x₀, g x₀)
[PROOFSTEP]
refine' (hst.trans <| nhdsWithin_mono _ <| subset_insert _ _).trans hv
[GOAL]
case intro.intro.intro.intro.intro.refine'_2
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ
x₀ : E
hf : ContDiffWithinAt 𝕜 (↑n + 1) (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 (↑n) g s x₀
hgt : t ∈ 𝓝[g '' s] g x₀
hst : insert x₀ s ×ˢ t ∈ 𝓝[(fun x => (x, g x)) '' s] (x₀, g x₀)
v : Set (E × F)
hv : v ∈ 𝓝[insert (x₀, g x₀) (insert x₀ s ×ˢ t)] (x₀, g x₀)
hvs : v ⊆ insert (x₀, g x₀) (insert x₀ s ×ˢ t)
f' : E × F → E × F →L[𝕜] G
hvf' : ∀ (x : E × F), x ∈ v → HasFDerivWithinAt (uncurry f) (f' x) (insert x₀ s ×ˢ t) x
hf' : ContDiffWithinAt 𝕜 (↑↑n) f' (insert x₀ s ×ˢ t) (x₀, g x₀)
⊢ ∀ (x : E),
x ∈ (fun z => (z, g z)) ⁻¹' v ∩ insert x₀ s →
HasFDerivWithinAt (f x) ((fun z => ContinuousLinearMap.comp (f' (z, g z)) (ContinuousLinearMap.inr 𝕜 E F)) x) t
(g x)
[PROOFSTEP]
intro z hz
[GOAL]
case intro.intro.intro.intro.intro.refine'_2
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ
x₀ : E
hf : ContDiffWithinAt 𝕜 (↑n + 1) (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 (↑n) g s x₀
hgt : t ∈ 𝓝[g '' s] g x₀
hst : insert x₀ s ×ˢ t ∈ 𝓝[(fun x => (x, g x)) '' s] (x₀, g x₀)
v : Set (E × F)
hv : v ∈ 𝓝[insert (x₀, g x₀) (insert x₀ s ×ˢ t)] (x₀, g x₀)
hvs : v ⊆ insert (x₀, g x₀) (insert x₀ s ×ˢ t)
f' : E × F → E × F →L[𝕜] G
hvf' : ∀ (x : E × F), x ∈ v → HasFDerivWithinAt (uncurry f) (f' x) (insert x₀ s ×ˢ t) x
hf' : ContDiffWithinAt 𝕜 (↑↑n) f' (insert x₀ s ×ˢ t) (x₀, g x₀)
z : E
hz : z ∈ (fun z => (z, g z)) ⁻¹' v ∩ insert x₀ s
⊢ HasFDerivWithinAt (f z) ((fun z => ContinuousLinearMap.comp (f' (z, g z)) (ContinuousLinearMap.inr 𝕜 E F)) z) t (g z)
[PROOFSTEP]
have := hvf' (z, g z) hz.1
[GOAL]
case intro.intro.intro.intro.intro.refine'_2
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ
x₀ : E
hf : ContDiffWithinAt 𝕜 (↑n + 1) (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 (↑n) g s x₀
hgt : t ∈ 𝓝[g '' s] g x₀
hst : insert x₀ s ×ˢ t ∈ 𝓝[(fun x => (x, g x)) '' s] (x₀, g x₀)
v : Set (E × F)
hv : v ∈ 𝓝[insert (x₀, g x₀) (insert x₀ s ×ˢ t)] (x₀, g x₀)
hvs : v ⊆ insert (x₀, g x₀) (insert x₀ s ×ˢ t)
f' : E × F → E × F →L[𝕜] G
hvf' : ∀ (x : E × F), x ∈ v → HasFDerivWithinAt (uncurry f) (f' x) (insert x₀ s ×ˢ t) x
hf' : ContDiffWithinAt 𝕜 (↑↑n) f' (insert x₀ s ×ˢ t) (x₀, g x₀)
z : E
hz : z ∈ (fun z => (z, g z)) ⁻¹' v ∩ insert x₀ s
this : HasFDerivWithinAt (uncurry f) (f' (z, g z)) (insert x₀ s ×ˢ t) (z, g z)
⊢ HasFDerivWithinAt (f z) ((fun z => ContinuousLinearMap.comp (f' (z, g z)) (ContinuousLinearMap.inr 𝕜 E F)) z) t (g z)
[PROOFSTEP]
refine' this.comp _ (hasFDerivAt_prod_mk_right _ _).hasFDerivWithinAt _
[GOAL]
case intro.intro.intro.intro.intro.refine'_2
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ
x₀ : E
hf : ContDiffWithinAt 𝕜 (↑n + 1) (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 (↑n) g s x₀
hgt : t ∈ 𝓝[g '' s] g x₀
hst : insert x₀ s ×ˢ t ∈ 𝓝[(fun x => (x, g x)) '' s] (x₀, g x₀)
v : Set (E × F)
hv : v ∈ 𝓝[insert (x₀, g x₀) (insert x₀ s ×ˢ t)] (x₀, g x₀)
hvs : v ⊆ insert (x₀, g x₀) (insert x₀ s ×ˢ t)
f' : E × F → E × F →L[𝕜] G
hvf' : ∀ (x : E × F), x ∈ v → HasFDerivWithinAt (uncurry f) (f' x) (insert x₀ s ×ˢ t) x
hf' : ContDiffWithinAt 𝕜 (↑↑n) f' (insert x₀ s ×ˢ t) (x₀, g x₀)
z : E
hz : z ∈ (fun z => (z, g z)) ⁻¹' v ∩ insert x₀ s
this : HasFDerivWithinAt (uncurry f) (f' (z, g z)) (insert x₀ s ×ˢ t) (z, g z)
⊢ MapsTo (Prod.mk z) t (insert x₀ s ×ˢ t)
[PROOFSTEP]
exact mapsTo'.mpr (image_prod_mk_subset_prod_right hz.2)
[GOAL]
case intro.intro.intro.intro.intro.refine'_3
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ
x₀ : E
hf : ContDiffWithinAt 𝕜 (↑n + 1) (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 (↑n) g s x₀
hgt : t ∈ 𝓝[g '' s] g x₀
hst : insert x₀ s ×ˢ t ∈ 𝓝[(fun x => (x, g x)) '' s] (x₀, g x₀)
v : Set (E × F)
hv : v ∈ 𝓝[insert (x₀, g x₀) (insert x₀ s ×ˢ t)] (x₀, g x₀)
hvs : v ⊆ insert (x₀, g x₀) (insert x₀ s ×ˢ t)
f' : E × F → E × F →L[𝕜] G
hvf' : ∀ (x : E × F), x ∈ v → HasFDerivWithinAt (uncurry f) (f' x) (insert x₀ s ×ˢ t) x
hf' : ContDiffWithinAt 𝕜 (↑↑n) f' (insert x₀ s ×ˢ t) (x₀, g x₀)
⊢ ContDiffWithinAt 𝕜 (↑n) (fun x => (fun z => ContinuousLinearMap.comp (f' (z, g z)) (ContinuousLinearMap.inr 𝕜 E F)) x)
s x₀
[PROOFSTEP]
exact
(hf'.continuousLinearMap_comp <|
(ContinuousLinearMap.compL 𝕜 F (E × F) G).flip (ContinuousLinearMap.inr 𝕜 E F)).comp_of_mem
x₀ (contDiffWithinAt_id.prod hg) hst
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ∞
hf : ContDiffWithinAt 𝕜 n (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 m g s x₀
ht : ∀ᶠ (x : E) in 𝓝[insert x₀ s] x₀, UniqueDiffWithinAt 𝕜 t (g x)
hmn : m + 1 ≤ n
hgt : t ∈ 𝓝[g '' s] g x₀
⊢ ContDiffWithinAt 𝕜 m (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
[PROOFSTEP]
have : ∀ k : ℕ, (k : ℕ∞) ≤ m → ContDiffWithinAt 𝕜 k (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀ := fun k hkm ↦
by
obtain ⟨v, hv, -, f', hvf', hf'⟩ :=
(hf.of_le <| (add_le_add_right hkm 1).trans hmn).hasFDerivWithinAt_nhds (hg.of_le hkm) hgt
refine hf'.congr_of_eventuallyEq_insert ?_
filter_upwards [hv, ht]
exact fun y hy h2y => (hvf' y hy).fderivWithin h2y
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ∞
hf : ContDiffWithinAt 𝕜 n (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 m g s x₀
ht : ∀ᶠ (x : E) in 𝓝[insert x₀ s] x₀, UniqueDiffWithinAt 𝕜 t (g x)
hmn : m + 1 ≤ n
hgt : t ∈ 𝓝[g '' s] g x₀
k : ℕ
hkm : ↑k ≤ m
⊢ ContDiffWithinAt 𝕜 (↑k) (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
[PROOFSTEP]
obtain ⟨v, hv, -, f', hvf', hf'⟩ :=
(hf.of_le <| (add_le_add_right hkm 1).trans hmn).hasFDerivWithinAt_nhds (hg.of_le hkm) hgt
[GOAL]
case intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ∞
hf : ContDiffWithinAt 𝕜 n (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 m g s x₀
ht : ∀ᶠ (x : E) in 𝓝[insert x₀ s] x₀, UniqueDiffWithinAt 𝕜 t (g x)
hmn : m + 1 ≤ n
hgt : t ∈ 𝓝[g '' s] g x₀
k : ℕ
hkm : ↑k ≤ m
v : Set E
hv : v ∈ 𝓝[insert x₀ s] x₀
f' : E → F →L[𝕜] G
hvf' : ∀ (x : E), x ∈ v → HasFDerivWithinAt (f x) (f' x) t (g x)
hf' : ContDiffWithinAt 𝕜 (↑k) (fun x => f' x) s x₀
⊢ ContDiffWithinAt 𝕜 (↑k) (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
[PROOFSTEP]
refine hf'.congr_of_eventuallyEq_insert ?_
[GOAL]
case intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ∞
hf : ContDiffWithinAt 𝕜 n (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 m g s x₀
ht : ∀ᶠ (x : E) in 𝓝[insert x₀ s] x₀, UniqueDiffWithinAt 𝕜 t (g x)
hmn : m + 1 ≤ n
hgt : t ∈ 𝓝[g '' s] g x₀
k : ℕ
hkm : ↑k ≤ m
v : Set E
hv : v ∈ 𝓝[insert x₀ s] x₀
f' : E → F →L[𝕜] G
hvf' : ∀ (x : E), x ∈ v → HasFDerivWithinAt (f x) (f' x) t (g x)
hf' : ContDiffWithinAt 𝕜 (↑k) (fun x => f' x) s x₀
⊢ (fun x => fderivWithin 𝕜 (f x) t (g x)) =ᶠ[𝓝[insert x₀ s] x₀] fun x => f' x
[PROOFSTEP]
filter_upwards [hv, ht]
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ∞
hf : ContDiffWithinAt 𝕜 n (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 m g s x₀
ht : ∀ᶠ (x : E) in 𝓝[insert x₀ s] x₀, UniqueDiffWithinAt 𝕜 t (g x)
hmn : m + 1 ≤ n
hgt : t ∈ 𝓝[g '' s] g x₀
k : ℕ
hkm : ↑k ≤ m
v : Set E
hv : v ∈ 𝓝[insert x₀ s] x₀
f' : E → F →L[𝕜] G
hvf' : ∀ (x : E), x ∈ v → HasFDerivWithinAt (f x) (f' x) t (g x)
hf' : ContDiffWithinAt 𝕜 (↑k) (fun x => f' x) s x₀
⊢ ∀ (a : E), a ∈ v → UniqueDiffWithinAt 𝕜 t (g a) → fderivWithin 𝕜 (f a) t (g a) = f' a
[PROOFSTEP]
exact fun y hy h2y => (hvf' y hy).fderivWithin h2y
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ∞
hf : ContDiffWithinAt 𝕜 n (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 m g s x₀
ht : ∀ᶠ (x : E) in 𝓝[insert x₀ s] x₀, UniqueDiffWithinAt 𝕜 t (g x)
hmn : m + 1 ≤ n
hgt : t ∈ 𝓝[g '' s] g x₀
this : ∀ (k : ℕ), ↑k ≤ m → ContDiffWithinAt 𝕜 (↑k) (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
⊢ ContDiffWithinAt 𝕜 m (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
[PROOFSTEP]
induction' m using WithTop.recTopCoe with m
[GOAL]
case top
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ∞
hf : ContDiffWithinAt 𝕜 n (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg✝ : ContDiffWithinAt 𝕜 m g s x₀
ht : ∀ᶠ (x : E) in 𝓝[insert x₀ s] x₀, UniqueDiffWithinAt 𝕜 t (g x)
hmn✝ : m + 1 ≤ n
hgt : t ∈ 𝓝[g '' s] g x₀
this✝ : ∀ (k : ℕ), ↑k ≤ m → ContDiffWithinAt 𝕜 (↑k) (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
hg : ContDiffWithinAt 𝕜 ⊤ g s x₀
hmn : ⊤ + 1 ≤ n
this : ∀ (k : ℕ), ↑k ≤ ⊤ → ContDiffWithinAt 𝕜 (↑k) (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
⊢ ContDiffWithinAt 𝕜 ⊤ (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
[PROOFSTEP]
obtain rfl := eq_top_iff.mpr hmn
[GOAL]
case top
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
hg✝ : ContDiffWithinAt 𝕜 m g s x₀
ht : ∀ᶠ (x : E) in 𝓝[insert x₀ s] x₀, UniqueDiffWithinAt 𝕜 t (g x)
hgt : t ∈ 𝓝[g '' s] g x₀
this✝ : ∀ (k : ℕ), ↑k ≤ m → ContDiffWithinAt 𝕜 (↑k) (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
hg : ContDiffWithinAt 𝕜 ⊤ g s x₀
this : ∀ (k : ℕ), ↑k ≤ ⊤ → ContDiffWithinAt 𝕜 (↑k) (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
hf : ContDiffWithinAt 𝕜 ⊤ (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hmn✝ : m + 1 ≤ ⊤
hmn : ⊤ + 1 ≤ ⊤
⊢ ContDiffWithinAt 𝕜 ⊤ (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
[PROOFSTEP]
rw [contDiffWithinAt_top]
[GOAL]
case top
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
hg✝ : ContDiffWithinAt 𝕜 m g s x₀
ht : ∀ᶠ (x : E) in 𝓝[insert x₀ s] x₀, UniqueDiffWithinAt 𝕜 t (g x)
hgt : t ∈ 𝓝[g '' s] g x₀
this✝ : ∀ (k : ℕ), ↑k ≤ m → ContDiffWithinAt 𝕜 (↑k) (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
hg : ContDiffWithinAt 𝕜 ⊤ g s x₀
this : ∀ (k : ℕ), ↑k ≤ ⊤ → ContDiffWithinAt 𝕜 (↑k) (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
hf : ContDiffWithinAt 𝕜 ⊤ (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hmn✝ : m + 1 ≤ ⊤
hmn : ⊤ + 1 ≤ ⊤
⊢ ∀ (n : ℕ), ContDiffWithinAt 𝕜 (↑n) (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
[PROOFSTEP]
exact fun m => this m le_top
[GOAL]
case coe
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ∞
hf : ContDiffWithinAt 𝕜 n (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg✝ : ContDiffWithinAt 𝕜 m✝ g s x₀
ht : ∀ᶠ (x : E) in 𝓝[insert x₀ s] x₀, UniqueDiffWithinAt 𝕜 t (g x)
hmn✝ : m✝ + 1 ≤ n
hgt : t ∈ 𝓝[g '' s] g x₀
this✝ : ∀ (k : ℕ), ↑k ≤ m✝ → ContDiffWithinAt 𝕜 (↑k) (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
m : ℕ
hg : ContDiffWithinAt 𝕜 (↑m) g s x₀
hmn : ↑m + 1 ≤ n
this : ∀ (k : ℕ), ↑k ≤ ↑m → ContDiffWithinAt 𝕜 (↑k) (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
⊢ ContDiffWithinAt 𝕜 (↑m) (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
[PROOFSTEP]
exact this _ le_rfl
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ∞
hf : ContDiffWithinAt 𝕜 n (uncurry f) (s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 m g s x₀
ht : UniqueDiffOn 𝕜 t
hmn : m + 1 ≤ n
hx₀ : x₀ ∈ s
hst : s ⊆ g ⁻¹' t
⊢ ContDiffWithinAt 𝕜 m (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
[PROOFSTEP]
rw [← insert_eq_self.mpr hx₀] at hf
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ∞
hf : ContDiffWithinAt 𝕜 n (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 m g s x₀
ht : UniqueDiffOn 𝕜 t
hmn : m + 1 ≤ n
hx₀ : x₀ ∈ s
hst : s ⊆ g ⁻¹' t
⊢ ContDiffWithinAt 𝕜 m (fun x => fderivWithin 𝕜 (f x) t (g x)) s x₀
[PROOFSTEP]
refine' hf.fderivWithin' hg _ hmn hst
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ∞
hf : ContDiffWithinAt 𝕜 n (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 m g s x₀
ht : UniqueDiffOn 𝕜 t
hmn : m + 1 ≤ n
hx₀ : x₀ ∈ s
hst : s ⊆ g ⁻¹' t
⊢ ∀ᶠ (x : E) in 𝓝[insert x₀ s] x₀, UniqueDiffWithinAt 𝕜 t (g x)
[PROOFSTEP]
rw [insert_eq_self.mpr hx₀]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
t : Set F
n : ℕ∞
hf : ContDiffWithinAt 𝕜 n (uncurry f) (insert x₀ s ×ˢ t) (x₀, g x₀)
hg : ContDiffWithinAt 𝕜 m g s x₀
ht : UniqueDiffOn 𝕜 t
hmn : m + 1 ≤ n
hx₀ : x₀ ∈ s
hst : s ⊆ g ⁻¹' t
⊢ ∀ᶠ (x : E) in 𝓝[s] x₀, UniqueDiffWithinAt 𝕜 t (g x)
[PROOFSTEP]
exact eventually_of_mem self_mem_nhdsWithin fun x hx => ht _ (hst hx)
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : ContDiffWithinAt 𝕜 n f s x₀
hs : UniqueDiffOn 𝕜 s
hmn : m + 1 ≤ n
hx₀s : x₀ ∈ s
⊢ s ⊆ (fun x => x) ⁻¹' s
[PROOFSTEP]
rw [preimage_id']
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i : ℕ
hf : ContDiffWithinAt 𝕜 n f s x₀
hs : UniqueDiffOn 𝕜 s
hmn : m + ↑i ≤ n
hx₀s : x₀ ∈ s
⊢ ContDiffWithinAt 𝕜 m (iteratedFDerivWithin 𝕜 i f s) s x₀
[PROOFSTEP]
induction' i with i hi generalizing m
[GOAL]
case zero
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i : ℕ
hf : ContDiffWithinAt 𝕜 n f s x₀
hs : UniqueDiffOn 𝕜 s
hmn✝ : m✝ + ↑i ≤ n
hx₀s : x₀ ∈ s
m : ℕ∞
hmn : m + ↑Nat.zero ≤ n
⊢ ContDiffWithinAt 𝕜 m (iteratedFDerivWithin 𝕜 Nat.zero f s) s x₀
[PROOFSTEP]
rw [Nat.zero_eq, ENat.coe_zero, add_zero] at hmn
[GOAL]
case zero
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i : ℕ
hf : ContDiffWithinAt 𝕜 n f s x₀
hs : UniqueDiffOn 𝕜 s
hmn✝ : m✝ + ↑i ≤ n
hx₀s : x₀ ∈ s
m : ℕ∞
hmn : m ≤ n
⊢ ContDiffWithinAt 𝕜 m (iteratedFDerivWithin 𝕜 Nat.zero f s) s x₀
[PROOFSTEP]
exact (hf.of_le hmn).continuousLinearMap_comp ((continuousMultilinearCurryFin0 𝕜 E F).symm : _ →L[𝕜] E[×0]→L[𝕜] F)
[GOAL]
case succ
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i✝ : ℕ
hf : ContDiffWithinAt 𝕜 n f s x₀
hs : UniqueDiffOn 𝕜 s
hmn✝ : m✝ + ↑i✝ ≤ n
hx₀s : x₀ ∈ s
i : ℕ
hi : ∀ {m : ℕ∞}, m + ↑i ≤ n → ContDiffWithinAt 𝕜 m (iteratedFDerivWithin 𝕜 i f s) s x₀
m : ℕ∞
hmn : m + ↑(Nat.succ i) ≤ n
⊢ ContDiffWithinAt 𝕜 m (iteratedFDerivWithin 𝕜 (Nat.succ i) f s) s x₀
[PROOFSTEP]
rw [Nat.cast_succ, add_comm _ 1, ← add_assoc] at hmn
[GOAL]
case succ
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i✝ : ℕ
hf : ContDiffWithinAt 𝕜 n f s x₀
hs : UniqueDiffOn 𝕜 s
hmn✝ : m✝ + ↑i✝ ≤ n
hx₀s : x₀ ∈ s
i : ℕ
hi : ∀ {m : ℕ∞}, m + ↑i ≤ n → ContDiffWithinAt 𝕜 m (iteratedFDerivWithin 𝕜 i f s) s x₀
m : ℕ∞
hmn : m + 1 + ↑i ≤ n
⊢ ContDiffWithinAt 𝕜 m (iteratedFDerivWithin 𝕜 (Nat.succ i) f s) s x₀
[PROOFSTEP]
exact
((hi hmn).fderivWithin_right hs le_rfl hx₀s).continuousLinearMap_comp
(continuousMultilinearCurryLeftEquiv 𝕜 (fun _ : Fin (i + 1) ↦ E) F : _ →L[𝕜] E[×(i + 1)]→L[𝕜] F)
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
n : ℕ∞
hf : ContDiffAt 𝕜 n (uncurry f) (x₀, g x₀)
hg : ContDiffAt 𝕜 m g x₀
hmn : m + 1 ≤ n
⊢ ContDiffAt 𝕜 m (fun x => fderiv 𝕜 (f x) (g x)) x₀
[PROOFSTEP]
simp_rw [← fderivWithin_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
n : ℕ∞
hf : ContDiffAt 𝕜 n (uncurry f) (x₀, g x₀)
hg : ContDiffAt 𝕜 m g x₀
hmn : m + 1 ≤ n
⊢ ContDiffAt 𝕜 m (fun x => fderivWithin 𝕜 (f x) univ (g x)) x₀
[PROOFSTEP]
refine
(ContDiffWithinAt.fderivWithin hf.contDiffWithinAt hg.contDiffWithinAt uniqueDiffOn_univ hmn (mem_univ x₀)
?_).contDiffAt
univ_mem
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F → G
g : E → F
n : ℕ∞
hf : ContDiffAt 𝕜 n (uncurry f) (x₀, g x₀)
hg : ContDiffAt 𝕜 m g x₀
hmn : m + 1 ≤ n
⊢ univ ⊆ g ⁻¹' univ
[PROOFSTEP]
rw [preimage_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i : ℕ
hf : ContDiffAt 𝕜 n f x₀
hmn : m + ↑i ≤ n
⊢ ContDiffAt 𝕜 m (iteratedFDeriv 𝕜 i f) x₀
[PROOFSTEP]
rw [← iteratedFDerivWithin_univ, ← contDiffWithinAt_univ] at *
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i : ℕ
hf : ContDiffWithinAt 𝕜 n f univ x₀
hmn : m + ↑i ≤ n
⊢ ContDiffWithinAt 𝕜 m (iteratedFDerivWithin 𝕜 i f univ) univ x₀
[PROOFSTEP]
exact hf.iteratedFderivWithin_right uniqueDiffOn_univ hmn trivial
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
hf : ContDiffOn 𝕜 n f s
hs : UniqueDiffOn 𝕜 s
hn : 1 ≤ n
⊢ ?m.1105459 hf hs hn + 1 ≤ n
[PROOFSTEP]
rwa [zero_add]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F
hf : ContDiff 𝕜 n f
hmn : m + 1 ≤ n
⊢ ContDiff 𝕜 m fun p => ↑(fderiv 𝕜 f p.fst) p.snd
[PROOFSTEP]
rw [← contDiffOn_univ] at hf ⊢
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F
hf : ContDiffOn 𝕜 n f univ
hmn : m + 1 ≤ n
⊢ ContDiffOn 𝕜 m (fun p => ↑(fderiv 𝕜 f p.fst) p.snd) univ
[PROOFSTEP]
rw [← fderivWithin_univ, ← univ_prod_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F
hf : ContDiffOn 𝕜 n f univ
hmn : m + 1 ≤ n
⊢ ContDiffOn 𝕜 m (fun p => ↑(fderivWithin 𝕜 f univ p.fst) p.snd) (univ ×ˢ univ)
[PROOFSTEP]
exact contDiffOn_fderivWithin_apply hf uniqueDiffOn_univ hmn
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
⊢ HasFTaylorSeriesUpToOn n (fun x i => φ i x) (fun x m => ContinuousMultilinearMap.pi fun i => p' i x m) s ↔
∀ (i : ι), HasFTaylorSeriesUpToOn n (φ i) (p' i) s
[PROOFSTEP]
set pr := @ContinuousLinearMap.proj 𝕜 _ ι F' _ _ _
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
pr : (i : ι) → ((i : ι) → F' i) →L[𝕜] F' i := ContinuousLinearMap.proj
⊢ HasFTaylorSeriesUpToOn n (fun x i => φ i x) (fun x m => ContinuousMultilinearMap.pi fun i => p' i x m) s ↔
∀ (i : ι), HasFTaylorSeriesUpToOn n (φ i) (p' i) s
[PROOFSTEP]
letI : ∀ (m : ℕ) (i : ι), NormedSpace 𝕜 (E[×m]→L[𝕜] F' i) := fun m i => inferInstance
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
pr : (i : ι) → ((i : ι) → F' i) →L[𝕜] F' i := ContinuousLinearMap.proj
this : (m : ℕ) → (i : ι) → NormedSpace 𝕜 (ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) := fun m i => inferInstance
⊢ HasFTaylorSeriesUpToOn n (fun x i => φ i x) (fun x m => ContinuousMultilinearMap.pi fun i => p' i x m) s ↔
∀ (i : ι), HasFTaylorSeriesUpToOn n (φ i) (p' i) s
[PROOFSTEP]
set L : ∀ m : ℕ, (∀ i, E[×m]→L[𝕜] F' i) ≃ₗᵢ[𝕜] E[×m]→L[𝕜] ∀ i, F' i := fun m => ContinuousMultilinearMap.piₗᵢ _ _
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
pr : (i : ι) → ((i : ι) → F' i) →L[𝕜] F' i := ContinuousLinearMap.proj
this : (m : ℕ) → (i : ι) → NormedSpace 𝕜 (ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) := fun m i => inferInstance
L : (m : ℕ) →
((i : ι) → ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) ≃ₗᵢ[𝕜]
ContinuousMultilinearMap 𝕜 (fun i => E) ((i : ι) → F' i) :=
fun m => ContinuousMultilinearMap.piₗᵢ 𝕜 fun i => E
⊢ HasFTaylorSeriesUpToOn n (fun x i => φ i x) (fun x m => ContinuousMultilinearMap.pi fun i => p' i x m) s ↔
∀ (i : ι), HasFTaylorSeriesUpToOn n (φ i) (p' i) s
[PROOFSTEP]
refine' ⟨fun h i => _, fun h => ⟨fun x hx => _, _, _⟩⟩
[GOAL]
case refine'_1
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
pr : (i : ι) → ((i : ι) → F' i) →L[𝕜] F' i := ContinuousLinearMap.proj
this : (m : ℕ) → (i : ι) → NormedSpace 𝕜 (ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) := fun m i => inferInstance
L : (m : ℕ) →
((i : ι) → ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) ≃ₗᵢ[𝕜]
ContinuousMultilinearMap 𝕜 (fun i => E) ((i : ι) → F' i) :=
fun m => ContinuousMultilinearMap.piₗᵢ 𝕜 fun i => E
h : HasFTaylorSeriesUpToOn n (fun x i => φ i x) (fun x m => ContinuousMultilinearMap.pi fun i => p' i x m) s
i : ι
⊢ HasFTaylorSeriesUpToOn n (φ i) (p' i) s
[PROOFSTEP]
convert h.continuousLinearMap_comp (pr i)
[GOAL]
case refine'_2
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
pr : (i : ι) → ((i : ι) → F' i) →L[𝕜] F' i := ContinuousLinearMap.proj
this : (m : ℕ) → (i : ι) → NormedSpace 𝕜 (ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) := fun m i => inferInstance
L : (m : ℕ) →
((i : ι) → ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) ≃ₗᵢ[𝕜]
ContinuousMultilinearMap 𝕜 (fun i => E) ((i : ι) → F' i) :=
fun m => ContinuousMultilinearMap.piₗᵢ 𝕜 fun i => E
h : ∀ (i : ι), HasFTaylorSeriesUpToOn n (φ i) (p' i) s
x : E
hx : x ∈ s
⊢ ContinuousMultilinearMap.uncurry0 (ContinuousMultilinearMap.pi fun i => p' i x 0) = fun i => φ i x
[PROOFSTEP]
ext1 i
[GOAL]
case refine'_2.h
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
pr : (i : ι) → ((i : ι) → F' i) →L[𝕜] F' i := ContinuousLinearMap.proj
this : (m : ℕ) → (i : ι) → NormedSpace 𝕜 (ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) := fun m i => inferInstance
L : (m : ℕ) →
((i : ι) → ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) ≃ₗᵢ[𝕜]
ContinuousMultilinearMap 𝕜 (fun i => E) ((i : ι) → F' i) :=
fun m => ContinuousMultilinearMap.piₗᵢ 𝕜 fun i => E
h : ∀ (i : ι), HasFTaylorSeriesUpToOn n (φ i) (p' i) s
x : E
hx : x ∈ s
i : ι
⊢ ContinuousMultilinearMap.uncurry0 (ContinuousMultilinearMap.pi fun i => p' i x 0) i = φ i x
[PROOFSTEP]
exact (h i).zero_eq x hx
[GOAL]
case refine'_3
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
pr : (i : ι) → ((i : ι) → F' i) →L[𝕜] F' i := ContinuousLinearMap.proj
this : (m : ℕ) → (i : ι) → NormedSpace 𝕜 (ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) := fun m i => inferInstance
L : (m : ℕ) →
((i : ι) → ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) ≃ₗᵢ[𝕜]
ContinuousMultilinearMap 𝕜 (fun i => E) ((i : ι) → F' i) :=
fun m => ContinuousMultilinearMap.piₗᵢ 𝕜 fun i => E
h : ∀ (i : ι), HasFTaylorSeriesUpToOn n (φ i) (p' i) s
⊢ ∀ (m : ℕ),
↑m < n →
∀ (x : E),
x ∈ s →
HasFDerivWithinAt (fun x => ContinuousMultilinearMap.pi fun i => p' i x m)
(ContinuousMultilinearMap.curryLeft (ContinuousMultilinearMap.pi fun i => p' i x (Nat.succ m))) s x
[PROOFSTEP]
intro m hm x hx
[GOAL]
case refine'_3
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
pr : (i : ι) → ((i : ι) → F' i) →L[𝕜] F' i := ContinuousLinearMap.proj
this : (m : ℕ) → (i : ι) → NormedSpace 𝕜 (ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) := fun m i => inferInstance
L : (m : ℕ) →
((i : ι) → ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) ≃ₗᵢ[𝕜]
ContinuousMultilinearMap 𝕜 (fun i => E) ((i : ι) → F' i) :=
fun m => ContinuousMultilinearMap.piₗᵢ 𝕜 fun i => E
h : ∀ (i : ι), HasFTaylorSeriesUpToOn n (φ i) (p' i) s
m : ℕ
hm : ↑m < n
x : E
hx : x ∈ s
⊢ HasFDerivWithinAt (fun x => ContinuousMultilinearMap.pi fun i => p' i x m)
(ContinuousMultilinearMap.curryLeft (ContinuousMultilinearMap.pi fun i => p' i x (Nat.succ m))) s x
[PROOFSTEP]
have := hasFDerivWithinAt_pi.2 fun i => (h i).fderivWithin m hm x hx
[GOAL]
case refine'_3
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
pr : (i : ι) → ((i : ι) → F' i) →L[𝕜] F' i := ContinuousLinearMap.proj
this✝ : (m : ℕ) → (i : ι) → NormedSpace 𝕜 (ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) := fun m i => inferInstance
L : (m : ℕ) →
((i : ι) → ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) ≃ₗᵢ[𝕜]
ContinuousMultilinearMap 𝕜 (fun i => E) ((i : ι) → F' i) :=
fun m => ContinuousMultilinearMap.piₗᵢ 𝕜 fun i => E
h : ∀ (i : ι), HasFTaylorSeriesUpToOn n (φ i) (p' i) s
m : ℕ
hm : ↑m < n
x : E
hx : x ∈ s
this :
HasFDerivWithinAt (fun x i => p' i x m)
(ContinuousLinearMap.pi fun i => ContinuousMultilinearMap.curryLeft (p' i x (Nat.succ m))) s x
⊢ HasFDerivWithinAt (fun x => ContinuousMultilinearMap.pi fun i => p' i x m)
(ContinuousMultilinearMap.curryLeft (ContinuousMultilinearMap.pi fun i => p' i x (Nat.succ m))) s x
[PROOFSTEP]
convert (L m).hasFDerivAt.comp_hasFDerivWithinAt x this
[GOAL]
case refine'_4
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
pr : (i : ι) → ((i : ι) → F' i) →L[𝕜] F' i := ContinuousLinearMap.proj
this : (m : ℕ) → (i : ι) → NormedSpace 𝕜 (ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) := fun m i => inferInstance
L : (m : ℕ) →
((i : ι) → ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) ≃ₗᵢ[𝕜]
ContinuousMultilinearMap 𝕜 (fun i => E) ((i : ι) → F' i) :=
fun m => ContinuousMultilinearMap.piₗᵢ 𝕜 fun i => E
h : ∀ (i : ι), HasFTaylorSeriesUpToOn n (φ i) (p' i) s
⊢ ∀ (m : ℕ), ↑m ≤ n → ContinuousOn (fun x => ContinuousMultilinearMap.pi fun i => p' i x m) s
[PROOFSTEP]
intro m hm
[GOAL]
case refine'_4
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
pr : (i : ι) → ((i : ι) → F' i) →L[𝕜] F' i := ContinuousLinearMap.proj
this : (m : ℕ) → (i : ι) → NormedSpace 𝕜 (ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) := fun m i => inferInstance
L : (m : ℕ) →
((i : ι) → ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) ≃ₗᵢ[𝕜]
ContinuousMultilinearMap 𝕜 (fun i => E) ((i : ι) → F' i) :=
fun m => ContinuousMultilinearMap.piₗᵢ 𝕜 fun i => E
h : ∀ (i : ι), HasFTaylorSeriesUpToOn n (φ i) (p' i) s
m : ℕ
hm : ↑m ≤ n
⊢ ContinuousOn (fun x => ContinuousMultilinearMap.pi fun i => p' i x m) s
[PROOFSTEP]
have := continuousOn_pi.2 fun i => (h i).cont m hm
[GOAL]
case refine'_4
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
pr : (i : ι) → ((i : ι) → F' i) →L[𝕜] F' i := ContinuousLinearMap.proj
this✝ : (m : ℕ) → (i : ι) → NormedSpace 𝕜 (ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) := fun m i => inferInstance
L : (m : ℕ) →
((i : ι) → ContinuousMultilinearMap 𝕜 (fun i => E) (F' i)) ≃ₗᵢ[𝕜]
ContinuousMultilinearMap 𝕜 (fun i => E) ((i : ι) → F' i) :=
fun m => ContinuousMultilinearMap.piₗᵢ 𝕜 fun i => E
h : ∀ (i : ι), HasFTaylorSeriesUpToOn n (φ i) (p' i) s
m : ℕ
hm : ↑m ≤ n
this : ContinuousOn (fun y i => p' i y m) s
⊢ ContinuousOn (fun x => ContinuousMultilinearMap.pi fun i => p' i x m) s
[PROOFSTEP]
convert (L m).continuous.comp_continuousOn this
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
⊢ HasFTaylorSeriesUpToOn n Φ P' s ↔
∀ (i : ι),
HasFTaylorSeriesUpToOn n (fun x => Φ x i)
(fun x m => ContinuousLinearMap.compContinuousMultilinearMap (ContinuousLinearMap.proj i) (P' x m)) s
[PROOFSTEP]
convert hasFTaylorSeriesUpToOn_pi (𝕜 := 𝕜) (φ := fun i x ↦ Φ x i)
[GOAL]
case h.e'_1.h.e'_11.h.h
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
x✝¹ : E
x✝ : ℕ
⊢ P' x✝¹ x✝ =
ContinuousMultilinearMap.pi fun i =>
ContinuousLinearMap.compContinuousMultilinearMap (ContinuousLinearMap.proj i) (P' x✝¹ x✝)
[PROOFSTEP]
ext
[GOAL]
case h.e'_1.h.e'_11.h.h.H.h
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
x✝³ : E
x✝² : ℕ
x✝¹ : Fin x✝² → E
x✝ : ι
⊢ ↑(P' x✝³ x✝²) x✝¹ x✝ =
↑(ContinuousMultilinearMap.pi fun i =>
ContinuousLinearMap.compContinuousMultilinearMap (ContinuousLinearMap.proj i) (P' x✝³ x✝²))
x✝¹ x✝
[PROOFSTEP]
rfl
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
⊢ ContDiffWithinAt 𝕜 n Φ s x ↔ ∀ (i : ι), ContDiffWithinAt 𝕜 n (fun x => Φ x i) s x
[PROOFSTEP]
set pr := @ContinuousLinearMap.proj 𝕜 _ ι F' _ _ _
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
pr : (i : ι) → ((i : ι) → F' i) →L[𝕜] F' i := ContinuousLinearMap.proj
⊢ ContDiffWithinAt 𝕜 n Φ s x ↔ ∀ (i : ι), ContDiffWithinAt 𝕜 n (fun x => Φ x i) s x
[PROOFSTEP]
refine' ⟨fun h i => h.continuousLinearMap_comp (pr i), fun h m hm => _⟩
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
pr : (i : ι) → ((i : ι) → F' i) →L[𝕜] F' i := ContinuousLinearMap.proj
h : ∀ (i : ι), ContDiffWithinAt 𝕜 n (fun x => Φ x i) s x
m : ℕ
hm : ↑m ≤ n
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) Φ p u
[PROOFSTEP]
choose u hux p hp using fun i => h i m hm
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
pr : (i : ι) → ((i : ι) → F' i) →L[𝕜] F' i := ContinuousLinearMap.proj
h : ∀ (i : ι), ContDiffWithinAt 𝕜 n (fun x => Φ x i) s x
m : ℕ
hm : ↑m ≤ n
u : ι → Set E
hux : ∀ (i : ι), u i ∈ 𝓝[insert x s] x
p : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
hp : ∀ (i : ι), HasFTaylorSeriesUpToOn (↑m) (fun x => Φ x i) (p i) (u i)
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) Φ p u
[PROOFSTEP]
exact ⟨⋂ i, u i, Filter.iInter_mem.2 hux, _, hasFTaylorSeriesUpToOn_pi.2 fun i => (hp i).mono <| iInter_subset _ _⟩
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
ι : Type u_3
ι' : Type u_4
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_5
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
⊢ ContDiff 𝕜 n Φ ↔ ∀ (i : ι), ContDiff 𝕜 n fun x => Φ x i
[PROOFSTEP]
simp only [← contDiffOn_univ, contDiffOn_pi]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
q : E → FormalMultilinearSeries 𝕜 E F
g : E → F
hf : HasFTaylorSeriesUpToOn n f p s
hg : HasFTaylorSeriesUpToOn n g q s
⊢ HasFTaylorSeriesUpToOn n (f + g) (p + q) s
[PROOFSTEP]
convert
HasFTaylorSeriesUpToOn.continuousLinearMap_comp (ContinuousLinearMap.fst 𝕜 F F + .snd 𝕜 F F)
(hf.prod hg)
-- The sum is smooth.
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f g : E → F
hf : ContDiffAt 𝕜 n f x
hg : ContDiffAt 𝕜 n g x
⊢ ContDiffAt 𝕜 n (fun x => f x + g x) x
[PROOFSTEP]
rw [← contDiffWithinAt_univ] at *
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f g : E → F
hf : ContDiffWithinAt 𝕜 n f univ x
hg : ContDiffWithinAt 𝕜 n g univ x
⊢ ContDiffWithinAt 𝕜 n (fun x => f x + g x) univ x
[PROOFSTEP]
exact hf.add hg
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i✝ i : ℕ
f g : E → F
hf : ContDiff 𝕜 (↑i) f
hg : ContDiff 𝕜 (↑i) g
⊢ iteratedFDeriv 𝕜 i (f + g) x = iteratedFDeriv 𝕜 i f x + iteratedFDeriv 𝕜 i g x
[PROOFSTEP]
simp_rw [← contDiffOn_univ, ← iteratedFDerivWithin_univ] at hf hg ⊢
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i✝ i : ℕ
f g : E → F
hf : ContDiffOn 𝕜 (↑i) f univ
hg : ContDiffOn 𝕜 (↑i) g univ
⊢ iteratedFDerivWithin 𝕜 i (f + g) univ x = iteratedFDerivWithin 𝕜 i f univ x + iteratedFDerivWithin 𝕜 i g univ x
[PROOFSTEP]
exact iteratedFDerivWithin_add_apply hf hg uniqueDiffOn_univ (Set.mem_univ _)
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F
hf : ContDiffAt 𝕜 n f x
⊢ ContDiffAt 𝕜 n (fun x => -f x) x
[PROOFSTEP]
rw [← contDiffWithinAt_univ] at *
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F
hf : ContDiffWithinAt 𝕜 n f univ x
⊢ ContDiffWithinAt 𝕜 n (fun x => -f x) univ x
[PROOFSTEP]
exact hf.neg
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i : ℕ
f : E → F
hu : UniqueDiffOn 𝕜 s
hx : x ∈ s
⊢ iteratedFDerivWithin 𝕜 i (-f) s x = -iteratedFDerivWithin 𝕜 i f s x
[PROOFSTEP]
induction' i with i hi generalizing x
[GOAL]
case zero
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i : ℕ
f : E → F
hu : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
x : E
hx : x ∈ s
⊢ iteratedFDerivWithin 𝕜 Nat.zero (-f) s x = -iteratedFDerivWithin 𝕜 Nat.zero f s x
[PROOFSTEP]
ext
[GOAL]
case zero.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i : ℕ
f : E → F
hu : UniqueDiffOn 𝕜 s
hx✝ : x✝¹ ∈ s
x : E
hx : x ∈ s
x✝ : Fin Nat.zero → E
⊢ ↑(iteratedFDerivWithin 𝕜 Nat.zero (-f) s x) x✝ = ↑(-iteratedFDerivWithin 𝕜 Nat.zero f s x) x✝
[PROOFSTEP]
simp
[GOAL]
case succ
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i✝ : ℕ
f : E → F
hu : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
i : ℕ
hi : ∀ {x : E}, x ∈ s → iteratedFDerivWithin 𝕜 i (-f) s x = -iteratedFDerivWithin 𝕜 i f s x
x : E
hx : x ∈ s
⊢ iteratedFDerivWithin 𝕜 (Nat.succ i) (-f) s x = -iteratedFDerivWithin 𝕜 (Nat.succ i) f s x
[PROOFSTEP]
ext h
[GOAL]
case succ.H
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i✝ : ℕ
f : E → F
hu : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
i : ℕ
hi : ∀ {x : E}, x ∈ s → iteratedFDerivWithin 𝕜 i (-f) s x = -iteratedFDerivWithin 𝕜 i f s x
x : E
hx : x ∈ s
h : Fin (Nat.succ i) → E
⊢ ↑(iteratedFDerivWithin 𝕜 (Nat.succ i) (-f) s x) h = ↑(-iteratedFDerivWithin 𝕜 (Nat.succ i) f s x) h
[PROOFSTEP]
calc
iteratedFDerivWithin 𝕜 (i + 1) (-f) s x h = fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i (-f) s) s x (h 0) (Fin.tail h) :=
rfl
_ = fderivWithin 𝕜 (-iteratedFDerivWithin 𝕜 i f s) s x (h 0) (Fin.tail h) := by rw [fderivWithin_congr' (@hi) hx]; rfl
_ = -(fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i f s) s) x (h 0) (Fin.tail h) := by
rw [Pi.neg_def, fderivWithin_neg (hu x hx)]; rfl
_ = -(iteratedFDerivWithin 𝕜 (i + 1) f s) x h := rfl
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i✝ : ℕ
f : E → F
hu : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
i : ℕ
hi : ∀ {x : E}, x ∈ s → iteratedFDerivWithin 𝕜 i (-f) s x = -iteratedFDerivWithin 𝕜 i f s x
x : E
hx : x ∈ s
h : Fin (Nat.succ i) → E
⊢ ↑(↑(fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i (-f) s) s x) (h 0)) (tail h) =
↑(↑(fderivWithin 𝕜 (-iteratedFDerivWithin 𝕜 i f s) s x) (h 0)) (tail h)
[PROOFSTEP]
rw [fderivWithin_congr' (@hi) hx]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i✝ : ℕ
f : E → F
hu : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
i : ℕ
hi : ∀ {x : E}, x ∈ s → iteratedFDerivWithin 𝕜 i (-f) s x = -iteratedFDerivWithin 𝕜 i f s x
x : E
hx : x ∈ s
h : Fin (Nat.succ i) → E
⊢ ↑(↑(fderivWithin 𝕜 (fun x => -iteratedFDerivWithin 𝕜 i f s x) s x) (h 0)) (tail h) =
↑(↑(fderivWithin 𝕜 (-iteratedFDerivWithin 𝕜 i f s) s x) (h 0)) (tail h)
[PROOFSTEP]
rfl
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i✝ : ℕ
f : E → F
hu : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
i : ℕ
hi : ∀ {x : E}, x ∈ s → iteratedFDerivWithin 𝕜 i (-f) s x = -iteratedFDerivWithin 𝕜 i f s x
x : E
hx : x ∈ s
h : Fin (Nat.succ i) → E
⊢ ↑(↑(fderivWithin 𝕜 (-iteratedFDerivWithin 𝕜 i f s) s x) (h 0)) (tail h) =
-↑(↑(fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i f s) s x) (h 0)) (tail h)
[PROOFSTEP]
rw [Pi.neg_def, fderivWithin_neg (hu x hx)]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i✝ : ℕ
f : E → F
hu : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
i : ℕ
hi : ∀ {x : E}, x ∈ s → iteratedFDerivWithin 𝕜 i (-f) s x = -iteratedFDerivWithin 𝕜 i f s x
x : E
hx : x ∈ s
h : Fin (Nat.succ i) → E
⊢ ↑(↑(-fderivWithin 𝕜 (fun i_1 => iteratedFDerivWithin 𝕜 i f s i_1) s x) (h 0)) (tail h) =
-↑(↑(fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 i f s) s x) (h 0)) (tail h)
[PROOFSTEP]
rfl
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i✝ i : ℕ
f : E → F
⊢ iteratedFDeriv 𝕜 i (-f) x = -iteratedFDeriv 𝕜 i f x
[PROOFSTEP]
simp_rw [← iteratedFDerivWithin_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
i✝ i : ℕ
f : E → F
⊢ iteratedFDerivWithin 𝕜 i (-f) univ x = -iteratedFDerivWithin 𝕜 i f univ x
[PROOFSTEP]
exact iteratedFDerivWithin_neg_apply uniqueDiffOn_univ (Set.mem_univ _)
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
f g : E → F
hf : ContDiffWithinAt 𝕜 n f s x
hg : ContDiffWithinAt 𝕜 n g s x
⊢ ContDiffWithinAt 𝕜 n (fun x => f x - g x) s x
[PROOFSTEP]
simpa only [sub_eq_add_neg] using hf.add hg.neg
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f g : E → F
hf : ContDiffAt 𝕜 n f x
hg : ContDiffAt 𝕜 n g x
⊢ ContDiffAt 𝕜 n (fun x => f x - g x) x
[PROOFSTEP]
simpa only [sub_eq_add_neg] using hf.add hg.neg
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
s : Set E
f g : E → F
hf : ContDiffOn 𝕜 n f s
hg : ContDiffOn 𝕜 n g s
⊢ ContDiffOn 𝕜 n (fun x => f x - g x) s
[PROOFSTEP]
simpa only [sub_eq_add_neg] using hf.add hg.neg
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f g : E → F
hf : ContDiff 𝕜 n f
hg : ContDiff 𝕜 n g
⊢ ContDiff 𝕜 n fun x => f x - g x
[PROOFSTEP]
simpa only [sub_eq_add_neg] using hf.add hg.neg
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
ι : Type u_3
f : ι → E → F
s : Finset ι
t : Set E
x : E
h : ∀ (i : ι), i ∈ s → ContDiffWithinAt 𝕜 n (fun x => f i x) t x
⊢ ContDiffWithinAt 𝕜 n (fun x => ∑ i in s, f i x) t x
[PROOFSTEP]
classical
induction' s using Finset.induction_on with i s is IH
· simp [contDiffWithinAt_const]
· simp only [is, Finset.sum_insert, not_false_iff]
exact (h _ (Finset.mem_insert_self i s)).add (IH fun j hj => h _ (Finset.mem_insert_of_mem hj))
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
ι : Type u_3
f : ι → E → F
s : Finset ι
t : Set E
x : E
h : ∀ (i : ι), i ∈ s → ContDiffWithinAt 𝕜 n (fun x => f i x) t x
⊢ ContDiffWithinAt 𝕜 n (fun x => ∑ i in s, f i x) t x
[PROOFSTEP]
induction' s using Finset.induction_on with i s is IH
[GOAL]
case empty
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
ι : Type u_3
f : ι → E → F
s : Finset ι
t : Set E
x : E
h✝ : ∀ (i : ι), i ∈ s → ContDiffWithinAt 𝕜 n (fun x => f i x) t x
h : ∀ (i : ι), i ∈ ∅ → ContDiffWithinAt 𝕜 n (fun x => f i x) t x
⊢ ContDiffWithinAt 𝕜 n (fun x => ∑ i in ∅, f i x) t x
[PROOFSTEP]
simp [contDiffWithinAt_const]
[GOAL]
case insert
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
ι : Type u_3
f : ι → E → F
s✝ : Finset ι
t : Set E
x : E
h✝ : ∀ (i : ι), i ∈ s✝ → ContDiffWithinAt 𝕜 n (fun x => f i x) t x
i : ι
s : Finset ι
is : ¬i ∈ s
IH :
(∀ (i : ι), i ∈ s → ContDiffWithinAt 𝕜 n (fun x => f i x) t x) → ContDiffWithinAt 𝕜 n (fun x => ∑ i in s, f i x) t x
h : ∀ (i_1 : ι), i_1 ∈ insert i s → ContDiffWithinAt 𝕜 n (fun x => f i_1 x) t x
⊢ ContDiffWithinAt 𝕜 n (fun x => ∑ i in insert i s, f i x) t x
[PROOFSTEP]
simp only [is, Finset.sum_insert, not_false_iff]
[GOAL]
case insert
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
ι : Type u_3
f : ι → E → F
s✝ : Finset ι
t : Set E
x : E
h✝ : ∀ (i : ι), i ∈ s✝ → ContDiffWithinAt 𝕜 n (fun x => f i x) t x
i : ι
s : Finset ι
is : ¬i ∈ s
IH :
(∀ (i : ι), i ∈ s → ContDiffWithinAt 𝕜 n (fun x => f i x) t x) → ContDiffWithinAt 𝕜 n (fun x => ∑ i in s, f i x) t x
h : ∀ (i_1 : ι), i_1 ∈ insert i s → ContDiffWithinAt 𝕜 n (fun x => f i_1 x) t x
⊢ ContDiffWithinAt 𝕜 n (fun x => f i x + ∑ i in s, f i x) t x
[PROOFSTEP]
exact (h _ (Finset.mem_insert_self i s)).add (IH fun j hj => h _ (Finset.mem_insert_of_mem hj))
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
ι : Type u_3
f : ι → E → F
s : Finset ι
x : E
h : ∀ (i : ι), i ∈ s → ContDiffAt 𝕜 n (fun x => f i x) x
⊢ ContDiffAt 𝕜 n (fun x => ∑ i in s, f i x) x
[PROOFSTEP]
rw [← contDiffWithinAt_univ] at *
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
ι : Type u_3
f : ι → E → F
s : Finset ι
x : E
h : ∀ (i : ι), i ∈ s → ContDiffAt 𝕜 n (fun x => f i x) x
⊢ ContDiffWithinAt 𝕜 n (fun x => ∑ i in s, f i x) univ x
[PROOFSTEP]
exact ContDiffWithinAt.sum h
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
ι : Type u_3
f : ι → E → F
s : Finset ι
h : ∀ (i : ι), i ∈ s → ContDiff 𝕜 n fun x => f i x
⊢ ContDiff 𝕜 n fun x => ∑ i in s, f i x
[PROOFSTEP]
simp only [← contDiffOn_univ] at *
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
ι : Type u_3
f : ι → E → F
s : Finset ι
h : ∀ (i : ι), i ∈ s → ContDiffOn 𝕜 n (fun x => f i x) univ
⊢ ContDiffOn 𝕜 n (fun x => ∑ i in s, f i x) univ
[PROOFSTEP]
exact ContDiffOn.sum h
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁵ : NormedAddCommGroup D
inst✝¹⁴ : NormedSpace 𝕜 D
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
𝔸 : Type u_3
𝔸' : Type u_4
ι : Type u_5
𝕜' : Type u_6
inst✝⁵ : NormedRing 𝔸
inst✝⁴ : NormedAlgebra 𝕜 𝔸
inst✝³ : NormedCommRing 𝔸'
inst✝² : NormedAlgebra 𝕜 𝔸'
inst✝¹ : NormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
t : Finset ι
f : ι → E → 𝔸'
h : ∀ (i : ι), i ∈ t → ContDiffWithinAt 𝕜 n (f i) s x
⊢ ContDiffWithinAt 𝕜 n (fun y => ∏ i in t, f i y) s x
[PROOFSTEP]
simpa only [← Finset.prod_apply] using contDiffWithinAt_prod' h
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁵ : NormedAddCommGroup D
inst✝¹⁴ : NormedSpace 𝕜 D
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
𝔸 : Type u_3
𝔸' : Type u_4
ι : Type u_5
𝕜' : Type u_6
inst✝⁵ : NormedRing 𝔸
inst✝⁴ : NormedAlgebra 𝕜 𝔸
inst✝³ : NormedCommRing 𝔸'
inst✝² : NormedAlgebra 𝕜 𝔸'
inst✝¹ : NormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
f : E → 𝔸
hf : ContDiff 𝕜 n f
⊢ ContDiff 𝕜 n fun x => f x ^ 0
[PROOFSTEP]
simpa using contDiff_const
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁵ : NormedAddCommGroup D
inst✝¹⁴ : NormedSpace 𝕜 D
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
𝔸 : Type u_3
𝔸' : Type u_4
ι : Type u_5
𝕜' : Type u_6
inst✝⁵ : NormedRing 𝔸
inst✝⁴ : NormedAlgebra 𝕜 𝔸
inst✝³ : NormedCommRing 𝔸'
inst✝² : NormedAlgebra 𝕜 𝔸'
inst✝¹ : NormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
f : E → 𝔸
hf : ContDiff 𝕜 n f
m : ℕ
⊢ ContDiff 𝕜 n fun x => f x ^ (m + 1)
[PROOFSTEP]
simpa [pow_succ] using hf.mul (hf.pow m)
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁵ : NormedAddCommGroup D
inst✝¹⁴ : NormedSpace 𝕜 D
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
𝔸 : Type u_3
𝔸' : Type u_4
ι : Type u_5
𝕜' : Type u_6
inst✝⁵ : NormedRing 𝔸
inst✝⁴ : NormedAlgebra 𝕜 𝔸
inst✝³ : NormedCommRing 𝔸'
inst✝² : NormedAlgebra 𝕜 𝔸'
inst✝¹ : NormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
f : E → 𝕜'
n : ℕ∞
hf : ContDiffWithinAt 𝕜 n f s x
c : 𝕜'
⊢ ContDiffWithinAt 𝕜 n (fun x => f x / c) s x
[PROOFSTEP]
simpa only [div_eq_mul_inv] using hf.mul contDiffWithinAt_const
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁵ : NormedAddCommGroup D
inst✝¹⁴ : NormedSpace 𝕜 D
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
𝔸 : Type u_3
𝔸' : Type u_4
ι : Type u_5
𝕜' : Type u_6
inst✝⁵ : NormedRing 𝔸
inst✝⁴ : NormedAlgebra 𝕜 𝔸
inst✝³ : NormedCommRing 𝔸'
inst✝² : NormedAlgebra 𝕜 𝔸'
inst✝¹ : NormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
f : E → 𝕜'
n : ℕ∞
hf : ContDiff 𝕜 n f
c : 𝕜'
⊢ ContDiff 𝕜 n fun x => f x / c
[PROOFSTEP]
simpa only [div_eq_mul_inv] using hf.mul contDiff_const
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → 𝕜
g : E → F
hf : ContDiffAt 𝕜 n f x
hg : ContDiffAt 𝕜 n g x
⊢ ContDiffAt 𝕜 n (fun x => f x • g x) x
[PROOFSTEP]
rw [← contDiffWithinAt_univ] at *
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → 𝕜
g : E → F
hf : ContDiffWithinAt 𝕜 n f univ x
hg : ContDiffWithinAt 𝕜 n g univ x
⊢ ContDiffWithinAt 𝕜 n (fun x => f x • g x) univ x
[PROOFSTEP]
exact hf.smul hg
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
R : Type u_3
inst✝³ : Semiring R
inst✝² : Module R F
inst✝¹ : SMulCommClass 𝕜 R F
inst✝ : ContinuousConstSMul R F
f : E → F
x : E
c : R
hf : ContDiffAt 𝕜 n f x
⊢ ContDiffAt 𝕜 n (fun y => c • f y) x
[PROOFSTEP]
rw [← contDiffWithinAt_univ] at *
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
R : Type u_3
inst✝³ : Semiring R
inst✝² : Module R F
inst✝¹ : SMulCommClass 𝕜 R F
inst✝ : ContinuousConstSMul R F
f : E → F
x : E
c : R
hf : ContDiffWithinAt 𝕜 n f univ x
⊢ ContDiffWithinAt 𝕜 n (fun y => c • f y) univ x
[PROOFSTEP]
exact hf.const_smul c
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
R : Type u_3
inst✝³ : Semiring R
inst✝² : Module R F
inst✝¹ : SMulCommClass 𝕜 R F
inst✝ : ContinuousConstSMul R F
i : ℕ
a : R
x : E
hf : ContDiff 𝕜 (↑i) f
⊢ iteratedFDeriv 𝕜 i (a • f) x = a • iteratedFDeriv 𝕜 i f x
[PROOFSTEP]
simp_rw [← contDiffOn_univ, ← iteratedFDerivWithin_univ] at *
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
R : Type u_3
inst✝³ : Semiring R
inst✝² : Module R F
inst✝¹ : SMulCommClass 𝕜 R F
inst✝ : ContinuousConstSMul R F
i : ℕ
a : R
x : E
hf : ContDiffOn 𝕜 (↑i) f univ
⊢ iteratedFDerivWithin 𝕜 i (a • f) univ x = a • iteratedFDerivWithin 𝕜 i f univ x
[PROOFSTEP]
refine' iteratedFDerivWithin_const_smul_apply hf uniqueDiffOn_univ (Set.mem_univ _)
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
E' : Type u_3
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
F' : Type u_4
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace 𝕜 F'
f : E → F
g : E' → F'
x : E
y : E'
hf : ContDiffAt 𝕜 n f x
hg : ContDiffAt 𝕜 n g y
⊢ ContDiffAt 𝕜 n (Prod.map f g) (x, y)
[PROOFSTEP]
rw [ContDiffAt] at *
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
E' : Type u_3
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
F' : Type u_4
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace 𝕜 F'
f : E → F
g : E' → F'
x : E
y : E'
hf : ContDiffWithinAt 𝕜 n f univ x
hg : ContDiffWithinAt 𝕜 n g univ y
⊢ ContDiffWithinAt 𝕜 n (Prod.map f g) univ (x, y)
[PROOFSTEP]
convert hf.prod_map hg
[GOAL]
case h.e'_11
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
E' : Type u_3
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
F' : Type u_4
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace 𝕜 F'
f : E → F
g : E' → F'
x : E
y : E'
hf : ContDiffWithinAt 𝕜 n f univ x
hg : ContDiffWithinAt 𝕜 n g univ y
⊢ univ = univ ×ˢ univ
[PROOFSTEP]
simp only [univ_prod_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
E' : Type u_3
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
F' : Type u_4
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace 𝕜 F'
f : E → F
g : E' → F'
p : E × E'
hf : ContDiffAt 𝕜 n f p.fst
hg : ContDiffAt 𝕜 n g p.snd
⊢ ContDiffAt 𝕜 n (Prod.map f g) p
[PROOFSTEP]
rcases p with ⟨⟩
[GOAL]
case mk
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
E' : Type u_3
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
F' : Type u_4
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace 𝕜 F'
f : E → F
g : E' → F'
fst✝ : E
snd✝ : E'
hf : ContDiffAt 𝕜 n f (fst✝, snd✝).fst
hg : ContDiffAt 𝕜 n g (fst✝, snd✝).snd
⊢ ContDiffAt 𝕜 n (Prod.map f g) (fst✝, snd✝)
[PROOFSTEP]
exact ContDiffAt.prod_map hf hg
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
E' : Type u_3
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
F' : Type u_4
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace 𝕜 F'
f : E → F
g : E' → F'
hf : ContDiff 𝕜 n f
hg : ContDiff 𝕜 n g
⊢ ContDiff 𝕜 n (Prod.map f g)
[PROOFSTEP]
rw [contDiff_iff_contDiffAt] at *
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
E' : Type u_3
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
F' : Type u_4
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace 𝕜 F'
f : E → F
g : E' → F'
hf : ∀ (x : E), ContDiffAt 𝕜 n f x
hg : ∀ (x : E'), ContDiffAt 𝕜 n g x
⊢ ∀ (x : E × E'), ContDiffAt 𝕜 n (Prod.map f g) x
[PROOFSTEP]
exact fun ⟨x, y⟩ => (hf x).prod_map (hg y)
[GOAL]
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
⊢ ContDiffAt 𝕜 n Ring.inverse ↑x
[PROOFSTEP]
induction' n using ENat.nat_induction with n IH Itop
[GOAL]
case h0
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
⊢ ContDiffAt 𝕜 0 Ring.inverse ↑x
[PROOFSTEP]
intro m hm
[GOAL]
case h0
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
m : ℕ
hm : ↑m ≤ 0
⊢ ∃ u, u ∈ 𝓝[insert (↑x) univ] ↑x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) Ring.inverse p u
[PROOFSTEP]
refine' ⟨{y : R | IsUnit y}, _, _⟩
[GOAL]
case h0.refine'_1
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
m : ℕ
hm : ↑m ≤ 0
⊢ {y | IsUnit y} ∈ 𝓝[insert (↑x) univ] ↑x
[PROOFSTEP]
simp [nhdsWithin_univ]
[GOAL]
case h0.refine'_1
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
m : ℕ
hm : ↑m ≤ 0
⊢ {y | IsUnit y} ∈ 𝓝 ↑x
[PROOFSTEP]
exact x.nhds
[GOAL]
case h0.refine'_2
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
m : ℕ
hm : ↑m ≤ 0
⊢ ∃ p, HasFTaylorSeriesUpToOn (↑m) Ring.inverse p {y | IsUnit y}
[PROOFSTEP]
use ftaylorSeriesWithin 𝕜 inverse univ
[GOAL]
case h
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
m : ℕ
hm : ↑m ≤ 0
⊢ HasFTaylorSeriesUpToOn (↑m) Ring.inverse (ftaylorSeriesWithin 𝕜 Ring.inverse univ) {y | IsUnit y}
[PROOFSTEP]
rw [le_antisymm hm bot_le, hasFTaylorSeriesUpToOn_zero_iff]
[GOAL]
case h
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
m : ℕ
hm : ↑m ≤ 0
⊢ ContinuousOn Ring.inverse {y | IsUnit y} ∧
∀ (x : R),
x ∈ {y | IsUnit y} →
ContinuousMultilinearMap.uncurry0 (ftaylorSeriesWithin 𝕜 Ring.inverse univ x 0) = Ring.inverse x
[PROOFSTEP]
constructor
[GOAL]
case h.left
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
m : ℕ
hm : ↑m ≤ 0
⊢ ContinuousOn Ring.inverse {y | IsUnit y}
[PROOFSTEP]
rintro _ ⟨x', rfl⟩
[GOAL]
case h.left.intro
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
m : ℕ
hm : ↑m ≤ 0
x' : Rˣ
⊢ ContinuousWithinAt Ring.inverse {y | IsUnit y} ↑x'
[PROOFSTEP]
exact (inverse_continuousAt x').continuousWithinAt
[GOAL]
case h.right
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
m : ℕ
hm : ↑m ≤ 0
⊢ ∀ (x : R),
x ∈ {y | IsUnit y} →
ContinuousMultilinearMap.uncurry0 (ftaylorSeriesWithin 𝕜 Ring.inverse univ x 0) = Ring.inverse x
[PROOFSTEP]
simp [ftaylorSeriesWithin]
[GOAL]
case hsuc
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
n : ℕ
IH : ContDiffAt 𝕜 (↑n) Ring.inverse ↑x
⊢ ContDiffAt 𝕜 (↑(Nat.succ n)) Ring.inverse ↑x
[PROOFSTEP]
apply contDiffAt_succ_iff_hasFDerivAt.mpr
[GOAL]
case hsuc
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
n : ℕ
IH : ContDiffAt 𝕜 (↑n) Ring.inverse ↑x
⊢ ∃ f', (∃ u, u ∈ 𝓝 ↑x ∧ ∀ (x : R), x ∈ u → HasFDerivAt Ring.inverse (f' x) x) ∧ ContDiffAt 𝕜 (↑n) f' ↑x
[PROOFSTEP]
refine' ⟨fun x : R => -mulLeftRight 𝕜 R (inverse x) (inverse x), _, _⟩
[GOAL]
case hsuc.refine'_1
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
n : ℕ
IH : ContDiffAt 𝕜 (↑n) Ring.inverse ↑x
⊢ ∃ u,
u ∈ 𝓝 ↑x ∧
∀ (x : R),
x ∈ u → HasFDerivAt Ring.inverse ((fun x => -↑(↑(mulLeftRight 𝕜 R) (Ring.inverse x)) (Ring.inverse x)) x) x
[PROOFSTEP]
refine' ⟨{y : R | IsUnit y}, x.nhds, _⟩
[GOAL]
case hsuc.refine'_1
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
n : ℕ
IH : ContDiffAt 𝕜 (↑n) Ring.inverse ↑x
⊢ ∀ (x : R),
x ∈ {y | IsUnit y} →
HasFDerivAt Ring.inverse ((fun x => -↑(↑(mulLeftRight 𝕜 R) (Ring.inverse x)) (Ring.inverse x)) x) x
[PROOFSTEP]
rintro _ ⟨y, rfl⟩
[GOAL]
case hsuc.refine'_1.intro
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
n : ℕ
IH : ContDiffAt 𝕜 (↑n) Ring.inverse ↑x
y : Rˣ
⊢ HasFDerivAt Ring.inverse ((fun x => -↑(↑(mulLeftRight 𝕜 R) (Ring.inverse x)) (Ring.inverse x)) ↑y) ↑y
[PROOFSTEP]
simp_rw [inverse_unit]
[GOAL]
case hsuc.refine'_1.intro
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
n : ℕ
IH : ContDiffAt 𝕜 (↑n) Ring.inverse ↑x
y : Rˣ
⊢ HasFDerivAt Ring.inverse (-↑(↑(mulLeftRight 𝕜 R) ↑y⁻¹) ↑y⁻¹) ↑y
[PROOFSTEP]
exact hasFDerivAt_ring_inverse y
[GOAL]
case hsuc.refine'_2
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
n : ℕ
IH : ContDiffAt 𝕜 (↑n) Ring.inverse ↑x
⊢ ContDiffAt 𝕜 (↑n) (fun x => -↑(↑(mulLeftRight 𝕜 R) (Ring.inverse x)) (Ring.inverse x)) ↑x
[PROOFSTEP]
convert (mulLeftRight_isBoundedBilinear 𝕜 R).contDiff.neg.comp_contDiffAt (x : R) (IH.prod IH)
[GOAL]
case htop
𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹² : NormedAddCommGroup D
inst✝¹¹ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type uF
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type uG
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁴ : NormedAddCommGroup X
inst✝³ : 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
R : Type u_3
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
Itop : ∀ (n : ℕ), ContDiffAt 𝕜 (↑n) Ring.inverse ↑x
⊢ ContDiffAt 𝕜 ⊤ Ring.inverse ↑x
[PROOFSTEP]
exact contDiffAt_top.mpr Itop
[GOAL]
𝕜 : Type u_1
inst✝¹⁵ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁴ : NormedAddCommGroup D
inst✝¹³ : NormedSpace 𝕜 D
E : Type uE
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace 𝕜 F
G : Type uG
inst✝⁸ : NormedAddCommGroup G
inst✝⁷ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁶ : NormedAddCommGroup X
inst✝⁵ : 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
R : Type u_3
inst✝⁴ : NormedRing R
inst✝³ : NormedAlgebra 𝕜 R
𝕜' : Type u_4
inst✝² : NormedField 𝕜'
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : CompleteSpace 𝕜'
x : 𝕜'
hx : x ≠ 0
n : ℕ∞
⊢ ContDiffAt 𝕜 n Inv.inv x
[PROOFSTEP]
simpa only [Ring.inverse_eq_inv'] using contDiffAt_ring_inverse 𝕜 (Units.mk0 x hx)
[GOAL]
𝕜 : Type u_1
inst✝¹⁵ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁴ : NormedAddCommGroup D
inst✝¹³ : NormedSpace 𝕜 D
E : Type uE
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace 𝕜 F
G : Type uG
inst✝⁸ : NormedAddCommGroup G
inst✝⁷ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁶ : NormedAddCommGroup X
inst✝⁵ : 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
R : Type u_3
inst✝⁴ : NormedRing R
inst✝³ : NormedAlgebra 𝕜 R
𝕜' : Type u_4
inst✝² : NormedField 𝕜'
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : CompleteSpace 𝕜'
f : E → 𝕜'
n : ℕ∞
hf : ContDiff 𝕜 n f
h : ∀ (x : E), f x ≠ 0
⊢ ContDiff 𝕜 n fun x => (f x)⁻¹
[PROOFSTEP]
rw [contDiff_iff_contDiffAt]
[GOAL]
𝕜 : Type u_1
inst✝¹⁵ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁴ : NormedAddCommGroup D
inst✝¹³ : NormedSpace 𝕜 D
E : Type uE
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace 𝕜 F
G : Type uG
inst✝⁸ : NormedAddCommGroup G
inst✝⁷ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁶ : NormedAddCommGroup X
inst✝⁵ : 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
R : Type u_3
inst✝⁴ : NormedRing R
inst✝³ : NormedAlgebra 𝕜 R
𝕜' : Type u_4
inst✝² : NormedField 𝕜'
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : CompleteSpace 𝕜'
f : E → 𝕜'
n : ℕ∞
hf : ContDiff 𝕜 n f
h : ∀ (x : E), f x ≠ 0
⊢ ∀ (x : E), ContDiffAt 𝕜 n (fun x => (f x)⁻¹) x
[PROOFSTEP]
exact fun x => hf.contDiffAt.inv (h x)
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁵ : NormedAddCommGroup D
inst✝¹⁴ : NormedSpace 𝕜 D
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
R : Type u_3
inst✝⁵ : NormedRing R
inst✝⁴ : NormedAlgebra 𝕜 R
𝕜' : Type u_4
inst✝³ : NormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : CompleteSpace 𝕜'
inst✝ : CompleteSpace 𝕜
f g : E → 𝕜
n : ℕ∞
hf : ContDiffWithinAt 𝕜 n f s x
hg : ContDiffWithinAt 𝕜 n g s x
hx : g x ≠ 0
⊢ ContDiffWithinAt 𝕜 n (fun x => f x / g x) s x
[PROOFSTEP]
simpa only [div_eq_mul_inv] using hf.mul (hg.inv hx)
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁵ : NormedAddCommGroup D
inst✝¹⁴ : NormedSpace 𝕜 D
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
R : Type u_3
inst✝⁵ : NormedRing R
inst✝⁴ : NormedAlgebra 𝕜 R
𝕜' : Type u_4
inst✝³ : NormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : CompleteSpace 𝕜'
inst✝ : CompleteSpace 𝕜
f g : E → 𝕜
n : ℕ∞
hf : ContDiff 𝕜 n f
hg : ContDiff 𝕜 n g
h0 : ∀ (x : E), g x ≠ 0
⊢ ContDiff 𝕜 n fun x => f x / g x
[PROOFSTEP]
simp only [contDiff_iff_contDiffAt] at *
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁵ : NormedAddCommGroup D
inst✝¹⁴ : NormedSpace 𝕜 D
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
R : Type u_3
inst✝⁵ : NormedRing R
inst✝⁴ : NormedAlgebra 𝕜 R
𝕜' : Type u_4
inst✝³ : NormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : CompleteSpace 𝕜'
inst✝ : CompleteSpace 𝕜
f g : E → 𝕜
n : ℕ∞
h0 : ∀ (x : E), g x ≠ 0
hf : ∀ (x : E), ContDiffAt 𝕜 n f x
hg : ∀ (x : E), ContDiffAt 𝕜 n g x
⊢ ∀ (x : E), ContDiffAt 𝕜 n (fun x => f x / g x) x
[PROOFSTEP]
exact fun x => (hf x).div (hg x) (h0 x)
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
e : E ≃L[𝕜] F
⊢ ContDiffAt 𝕜 n inverse ↑e
[PROOFSTEP]
nontriviality E
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
e : E ≃L[𝕜] F
✝ : Nontrivial E
⊢ ContDiffAt 𝕜 n inverse ↑e
[PROOFSTEP]
let O₁ : (E →L[𝕜] E) → F →L[𝕜] E := fun f => f.comp (e.symm : F →L[𝕜] E)
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
e : E ≃L[𝕜] F
✝ : Nontrivial E
O₁ : (E →L[𝕜] E) → F →L[𝕜] E := fun f => ContinuousLinearMap.comp f ↑(ContinuousLinearEquiv.symm e)
⊢ ContDiffAt 𝕜 n inverse ↑e
[PROOFSTEP]
let O₂ : (E →L[𝕜] F) → E →L[𝕜] E := fun f => (e.symm : F →L[𝕜] E).comp f
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
e : E ≃L[𝕜] F
✝ : Nontrivial E
O₁ : (E →L[𝕜] E) → F →L[𝕜] E := fun f => ContinuousLinearMap.comp f ↑(ContinuousLinearEquiv.symm e)
O₂ : (E →L[𝕜] F) → E →L[𝕜] E := fun f => ContinuousLinearMap.comp (↑(ContinuousLinearEquiv.symm e)) f
⊢ ContDiffAt 𝕜 n inverse ↑e
[PROOFSTEP]
have : ContinuousLinearMap.inverse = O₁ ∘ Ring.inverse ∘ O₂ := funext (to_ring_inverse e)
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
e : E ≃L[𝕜] F
✝ : Nontrivial E
O₁ : (E →L[𝕜] E) → F →L[𝕜] E := fun f => ContinuousLinearMap.comp f ↑(ContinuousLinearEquiv.symm e)
O₂ : (E →L[𝕜] F) → E →L[𝕜] E := fun f => ContinuousLinearMap.comp (↑(ContinuousLinearEquiv.symm e)) f
this : inverse = O₁ ∘ Ring.inverse ∘ O₂
⊢ ContDiffAt 𝕜 n inverse ↑e
[PROOFSTEP]
rw [this]
-- `O₁` and `O₂` are `ContDiff`,
-- so we reduce to proving that `Ring.inverse` is `ContDiff`
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
e : E ≃L[𝕜] F
✝ : Nontrivial E
O₁ : (E →L[𝕜] E) → F →L[𝕜] E := fun f => ContinuousLinearMap.comp f ↑(ContinuousLinearEquiv.symm e)
O₂ : (E →L[𝕜] F) → E →L[𝕜] E := fun f => ContinuousLinearMap.comp (↑(ContinuousLinearEquiv.symm e)) f
this : inverse = O₁ ∘ Ring.inverse ∘ O₂
⊢ ContDiffAt 𝕜 n (O₁ ∘ Ring.inverse ∘ O₂) ↑e
[PROOFSTEP]
have h₁ : ContDiff 𝕜 n O₁ := contDiff_id.clm_comp contDiff_const
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
e : E ≃L[𝕜] F
✝ : Nontrivial E
O₁ : (E →L[𝕜] E) → F →L[𝕜] E := fun f => ContinuousLinearMap.comp f ↑(ContinuousLinearEquiv.symm e)
O₂ : (E →L[𝕜] F) → E →L[𝕜] E := fun f => ContinuousLinearMap.comp (↑(ContinuousLinearEquiv.symm e)) f
this : inverse = O₁ ∘ Ring.inverse ∘ O₂
h₁ : ContDiff 𝕜 n O₁
⊢ ContDiffAt 𝕜 n (O₁ ∘ Ring.inverse ∘ O₂) ↑e
[PROOFSTEP]
have h₂ : ContDiff 𝕜 n O₂ := contDiff_const.clm_comp contDiff_id
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
e : E ≃L[𝕜] F
✝ : Nontrivial E
O₁ : (E →L[𝕜] E) → F →L[𝕜] E := fun f => ContinuousLinearMap.comp f ↑(ContinuousLinearEquiv.symm e)
O₂ : (E →L[𝕜] F) → E →L[𝕜] E := fun f => ContinuousLinearMap.comp (↑(ContinuousLinearEquiv.symm e)) f
this : inverse = O₁ ∘ Ring.inverse ∘ O₂
h₁ : ContDiff 𝕜 n O₁
h₂ : ContDiff 𝕜 n O₂
⊢ ContDiffAt 𝕜 n (O₁ ∘ Ring.inverse ∘ O₂) ↑e
[PROOFSTEP]
refine' h₁.contDiffAt.comp _ (ContDiffAt.comp _ _ h₂.contDiffAt)
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
e : E ≃L[𝕜] F
✝ : Nontrivial E
O₁ : (E →L[𝕜] E) → F →L[𝕜] E := fun f => ContinuousLinearMap.comp f ↑(ContinuousLinearEquiv.symm e)
O₂ : (E →L[𝕜] F) → E →L[𝕜] E := fun f => ContinuousLinearMap.comp (↑(ContinuousLinearEquiv.symm e)) f
this : inverse = O₁ ∘ Ring.inverse ∘ O₂
h₁ : ContDiff 𝕜 n O₁
h₂ : ContDiff 𝕜 n O₂
⊢ ContDiffAt 𝕜 n Ring.inverse (O₂ ↑e)
[PROOFSTEP]
convert contDiffAt_ring_inverse 𝕜 (1 : (E →L[𝕜] E)ˣ)
[GOAL]
case h.e'_11
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
e : E ≃L[𝕜] F
✝ : Nontrivial E
O₁ : (E →L[𝕜] E) → F →L[𝕜] E := fun f => ContinuousLinearMap.comp f ↑(ContinuousLinearEquiv.symm e)
O₂ : (E →L[𝕜] F) → E →L[𝕜] E := fun f => ContinuousLinearMap.comp (↑(ContinuousLinearEquiv.symm e)) f
this : inverse = O₁ ∘ Ring.inverse ∘ O₂
h₁ : ContDiff 𝕜 n O₁
h₂ : ContDiff 𝕜 n O₂
⊢ O₂ ↑e = ↑1
[PROOFSTEP]
simp [one_def]
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf : ContDiffAt 𝕜 n (↑f) (↑(LocalHomeomorph.symm f) a)
⊢ ContDiffAt 𝕜 n (↑(LocalHomeomorph.symm f)) a
[PROOFSTEP]
induction' n using ENat.nat_induction with n IH Itop
[GOAL]
case h0
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n (↑f) (↑(LocalHomeomorph.symm f) a)
hf : ContDiffAt 𝕜 0 (↑f) (↑(LocalHomeomorph.symm f) a)
⊢ ContDiffAt 𝕜 0 (↑(LocalHomeomorph.symm f)) a
[PROOFSTEP]
rw [contDiffAt_zero]
[GOAL]
case h0
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n (↑f) (↑(LocalHomeomorph.symm f) a)
hf : ContDiffAt 𝕜 0 (↑f) (↑(LocalHomeomorph.symm f) a)
⊢ ∃ u, u ∈ 𝓝 a ∧ ContinuousOn (↑(LocalHomeomorph.symm f)) u
[PROOFSTEP]
exact ⟨f.target, IsOpen.mem_nhds f.open_target ha, f.continuous_invFun⟩
[GOAL]
case hsuc
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
⊢ ContDiffAt 𝕜 (↑(Nat.succ n)) (↑(LocalHomeomorph.symm f)) a
[PROOFSTEP]
obtain ⟨f', ⟨u, hu, hff'⟩, hf'⟩ := contDiffAt_succ_iff_hasFDerivAt.mp hf
[GOAL]
case hsuc.intro.intro.intro.intro
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
⊢ ContDiffAt 𝕜 (↑(Nat.succ n)) (↑(LocalHomeomorph.symm f)) a
[PROOFSTEP]
apply contDiffAt_succ_iff_hasFDerivAt.mpr
[GOAL]
case hsuc.intro.intro.intro.intro
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
⊢ ∃ f', (∃ u, u ∈ 𝓝 a ∧ ∀ (x : F), x ∈ u → HasFDerivAt (↑(LocalHomeomorph.symm f)) (f' x) x) ∧ ContDiffAt 𝕜 (↑n) f' a
[PROOFSTEP]
have eq_f₀' : f' (f.symm a) = f₀' := (hff' (f.symm a) (mem_of_mem_nhds hu)).unique hf₀'
[GOAL]
case hsuc.intro.intro.intro.intro
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
⊢ ∃ f', (∃ u, u ∈ 𝓝 a ∧ ∀ (x : F), x ∈ u → HasFDerivAt (↑(LocalHomeomorph.symm f)) (f' x) x) ∧ ContDiffAt 𝕜 (↑n) f' a
[PROOFSTEP]
refine' ⟨inverse ∘ f' ∘ f.symm, _, _⟩
[GOAL]
case hsuc.intro.intro.intro.intro.refine'_1
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
⊢ ∃ u,
u ∈ 𝓝 a ∧
∀ (x : F), x ∈ u → HasFDerivAt (↑(LocalHomeomorph.symm f)) ((inverse ∘ f' ∘ ↑(LocalHomeomorph.symm f)) x) x
[PROOFSTEP]
have h_nhds : {y : E | ∃ e : E ≃L[𝕜] F, ↑e = f' y} ∈ 𝓝 (f.symm a) :=
by
have hf₀' := f₀'.nhds
rw [← eq_f₀'] at hf₀'
exact hf'.continuousAt.preimage_mem_nhds hf₀'
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
⊢ {y | ∃ e, ↑e = f' y} ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
[PROOFSTEP]
have hf₀' := f₀'.nhds
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀'✝ : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
hf₀' : range ContinuousLinearEquiv.toContinuousLinearMap ∈ 𝓝 ↑f₀'
⊢ {y | ∃ e, ↑e = f' y} ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
[PROOFSTEP]
rw [← eq_f₀'] at hf₀'
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀'✝ : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
hf₀' : range ContinuousLinearEquiv.toContinuousLinearMap ∈ 𝓝 (f' (↑(LocalHomeomorph.symm f) a))
⊢ {y | ∃ e, ↑e = f' y} ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
[PROOFSTEP]
exact hf'.continuousAt.preimage_mem_nhds hf₀'
[GOAL]
case hsuc.intro.intro.intro.intro.refine'_1
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
h_nhds : {y | ∃ e, ↑e = f' y} ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
⊢ ∃ u,
u ∈ 𝓝 a ∧
∀ (x : F), x ∈ u → HasFDerivAt (↑(LocalHomeomorph.symm f)) ((inverse ∘ f' ∘ ↑(LocalHomeomorph.symm f)) x) x
[PROOFSTEP]
obtain ⟨t, htu, ht, htf⟩ := mem_nhds_iff.mp (Filter.inter_mem hu h_nhds)
[GOAL]
case hsuc.intro.intro.intro.intro.refine'_1.intro.intro.intro
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
h_nhds : {y | ∃ e, ↑e = f' y} ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
t : Set E
htu : t ⊆ u ∩ {y | ∃ e, ↑e = f' y}
ht : IsOpen t
htf : ↑(LocalHomeomorph.symm f) a ∈ t
⊢ ∃ u,
u ∈ 𝓝 a ∧
∀ (x : F), x ∈ u → HasFDerivAt (↑(LocalHomeomorph.symm f)) ((inverse ∘ f' ∘ ↑(LocalHomeomorph.symm f)) x) x
[PROOFSTEP]
use f.target ∩ f.symm ⁻¹' t
[GOAL]
case h
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
h_nhds : {y | ∃ e, ↑e = f' y} ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
t : Set E
htu : t ⊆ u ∩ {y | ∃ e, ↑e = f' y}
ht : IsOpen t
htf : ↑(LocalHomeomorph.symm f) a ∈ t
⊢ f.target ∩ ↑(LocalHomeomorph.symm f) ⁻¹' t ∈ 𝓝 a ∧
∀ (x : F),
x ∈ f.target ∩ ↑(LocalHomeomorph.symm f) ⁻¹' t →
HasFDerivAt (↑(LocalHomeomorph.symm f)) ((inverse ∘ f' ∘ ↑(LocalHomeomorph.symm f)) x) x
[PROOFSTEP]
refine' ⟨IsOpen.mem_nhds _ _, _⟩
[GOAL]
case h.refine'_1
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
h_nhds : {y | ∃ e, ↑e = f' y} ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
t : Set E
htu : t ⊆ u ∩ {y | ∃ e, ↑e = f' y}
ht : IsOpen t
htf : ↑(LocalHomeomorph.symm f) a ∈ t
⊢ IsOpen (f.target ∩ ↑(LocalHomeomorph.symm f) ⁻¹' t)
[PROOFSTEP]
exact f.preimage_open_of_open_symm ht
[GOAL]
case h.refine'_2
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
h_nhds : {y | ∃ e, ↑e = f' y} ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
t : Set E
htu : t ⊆ u ∩ {y | ∃ e, ↑e = f' y}
ht : IsOpen t
htf : ↑(LocalHomeomorph.symm f) a ∈ t
⊢ a ∈ f.target ∩ ↑(LocalHomeomorph.symm f) ⁻¹' t
[PROOFSTEP]
exact mem_inter ha (mem_preimage.mpr htf)
[GOAL]
case h.refine'_3
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
h_nhds : {y | ∃ e, ↑e = f' y} ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
t : Set E
htu : t ⊆ u ∩ {y | ∃ e, ↑e = f' y}
ht : IsOpen t
htf : ↑(LocalHomeomorph.symm f) a ∈ t
⊢ ∀ (x : F),
x ∈ f.target ∩ ↑(LocalHomeomorph.symm f) ⁻¹' t →
HasFDerivAt (↑(LocalHomeomorph.symm f)) ((inverse ∘ f' ∘ ↑(LocalHomeomorph.symm f)) x) x
[PROOFSTEP]
intro x hx
[GOAL]
case h.refine'_3
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
h_nhds : {y | ∃ e, ↑e = f' y} ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
t : Set E
htu : t ⊆ u ∩ {y | ∃ e, ↑e = f' y}
ht : IsOpen t
htf : ↑(LocalHomeomorph.symm f) a ∈ t
x : F
hx : x ∈ f.target ∩ ↑(LocalHomeomorph.symm f) ⁻¹' t
⊢ HasFDerivAt (↑(LocalHomeomorph.symm f)) ((inverse ∘ f' ∘ ↑(LocalHomeomorph.symm f)) x) x
[PROOFSTEP]
obtain ⟨hxu, e, he⟩ := htu hx.2
[GOAL]
case h.refine'_3.intro.intro
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
h_nhds : {y | ∃ e, ↑e = f' y} ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
t : Set E
htu : t ⊆ u ∩ {y | ∃ e, ↑e = f' y}
ht : IsOpen t
htf : ↑(LocalHomeomorph.symm f) a ∈ t
x : F
hx : x ∈ f.target ∩ ↑(LocalHomeomorph.symm f) ⁻¹' t
hxu : ↑(LocalHomeomorph.symm f) x ∈ u
e : E ≃L[𝕜] F
he : ↑e = f' (↑(LocalHomeomorph.symm f) x)
⊢ HasFDerivAt (↑(LocalHomeomorph.symm f)) ((inverse ∘ f' ∘ ↑(LocalHomeomorph.symm f)) x) x
[PROOFSTEP]
have h_deriv : HasFDerivAt f (e : E →L[𝕜] F) (f.symm x) :=
by
rw [he]
exact hff' (f.symm x) hxu
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
h_nhds : {y | ∃ e, ↑e = f' y} ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
t : Set E
htu : t ⊆ u ∩ {y | ∃ e, ↑e = f' y}
ht : IsOpen t
htf : ↑(LocalHomeomorph.symm f) a ∈ t
x : F
hx : x ∈ f.target ∩ ↑(LocalHomeomorph.symm f) ⁻¹' t
hxu : ↑(LocalHomeomorph.symm f) x ∈ u
e : E ≃L[𝕜] F
he : ↑e = f' (↑(LocalHomeomorph.symm f) x)
⊢ HasFDerivAt (↑f) (↑e) (↑(LocalHomeomorph.symm f) x)
[PROOFSTEP]
rw [he]
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
h_nhds : {y | ∃ e, ↑e = f' y} ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
t : Set E
htu : t ⊆ u ∩ {y | ∃ e, ↑e = f' y}
ht : IsOpen t
htf : ↑(LocalHomeomorph.symm f) a ∈ t
x : F
hx : x ∈ f.target ∩ ↑(LocalHomeomorph.symm f) ⁻¹' t
hxu : ↑(LocalHomeomorph.symm f) x ∈ u
e : E ≃L[𝕜] F
he : ↑e = f' (↑(LocalHomeomorph.symm f) x)
⊢ HasFDerivAt (↑f) (f' (↑(LocalHomeomorph.symm f) x)) (↑(LocalHomeomorph.symm f) x)
[PROOFSTEP]
exact hff' (f.symm x) hxu
[GOAL]
case h.refine'_3.intro.intro
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
h_nhds : {y | ∃ e, ↑e = f' y} ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
t : Set E
htu : t ⊆ u ∩ {y | ∃ e, ↑e = f' y}
ht : IsOpen t
htf : ↑(LocalHomeomorph.symm f) a ∈ t
x : F
hx : x ∈ f.target ∩ ↑(LocalHomeomorph.symm f) ⁻¹' t
hxu : ↑(LocalHomeomorph.symm f) x ∈ u
e : E ≃L[𝕜] F
he : ↑e = f' (↑(LocalHomeomorph.symm f) x)
h_deriv : HasFDerivAt (↑f) (↑e) (↑(LocalHomeomorph.symm f) x)
⊢ HasFDerivAt (↑(LocalHomeomorph.symm f)) ((inverse ∘ f' ∘ ↑(LocalHomeomorph.symm f)) x) x
[PROOFSTEP]
convert f.hasFDerivAt_symm hx.1 h_deriv
[GOAL]
case h.e'_10
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
h_nhds : {y | ∃ e, ↑e = f' y} ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
t : Set E
htu : t ⊆ u ∩ {y | ∃ e, ↑e = f' y}
ht : IsOpen t
htf : ↑(LocalHomeomorph.symm f) a ∈ t
x : F
hx : x ∈ f.target ∩ ↑(LocalHomeomorph.symm f) ⁻¹' t
hxu : ↑(LocalHomeomorph.symm f) x ∈ u
e : E ≃L[𝕜] F
he : ↑e = f' (↑(LocalHomeomorph.symm f) x)
h_deriv : HasFDerivAt (↑f) (↑e) (↑(LocalHomeomorph.symm f) x)
⊢ (inverse ∘ f' ∘ ↑(LocalHomeomorph.symm f)) x = ↑(ContinuousLinearEquiv.symm e)
[PROOFSTEP]
simp [← he]
[GOAL]
case hsuc.intro.intro.intro.intro.refine'_2
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
⊢ ContDiffAt 𝕜 (↑n) (inverse ∘ f' ∘ ↑(LocalHomeomorph.symm f)) a
[PROOFSTEP]
have h_deriv₁ : ContDiffAt 𝕜 n inverse (f' (f.symm a)) :=
by
rw [eq_f₀']
exact contDiffAt_map_inverse _
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
⊢ ContDiffAt 𝕜 (↑n) inverse (f' (↑(LocalHomeomorph.symm f) a))
[PROOFSTEP]
rw [eq_f₀']
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
⊢ ContDiffAt 𝕜 (↑n) inverse ↑f₀'
[PROOFSTEP]
exact contDiffAt_map_inverse _
[GOAL]
case hsuc.intro.intro.intro.intro.refine'_2
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
h_deriv₁ : ContDiffAt 𝕜 (↑n) inverse (f' (↑(LocalHomeomorph.symm f) a))
⊢ ContDiffAt 𝕜 (↑n) (inverse ∘ f' ∘ ↑(LocalHomeomorph.symm f)) a
[PROOFSTEP]
have h_deriv₂ : ContDiffAt 𝕜 n f.symm a := by
refine' IH (hf.of_le _)
norm_cast
exact Nat.le_succ n
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
h_deriv₁ : ContDiffAt 𝕜 (↑n) inverse (f' (↑(LocalHomeomorph.symm f) a))
⊢ ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
[PROOFSTEP]
refine' IH (hf.of_le _)
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
h_deriv₁ : ContDiffAt 𝕜 (↑n) inverse (f' (↑(LocalHomeomorph.symm f) a))
⊢ ↑n ≤ ↑(Nat.succ n)
[PROOFSTEP]
norm_cast
[GOAL]
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
h_deriv₁ : ContDiffAt 𝕜 (↑n) inverse (f' (↑(LocalHomeomorph.symm f) a))
⊢ n ≤ Nat.succ n
[PROOFSTEP]
exact Nat.le_succ n
[GOAL]
case hsuc.intro.intro.intro.intro.refine'_2
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
IH : ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 (↑(Nat.succ n)) (↑f) (↑(LocalHomeomorph.symm f) a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑(LocalHomeomorph.symm f) a)
u : Set E
hu : u ∈ 𝓝 (↑(LocalHomeomorph.symm f) a)
hff' : ∀ (x : E), x ∈ u → HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑(LocalHomeomorph.symm f) a) = ↑f₀'
h_deriv₁ : ContDiffAt 𝕜 (↑n) inverse (f' (↑(LocalHomeomorph.symm f) a))
h_deriv₂ : ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
⊢ ContDiffAt 𝕜 (↑n) (inverse ∘ f' ∘ ↑(LocalHomeomorph.symm f)) a
[PROOFSTEP]
exact (h_deriv₁.comp _ hf').comp _ h_deriv₂
[GOAL]
case htop
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n (↑f) (↑(LocalHomeomorph.symm f) a)
Itop : ∀ (n : ℕ), ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 ⊤ (↑f) (↑(LocalHomeomorph.symm f) a)
⊢ ContDiffAt 𝕜 ⊤ (↑(LocalHomeomorph.symm f)) a
[PROOFSTEP]
refine' contDiffAt_top.mpr _
[GOAL]
case htop
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n (↑f) (↑(LocalHomeomorph.symm f) a)
Itop : ∀ (n : ℕ), ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 ⊤ (↑f) (↑(LocalHomeomorph.symm f) a)
⊢ ∀ (n : ℕ), ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
[PROOFSTEP]
intro n
[GOAL]
case htop
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type u_2
inst✝² : NormedAddCommGroup X
inst✝¹ : 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
inst✝ : CompleteSpace E
f : LocalHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑(LocalHomeomorph.symm f) a)
hf✝ : ContDiffAt 𝕜 n✝ (↑f) (↑(LocalHomeomorph.symm f) a)
Itop : ∀ (n : ℕ), ContDiffAt 𝕜 (↑n) (↑f) (↑(LocalHomeomorph.symm f) a) → ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
hf : ContDiffAt 𝕜 ⊤ (↑f) (↑(LocalHomeomorph.symm f) a)
n : ℕ
⊢ ContDiffAt 𝕜 (↑n) (↑(LocalHomeomorph.symm f)) a
[PROOFSTEP]
exact Itop n (contDiffAt_top.mp hf n)
[GOAL]
𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹¹ : NormedAddCommGroup D
inst✝¹⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝³ : NormedAddCommGroup X
inst✝² : 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
inst✝¹ : CompleteSpace 𝕜
n : ℕ∞
f : E → F →L[𝕜] G
s : Set E
inst✝ : FiniteDimensional 𝕜 F
⊢ ContDiffOn 𝕜 n f s ↔ ∀ (y : F), ContDiffOn 𝕜 n (fun x => ↑(f x) y) s
[PROOFSTEP]
refine' ⟨fun h y => h.clm_apply contDiffOn_const, fun h => _⟩
[GOAL]
𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹¹ : NormedAddCommGroup D
inst✝¹⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝³ : NormedAddCommGroup X
inst✝² : 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
inst✝¹ : CompleteSpace 𝕜
n : ℕ∞
f : E → F →L[𝕜] G
s : Set E
inst✝ : FiniteDimensional 𝕜 F
h : ∀ (y : F), ContDiffOn 𝕜 n (fun x => ↑(f x) y) s
⊢ ContDiffOn 𝕜 n f s
[PROOFSTEP]
let d := finrank 𝕜 F
[GOAL]
𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹¹ : NormedAddCommGroup D
inst✝¹⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝³ : NormedAddCommGroup X
inst✝² : 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
inst✝¹ : CompleteSpace 𝕜
n : ℕ∞
f : E → F →L[𝕜] G
s : Set E
inst✝ : FiniteDimensional 𝕜 F
h : ∀ (y : F), ContDiffOn 𝕜 n (fun x => ↑(f x) y) s
d : ℕ := finrank 𝕜 F
⊢ ContDiffOn 𝕜 n f s
[PROOFSTEP]
have hd : d = finrank 𝕜 (Fin d → 𝕜) := (finrank_fin_fun 𝕜).symm
[GOAL]
𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹¹ : NormedAddCommGroup D
inst✝¹⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝³ : NormedAddCommGroup X
inst✝² : 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
inst✝¹ : CompleteSpace 𝕜
n : ℕ∞
f : E → F →L[𝕜] G
s : Set E
inst✝ : FiniteDimensional 𝕜 F
h : ∀ (y : F), ContDiffOn 𝕜 n (fun x => ↑(f x) y) s
d : ℕ := finrank 𝕜 F
hd : d = finrank 𝕜 (Fin d → 𝕜)
⊢ ContDiffOn 𝕜 n f s
[PROOFSTEP]
let e₁ := ContinuousLinearEquiv.ofFinrankEq hd
[GOAL]
𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹¹ : NormedAddCommGroup D
inst✝¹⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝³ : NormedAddCommGroup X
inst✝² : 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
inst✝¹ : CompleteSpace 𝕜
n : ℕ∞
f : E → F →L[𝕜] G
s : Set E
inst✝ : FiniteDimensional 𝕜 F
h : ∀ (y : F), ContDiffOn 𝕜 n (fun x => ↑(f x) y) s
d : ℕ := finrank 𝕜 F
hd : d = finrank 𝕜 (Fin d → 𝕜)
e₁ : F ≃L[𝕜] Fin d → 𝕜 := ContinuousLinearEquiv.ofFinrankEq hd
⊢ ContDiffOn 𝕜 n f s
[PROOFSTEP]
let e₂ := (e₁.arrowCongr (1 : G ≃L[𝕜] G)).trans (ContinuousLinearEquiv.piRing (Fin d))
[GOAL]
𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹¹ : NormedAddCommGroup D
inst✝¹⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝³ : NormedAddCommGroup X
inst✝² : 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
inst✝¹ : CompleteSpace 𝕜
n : ℕ∞
f : E → F →L[𝕜] G
s : Set E
inst✝ : FiniteDimensional 𝕜 F
h : ∀ (y : F), ContDiffOn 𝕜 n (fun x => ↑(f x) y) s
d : ℕ := finrank 𝕜 F
hd : d = finrank 𝕜 (Fin d → 𝕜)
e₁ : F ≃L[𝕜] Fin d → 𝕜 := ContinuousLinearEquiv.ofFinrankEq hd
e₂ : (F →L[𝕜] G) ≃L[𝕜] Fin d → G :=
ContinuousLinearEquiv.trans (ContinuousLinearEquiv.arrowCongr e₁ 1) (ContinuousLinearEquiv.piRing (Fin d))
⊢ ContDiffOn 𝕜 n f s
[PROOFSTEP]
rw [← comp.left_id f, ← e₂.symm_comp_self]
[GOAL]
𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹¹ : NormedAddCommGroup D
inst✝¹⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝³ : NormedAddCommGroup X
inst✝² : 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
inst✝¹ : CompleteSpace 𝕜
n : ℕ∞
f : E → F →L[𝕜] G
s : Set E
inst✝ : FiniteDimensional 𝕜 F
h : ∀ (y : F), ContDiffOn 𝕜 n (fun x => ↑(f x) y) s
d : ℕ := finrank 𝕜 F
hd : d = finrank 𝕜 (Fin d → 𝕜)
e₁ : F ≃L[𝕜] Fin d → 𝕜 := ContinuousLinearEquiv.ofFinrankEq hd
e₂ : (F →L[𝕜] G) ≃L[𝕜] Fin d → G :=
ContinuousLinearEquiv.trans (ContinuousLinearEquiv.arrowCongr e₁ 1) (ContinuousLinearEquiv.piRing (Fin d))
⊢ ContDiffOn 𝕜 n ((↑(ContinuousLinearEquiv.symm e₂) ∘ ↑e₂) ∘ f) s
[PROOFSTEP]
exact e₂.symm.contDiff.comp_contDiffOn (contDiffOn_pi.mpr fun i => h _)
[GOAL]
𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹¹ : NormedAddCommGroup D
inst✝¹⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝³ : NormedAddCommGroup X
inst✝² : 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
inst✝¹ : CompleteSpace 𝕜
n : ℕ∞
f : E → F →L[𝕜] G
inst✝ : FiniteDimensional 𝕜 F
⊢ ContDiff 𝕜 n f ↔ ∀ (y : F), ContDiff 𝕜 n fun x => ↑(f x) y
[PROOFSTEP]
simp_rw [← contDiffOn_univ, contDiffOn_clm_apply]
[GOAL]
𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹¹ : NormedAddCommGroup D
inst✝¹⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝³ : NormedAddCommGroup X
inst✝² : 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
inst✝¹ : CompleteSpace 𝕜
inst✝ : FiniteDimensional 𝕜 E
n : ℕ
f : E → F
⊢ ContDiff 𝕜 (↑(n + 1)) f ↔ Differentiable 𝕜 f ∧ ∀ (y : E), ContDiff 𝕜 ↑n fun x => ↑(fderiv 𝕜 f x) y
[PROOFSTEP]
rw [contDiff_succ_iff_fderiv, contDiff_clm_apply_iff]
[GOAL]
𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹¹ : NormedAddCommGroup D
inst✝¹⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝³ : NormedAddCommGroup X
inst✝² : 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
inst✝¹ : CompleteSpace 𝕜
inst✝ : FiniteDimensional 𝕜 E
n : ℕ
f : E → F
s : Set E
hs : UniqueDiffOn 𝕜 s
⊢ ContDiffOn 𝕜 (↑(n + 1)) f s ↔
DifferentiableOn 𝕜 f s ∧ ∀ (y : E), ContDiffOn 𝕜 (↑n) (fun x => ↑(fderivWithin 𝕜 f s x) y) s
[PROOFSTEP]
rw [contDiffOn_succ_iff_fderivWithin hs, contDiffOn_clm_apply]
[GOAL]
𝕜 : Type u_1
inst✝¹⁵ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁴ : NormedAddCommGroup D
inst✝¹³ : NormedSpace 𝕜 D
E : Type uE
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace 𝕜 F
G : Type uG
inst✝⁸ : NormedAddCommGroup G
inst✝⁷ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁶ : NormedAddCommGroup X
inst✝⁵ : 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
𝕂 : Type u_3
inst✝⁴ : IsROrC 𝕂
E' : Type u_4
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕂 E'
F' : Type u_5
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace 𝕂 F'
f : E' → F'
f' : E' →L[𝕂] F'
x : E'
hf : ContDiffAt 𝕂 n f x
hf' : HasFDerivAt f f' x
hn : 1 ≤ n
⊢ HasStrictFDerivAt f f' x
[PROOFSTEP]
rcases hf 1 hn with ⟨u, H, p, hp⟩
[GOAL]
case intro.intro.intro
𝕜 : Type u_1
inst✝¹⁵ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁴ : NormedAddCommGroup D
inst✝¹³ : NormedSpace 𝕜 D
E : Type uE
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace 𝕜 F
G : Type uG
inst✝⁸ : NormedAddCommGroup G
inst✝⁷ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁶ : NormedAddCommGroup X
inst✝⁵ : 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
𝕂 : Type u_3
inst✝⁴ : IsROrC 𝕂
E' : Type u_4
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕂 E'
F' : Type u_5
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace 𝕂 F'
f : E' → F'
f' : E' →L[𝕂] F'
x : E'
hf : ContDiffAt 𝕂 n f x
hf' : HasFDerivAt f f' x
hn : 1 ≤ n
u : Set E'
H : u ∈ 𝓝[insert x univ] x
p : E' → FormalMultilinearSeries 𝕂 E' F'
hp : HasFTaylorSeriesUpToOn (↑1) f p u
⊢ HasStrictFDerivAt f f' x
[PROOFSTEP]
simp only [nhdsWithin_univ, mem_univ, insert_eq_of_mem] at H
[GOAL]
case intro.intro.intro
𝕜 : Type u_1
inst✝¹⁵ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁴ : NormedAddCommGroup D
inst✝¹³ : NormedSpace 𝕜 D
E : Type uE
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace 𝕜 F
G : Type uG
inst✝⁸ : NormedAddCommGroup G
inst✝⁷ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁶ : NormedAddCommGroup X
inst✝⁵ : 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
𝕂 : Type u_3
inst✝⁴ : IsROrC 𝕂
E' : Type u_4
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕂 E'
F' : Type u_5
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace 𝕂 F'
f : E' → F'
f' : E' →L[𝕂] F'
x : E'
hf : ContDiffAt 𝕂 n f x
hf' : HasFDerivAt f f' x
hn : 1 ≤ n
u : Set E'
p : E' → FormalMultilinearSeries 𝕂 E' F'
hp : HasFTaylorSeriesUpToOn (↑1) f p u
H : u ∈ 𝓝 x
⊢ HasStrictFDerivAt f f' x
[PROOFSTEP]
have := hp.hasStrictFDerivAt le_rfl H
[GOAL]
case intro.intro.intro
𝕜 : Type u_1
inst✝¹⁵ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁴ : NormedAddCommGroup D
inst✝¹³ : NormedSpace 𝕜 D
E : Type uE
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace 𝕜 F
G : Type uG
inst✝⁸ : NormedAddCommGroup G
inst✝⁷ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁶ : NormedAddCommGroup X
inst✝⁵ : 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
𝕂 : Type u_3
inst✝⁴ : IsROrC 𝕂
E' : Type u_4
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕂 E'
F' : Type u_5
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace 𝕂 F'
f : E' → F'
f' : E' →L[𝕂] F'
x : E'
hf : ContDiffAt 𝕂 n f x
hf' : HasFDerivAt f f' x
hn : 1 ≤ n
u : Set E'
p : E' → FormalMultilinearSeries 𝕂 E' F'
hp : HasFTaylorSeriesUpToOn (↑1) f p u
H : u ∈ 𝓝 x
this : HasStrictFDerivAt f (↑(continuousMultilinearCurryFin1 𝕂 E' F') (p x 1)) x
⊢ HasStrictFDerivAt f f' x
[PROOFSTEP]
rwa [hf'.unique this.hasFDerivAt]
[GOAL]
𝕜 : Type u_1
inst✝¹⁹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁸ : NormedAddCommGroup D
inst✝¹⁷ : NormedSpace 𝕜 D
E✝ : Type uE
inst✝¹⁶ : NormedAddCommGroup E✝
inst✝¹⁵ : NormedSpace 𝕜 E✝
F✝ : Type uF
inst✝¹⁴ : NormedAddCommGroup F✝
inst✝¹³ : NormedSpace 𝕜 F✝
G : Type uG
inst✝¹² : NormedAddCommGroup G
inst✝¹¹ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁰ : NormedAddCommGroup X
inst✝⁹ : 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✝
𝕂 : Type u_3
inst✝⁸ : IsROrC 𝕂
E' : Type u_4
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : NormedSpace 𝕂 E'
F' : Type u_5
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace 𝕂 F'
E : Type u_6
F : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
p : E → FormalMultilinearSeries ℝ E F
s : Set E
x : E
hf : HasFTaylorSeriesUpToOn 1 f p (insert x s)
hs : Convex ℝ s
K : ℝ≥0
hK : ‖p x 1‖₊ < K
⊢ ∃ t, t ∈ 𝓝[s] x ∧ LipschitzOnWith K f t
[PROOFSTEP]
set f' := fun y => continuousMultilinearCurryFin1 ℝ E F (p y 1)
[GOAL]
𝕜 : Type u_1
inst✝¹⁹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁸ : NormedAddCommGroup D
inst✝¹⁷ : NormedSpace 𝕜 D
E✝ : Type uE
inst✝¹⁶ : NormedAddCommGroup E✝
inst✝¹⁵ : NormedSpace 𝕜 E✝
F✝ : Type uF
inst✝¹⁴ : NormedAddCommGroup F✝
inst✝¹³ : NormedSpace 𝕜 F✝
G : Type uG
inst✝¹² : NormedAddCommGroup G
inst✝¹¹ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁰ : NormedAddCommGroup X
inst✝⁹ : 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✝
𝕂 : Type u_3
inst✝⁸ : IsROrC 𝕂
E' : Type u_4
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : NormedSpace 𝕂 E'
F' : Type u_5
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace 𝕂 F'
E : Type u_6
F : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
p : E → FormalMultilinearSeries ℝ E F
s : Set E
x : E
hf : HasFTaylorSeriesUpToOn 1 f p (insert x s)
hs : Convex ℝ s
K : ℝ≥0
hK : ‖p x 1‖₊ < K
f' : E → E →L[ℝ] F := fun y => ↑(continuousMultilinearCurryFin1 ℝ E F) (p y 1)
⊢ ∃ t, t ∈ 𝓝[s] x ∧ LipschitzOnWith K f t
[PROOFSTEP]
have hder : ∀ y ∈ s, HasFDerivWithinAt f (f' y) s y := fun y hy =>
(hf.hasFDerivWithinAt le_rfl (subset_insert x s hy)).mono (subset_insert x s)
[GOAL]
𝕜 : Type u_1
inst✝¹⁹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁸ : NormedAddCommGroup D
inst✝¹⁷ : NormedSpace 𝕜 D
E✝ : Type uE
inst✝¹⁶ : NormedAddCommGroup E✝
inst✝¹⁵ : NormedSpace 𝕜 E✝
F✝ : Type uF
inst✝¹⁴ : NormedAddCommGroup F✝
inst✝¹³ : NormedSpace 𝕜 F✝
G : Type uG
inst✝¹² : NormedAddCommGroup G
inst✝¹¹ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁰ : NormedAddCommGroup X
inst✝⁹ : 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✝
𝕂 : Type u_3
inst✝⁸ : IsROrC 𝕂
E' : Type u_4
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : NormedSpace 𝕂 E'
F' : Type u_5
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace 𝕂 F'
E : Type u_6
F : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
p : E → FormalMultilinearSeries ℝ E F
s : Set E
x : E
hf : HasFTaylorSeriesUpToOn 1 f p (insert x s)
hs : Convex ℝ s
K : ℝ≥0
hK : ‖p x 1‖₊ < K
f' : E → E →L[ℝ] F := fun y => ↑(continuousMultilinearCurryFin1 ℝ E F) (p y 1)
hder : ∀ (y : E), y ∈ s → HasFDerivWithinAt f (f' y) s y
⊢ ∃ t, t ∈ 𝓝[s] x ∧ LipschitzOnWith K f t
[PROOFSTEP]
have hcont : ContinuousWithinAt f' s x :=
(continuousMultilinearCurryFin1 ℝ E F).continuousAt.comp_continuousWithinAt
((hf.cont _ le_rfl _ (mem_insert _ _)).mono (subset_insert x s))
[GOAL]
𝕜 : Type u_1
inst✝¹⁹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁸ : NormedAddCommGroup D
inst✝¹⁷ : NormedSpace 𝕜 D
E✝ : Type uE
inst✝¹⁶ : NormedAddCommGroup E✝
inst✝¹⁵ : NormedSpace 𝕜 E✝
F✝ : Type uF
inst✝¹⁴ : NormedAddCommGroup F✝
inst✝¹³ : NormedSpace 𝕜 F✝
G : Type uG
inst✝¹² : NormedAddCommGroup G
inst✝¹¹ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁰ : NormedAddCommGroup X
inst✝⁹ : 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✝
𝕂 : Type u_3
inst✝⁸ : IsROrC 𝕂
E' : Type u_4
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : NormedSpace 𝕂 E'
F' : Type u_5
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace 𝕂 F'
E : Type u_6
F : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
p : E → FormalMultilinearSeries ℝ E F
s : Set E
x : E
hf : HasFTaylorSeriesUpToOn 1 f p (insert x s)
hs : Convex ℝ s
K : ℝ≥0
hK : ‖p x 1‖₊ < K
f' : E → E →L[ℝ] F := fun y => ↑(continuousMultilinearCurryFin1 ℝ E F) (p y 1)
hder : ∀ (y : E), y ∈ s → HasFDerivWithinAt f (f' y) s y
hcont : ContinuousWithinAt f' s x
⊢ ∃ t, t ∈ 𝓝[s] x ∧ LipschitzOnWith K f t
[PROOFSTEP]
replace hK : ‖f' x‖₊ < K
[GOAL]
case hK
𝕜 : Type u_1
inst✝¹⁹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁸ : NormedAddCommGroup D
inst✝¹⁷ : NormedSpace 𝕜 D
E✝ : Type uE
inst✝¹⁶ : NormedAddCommGroup E✝
inst✝¹⁵ : NormedSpace 𝕜 E✝
F✝ : Type uF
inst✝¹⁴ : NormedAddCommGroup F✝
inst✝¹³ : NormedSpace 𝕜 F✝
G : Type uG
inst✝¹² : NormedAddCommGroup G
inst✝¹¹ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁰ : NormedAddCommGroup X
inst✝⁹ : 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✝
𝕂 : Type u_3
inst✝⁸ : IsROrC 𝕂
E' : Type u_4
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : NormedSpace 𝕂 E'
F' : Type u_5
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace 𝕂 F'
E : Type u_6
F : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
p : E → FormalMultilinearSeries ℝ E F
s : Set E
x : E
hf : HasFTaylorSeriesUpToOn 1 f p (insert x s)
hs : Convex ℝ s
K : ℝ≥0
hK : ‖p x 1‖₊ < K
f' : E → E →L[ℝ] F := fun y => ↑(continuousMultilinearCurryFin1 ℝ E F) (p y 1)
hder : ∀ (y : E), y ∈ s → HasFDerivWithinAt f (f' y) s y
hcont : ContinuousWithinAt f' s x
⊢ ‖f' x‖₊ < K
[PROOFSTEP]
simpa only [LinearIsometryEquiv.nnnorm_map]
[GOAL]
𝕜 : Type u_1
inst✝¹⁹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁸ : NormedAddCommGroup D
inst✝¹⁷ : NormedSpace 𝕜 D
E✝ : Type uE
inst✝¹⁶ : NormedAddCommGroup E✝
inst✝¹⁵ : NormedSpace 𝕜 E✝
F✝ : Type uF
inst✝¹⁴ : NormedAddCommGroup F✝
inst✝¹³ : NormedSpace 𝕜 F✝
G : Type uG
inst✝¹² : NormedAddCommGroup G
inst✝¹¹ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁰ : NormedAddCommGroup X
inst✝⁹ : 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✝
𝕂 : Type u_3
inst✝⁸ : IsROrC 𝕂
E' : Type u_4
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : NormedSpace 𝕂 E'
F' : Type u_5
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace 𝕂 F'
E : Type u_6
F : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
p : E → FormalMultilinearSeries ℝ E F
s : Set E
x : E
hf : HasFTaylorSeriesUpToOn 1 f p (insert x s)
hs : Convex ℝ s
K : ℝ≥0
f' : E → E →L[ℝ] F := fun y => ↑(continuousMultilinearCurryFin1 ℝ E F) (p y 1)
hder : ∀ (y : E), y ∈ s → HasFDerivWithinAt f (f' y) s y
hcont : ContinuousWithinAt f' s x
hK : ‖f' x‖₊ < K
⊢ ∃ t, t ∈ 𝓝[s] x ∧ LipschitzOnWith K f t
[PROOFSTEP]
exact
hs.exists_nhdsWithin_lipschitzOnWith_of_hasFDerivWithinAt_of_nnnorm_lt
(eventually_nhdsWithin_iff.2 <| eventually_of_forall hder) hcont K hK
[GOAL]
𝕜 : Type u_1
inst✝¹⁹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁸ : NormedAddCommGroup D
inst✝¹⁷ : NormedSpace 𝕜 D
E✝ : Type uE
inst✝¹⁶ : NormedAddCommGroup E✝
inst✝¹⁵ : NormedSpace 𝕜 E✝
F✝ : Type uF
inst✝¹⁴ : NormedAddCommGroup F✝
inst✝¹³ : NormedSpace 𝕜 F✝
G : Type uG
inst✝¹² : NormedAddCommGroup G
inst✝¹¹ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁰ : NormedAddCommGroup X
inst✝⁹ : 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✝
𝕂 : Type u_3
inst✝⁸ : IsROrC 𝕂
E' : Type u_4
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : NormedSpace 𝕂 E'
F' : Type u_5
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace 𝕂 F'
E : Type u_6
F : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
s : Set E
x : E
hf : ContDiffWithinAt ℝ 1 f s x
hs : Convex ℝ s
⊢ ∃ K t, t ∈ 𝓝[s] x ∧ LipschitzOnWith K f t
[PROOFSTEP]
rcases hf 1 le_rfl with ⟨t, hst, p, hp⟩
[GOAL]
case intro.intro.intro
𝕜 : Type u_1
inst✝¹⁹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁸ : NormedAddCommGroup D
inst✝¹⁷ : NormedSpace 𝕜 D
E✝ : Type uE
inst✝¹⁶ : NormedAddCommGroup E✝
inst✝¹⁵ : NormedSpace 𝕜 E✝
F✝ : Type uF
inst✝¹⁴ : NormedAddCommGroup F✝
inst✝¹³ : NormedSpace 𝕜 F✝
G : Type uG
inst✝¹² : NormedAddCommGroup G
inst✝¹¹ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁰ : NormedAddCommGroup X
inst✝⁹ : 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✝
𝕂 : Type u_3
inst✝⁸ : IsROrC 𝕂
E' : Type u_4
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : NormedSpace 𝕂 E'
F' : Type u_5
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace 𝕂 F'
E : Type u_6
F : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
s : Set E
x : E
hf : ContDiffWithinAt ℝ 1 f s x
hs : Convex ℝ s
t : Set E
hst : t ∈ 𝓝[insert x s] x
p : E → FormalMultilinearSeries ℝ E F
hp : HasFTaylorSeriesUpToOn (↑1) f p t
⊢ ∃ K t, t ∈ 𝓝[s] x ∧ LipschitzOnWith K f t
[PROOFSTEP]
rcases Metric.mem_nhdsWithin_iff.mp hst with ⟨ε, ε0, hε⟩
[GOAL]
case intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝¹⁹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁸ : NormedAddCommGroup D
inst✝¹⁷ : NormedSpace 𝕜 D
E✝ : Type uE
inst✝¹⁶ : NormedAddCommGroup E✝
inst✝¹⁵ : NormedSpace 𝕜 E✝
F✝ : Type uF
inst✝¹⁴ : NormedAddCommGroup F✝
inst✝¹³ : NormedSpace 𝕜 F✝
G : Type uG
inst✝¹² : NormedAddCommGroup G
inst✝¹¹ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁰ : NormedAddCommGroup X
inst✝⁹ : 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✝
𝕂 : Type u_3
inst✝⁸ : IsROrC 𝕂
E' : Type u_4
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : NormedSpace 𝕂 E'
F' : Type u_5
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace 𝕂 F'
E : Type u_6
F : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
s : Set E
x : E
hf : ContDiffWithinAt ℝ 1 f s x
hs : Convex ℝ s
t : Set E
hst : t ∈ 𝓝[insert x s] x
p : E → FormalMultilinearSeries ℝ E F
hp : HasFTaylorSeriesUpToOn (↑1) f p t
ε : ℝ
ε0 : ε > 0
hε : Metric.ball x ε ∩ insert x s ⊆ t
⊢ ∃ K t, t ∈ 𝓝[s] x ∧ LipschitzOnWith K f t
[PROOFSTEP]
replace hp : HasFTaylorSeriesUpToOn 1 f p (Metric.ball x ε ∩ insert x s) := hp.mono hε
[GOAL]
case intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝¹⁹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁸ : NormedAddCommGroup D
inst✝¹⁷ : NormedSpace 𝕜 D
E✝ : Type uE
inst✝¹⁶ : NormedAddCommGroup E✝
inst✝¹⁵ : NormedSpace 𝕜 E✝
F✝ : Type uF
inst✝¹⁴ : NormedAddCommGroup F✝
inst✝¹³ : NormedSpace 𝕜 F✝
G : Type uG
inst✝¹² : NormedAddCommGroup G
inst✝¹¹ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁰ : NormedAddCommGroup X
inst✝⁹ : 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✝
𝕂 : Type u_3
inst✝⁸ : IsROrC 𝕂
E' : Type u_4
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : NormedSpace 𝕂 E'
F' : Type u_5
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace 𝕂 F'
E : Type u_6
F : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
s : Set E
x : E
hf : ContDiffWithinAt ℝ 1 f s x
hs : Convex ℝ s
t : Set E
hst : t ∈ 𝓝[insert x s] x
p : E → FormalMultilinearSeries ℝ E F
ε : ℝ
ε0 : ε > 0
hε : Metric.ball x ε ∩ insert x s ⊆ t
hp : HasFTaylorSeriesUpToOn 1 f p (Metric.ball x ε ∩ insert x s)
⊢ ∃ K t, t ∈ 𝓝[s] x ∧ LipschitzOnWith K f t
[PROOFSTEP]
clear hst hε t
[GOAL]
case intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝¹⁹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁸ : NormedAddCommGroup D
inst✝¹⁷ : NormedSpace 𝕜 D
E✝ : Type uE
inst✝¹⁶ : NormedAddCommGroup E✝
inst✝¹⁵ : NormedSpace 𝕜 E✝
F✝ : Type uF
inst✝¹⁴ : NormedAddCommGroup F✝
inst✝¹³ : NormedSpace 𝕜 F✝
G : Type uG
inst✝¹² : NormedAddCommGroup G
inst✝¹¹ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁰ : NormedAddCommGroup X
inst✝⁹ : 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✝
𝕂 : Type u_3
inst✝⁸ : IsROrC 𝕂
E' : Type u_4
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : NormedSpace 𝕂 E'
F' : Type u_5
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace 𝕂 F'
E : Type u_6
F : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
s : Set E
x : E
hf : ContDiffWithinAt ℝ 1 f s x
hs : Convex ℝ s
p : E → FormalMultilinearSeries ℝ E F
ε : ℝ
ε0 : ε > 0
hp : HasFTaylorSeriesUpToOn 1 f p (Metric.ball x ε ∩ insert x s)
⊢ ∃ K t, t ∈ 𝓝[s] x ∧ LipschitzOnWith K f t
[PROOFSTEP]
rw [← insert_eq_of_mem (Metric.mem_ball_self ε0), ← insert_inter_distrib] at hp
[GOAL]
case intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝¹⁹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁸ : NormedAddCommGroup D
inst✝¹⁷ : NormedSpace 𝕜 D
E✝ : Type uE
inst✝¹⁶ : NormedAddCommGroup E✝
inst✝¹⁵ : NormedSpace 𝕜 E✝
F✝ : Type uF
inst✝¹⁴ : NormedAddCommGroup F✝
inst✝¹³ : NormedSpace 𝕜 F✝
G : Type uG
inst✝¹² : NormedAddCommGroup G
inst✝¹¹ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁰ : NormedAddCommGroup X
inst✝⁹ : 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✝
𝕂 : Type u_3
inst✝⁸ : IsROrC 𝕂
E' : Type u_4
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : NormedSpace 𝕂 E'
F' : Type u_5
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace 𝕂 F'
E : Type u_6
F : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
s : Set E
x : E
hf : ContDiffWithinAt ℝ 1 f s x
hs : Convex ℝ s
p : E → FormalMultilinearSeries ℝ E F
ε : ℝ
ε0 : ε > 0
hp : HasFTaylorSeriesUpToOn 1 f p (insert x (Metric.ball x ε ∩ s))
⊢ ∃ K t, t ∈ 𝓝[s] x ∧ LipschitzOnWith K f t
[PROOFSTEP]
rcases hp.exists_lipschitzOnWith ((convex_ball _ _).inter hs) with ⟨K, t, hst, hft⟩
[GOAL]
case intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝¹⁹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁸ : NormedAddCommGroup D
inst✝¹⁷ : NormedSpace 𝕜 D
E✝ : Type uE
inst✝¹⁶ : NormedAddCommGroup E✝
inst✝¹⁵ : NormedSpace 𝕜 E✝
F✝ : Type uF
inst✝¹⁴ : NormedAddCommGroup F✝
inst✝¹³ : NormedSpace 𝕜 F✝
G : Type uG
inst✝¹² : NormedAddCommGroup G
inst✝¹¹ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁰ : NormedAddCommGroup X
inst✝⁹ : 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✝
𝕂 : Type u_3
inst✝⁸ : IsROrC 𝕂
E' : Type u_4
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : NormedSpace 𝕂 E'
F' : Type u_5
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace 𝕂 F'
E : Type u_6
F : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
s : Set E
x : E
hf : ContDiffWithinAt ℝ 1 f s x
hs : Convex ℝ s
p : E → FormalMultilinearSeries ℝ E F
ε : ℝ
ε0 : ε > 0
hp : HasFTaylorSeriesUpToOn 1 f p (insert x (Metric.ball x ε ∩ s))
K : ℝ≥0
t : Set E
hst : t ∈ 𝓝[Metric.ball x ε ∩ s] x
hft : LipschitzOnWith K f t
⊢ ∃ K t, t ∈ 𝓝[s] x ∧ LipschitzOnWith K f t
[PROOFSTEP]
rw [inter_comm, ← nhdsWithin_restrict' _ (Metric.ball_mem_nhds _ ε0)] at hst
[GOAL]
case intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
inst✝¹⁹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁸ : NormedAddCommGroup D
inst✝¹⁷ : NormedSpace 𝕜 D
E✝ : Type uE
inst✝¹⁶ : NormedAddCommGroup E✝
inst✝¹⁵ : NormedSpace 𝕜 E✝
F✝ : Type uF
inst✝¹⁴ : NormedAddCommGroup F✝
inst✝¹³ : NormedSpace 𝕜 F✝
G : Type uG
inst✝¹² : NormedAddCommGroup G
inst✝¹¹ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁰ : NormedAddCommGroup X
inst✝⁹ : 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✝
𝕂 : Type u_3
inst✝⁸ : IsROrC 𝕂
E' : Type u_4
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : NormedSpace 𝕂 E'
F' : Type u_5
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace 𝕂 F'
E : Type u_6
F : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
s : Set E
x : E
hf : ContDiffWithinAt ℝ 1 f s x
hs : Convex ℝ s
p : E → FormalMultilinearSeries ℝ E F
ε : ℝ
ε0 : ε > 0
hp : HasFTaylorSeriesUpToOn 1 f p (insert x (Metric.ball x ε ∩ s))
K : ℝ≥0
t : Set E
hst : t ∈ 𝓝[s] x
hft : LipschitzOnWith K f t
⊢ ∃ K t, t ∈ 𝓝[s] x ∧ LipschitzOnWith K f t
[PROOFSTEP]
exact ⟨K, t, hst, hft⟩
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : UniqueDiffOn 𝕜 s₂
⊢ ContDiffOn 𝕜 (↑(n + 1)) f₂ s₂ ↔ DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 (↑n) (derivWithin f₂ s₂) s₂
[PROOFSTEP]
rw [contDiffOn_succ_iff_fderivWithin hs, and_congr_right_iff]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : UniqueDiffOn 𝕜 s₂
⊢ DifferentiableOn 𝕜 f₂ s₂ →
(ContDiffOn 𝕜 (↑n) (fun y => fderivWithin 𝕜 f₂ s₂ y) s₂ ↔ ContDiffOn 𝕜 (↑n) (derivWithin f₂ s₂) s₂)
[PROOFSTEP]
intro _
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : UniqueDiffOn 𝕜 s₂
a✝ : DifferentiableOn 𝕜 f₂ s₂
⊢ ContDiffOn 𝕜 (↑n) (fun y => fderivWithin 𝕜 f₂ s₂ y) s₂ ↔ ContDiffOn 𝕜 (↑n) (derivWithin f₂ s₂) s₂
[PROOFSTEP]
constructor
[GOAL]
case mp
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : UniqueDiffOn 𝕜 s₂
a✝ : DifferentiableOn 𝕜 f₂ s₂
⊢ ContDiffOn 𝕜 (↑n) (fun y => fderivWithin 𝕜 f₂ s₂ y) s₂ → ContDiffOn 𝕜 (↑n) (derivWithin f₂ s₂) s₂
[PROOFSTEP]
intro h
[GOAL]
case mp
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : UniqueDiffOn 𝕜 s₂
a✝ : DifferentiableOn 𝕜 f₂ s₂
h : ContDiffOn 𝕜 (↑n) (fun y => fderivWithin 𝕜 f₂ s₂ y) s₂
⊢ ContDiffOn 𝕜 (↑n) (derivWithin f₂ s₂) s₂
[PROOFSTEP]
have : derivWithin f₂ s₂ = (fun u : 𝕜 →L[𝕜] F => u 1) ∘ fderivWithin 𝕜 f₂ s₂
[GOAL]
case this
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : UniqueDiffOn 𝕜 s₂
a✝ : DifferentiableOn 𝕜 f₂ s₂
h : ContDiffOn 𝕜 (↑n) (fun y => fderivWithin 𝕜 f₂ s₂ y) s₂
⊢ derivWithin f₂ s₂ = (fun u => ↑u 1) ∘ fderivWithin 𝕜 f₂ s₂
[PROOFSTEP]
ext x
[GOAL]
case this.h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : UniqueDiffOn 𝕜 s₂
a✝ : DifferentiableOn 𝕜 f₂ s₂
h : ContDiffOn 𝕜 (↑n) (fun y => fderivWithin 𝕜 f₂ s₂ y) s₂
x : 𝕜
⊢ derivWithin f₂ s₂ x = ((fun u => ↑u 1) ∘ fderivWithin 𝕜 f₂ s₂) x
[PROOFSTEP]
rfl
[GOAL]
case mp
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : UniqueDiffOn 𝕜 s₂
a✝ : DifferentiableOn 𝕜 f₂ s₂
h : ContDiffOn 𝕜 (↑n) (fun y => fderivWithin 𝕜 f₂ s₂ y) s₂
this : derivWithin f₂ s₂ = (fun u => ↑u 1) ∘ fderivWithin 𝕜 f₂ s₂
⊢ ContDiffOn 𝕜 (↑n) (derivWithin f₂ s₂) s₂
[PROOFSTEP]
simp_rw [this]
[GOAL]
case mp
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : UniqueDiffOn 𝕜 s₂
a✝ : DifferentiableOn 𝕜 f₂ s₂
h : ContDiffOn 𝕜 (↑n) (fun y => fderivWithin 𝕜 f₂ s₂ y) s₂
this : derivWithin f₂ s₂ = (fun u => ↑u 1) ∘ fderivWithin 𝕜 f₂ s₂
⊢ ContDiffOn 𝕜 (↑n) ((fun u => ↑u 1) ∘ fderivWithin 𝕜 f₂ s₂) s₂
[PROOFSTEP]
apply ContDiff.comp_contDiffOn _ h
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : UniqueDiffOn 𝕜 s₂
a✝ : DifferentiableOn 𝕜 f₂ s₂
h : ContDiffOn 𝕜 (↑n) (fun y => fderivWithin 𝕜 f₂ s₂ y) s₂
this : derivWithin f₂ s₂ = (fun u => ↑u 1) ∘ fderivWithin 𝕜 f₂ s₂
⊢ ContDiff 𝕜 ↑n fun u => ↑u 1
[PROOFSTEP]
exact (isBoundedBilinearMapApply.isBoundedLinearMap_left _).contDiff
[GOAL]
case mpr
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : UniqueDiffOn 𝕜 s₂
a✝ : DifferentiableOn 𝕜 f₂ s₂
⊢ ContDiffOn 𝕜 (↑n) (derivWithin f₂ s₂) s₂ → ContDiffOn 𝕜 (↑n) (fun y => fderivWithin 𝕜 f₂ s₂ y) s₂
[PROOFSTEP]
intro h
[GOAL]
case mpr
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : UniqueDiffOn 𝕜 s₂
a✝ : DifferentiableOn 𝕜 f₂ s₂
h : ContDiffOn 𝕜 (↑n) (derivWithin f₂ s₂) s₂
⊢ ContDiffOn 𝕜 (↑n) (fun y => fderivWithin 𝕜 f₂ s₂ y) s₂
[PROOFSTEP]
have : fderivWithin 𝕜 f₂ s₂ = smulRight (1 : 𝕜 →L[𝕜] 𝕜) ∘ derivWithin f₂ s₂
[GOAL]
case this
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : UniqueDiffOn 𝕜 s₂
a✝ : DifferentiableOn 𝕜 f₂ s₂
h : ContDiffOn 𝕜 (↑n) (derivWithin f₂ s₂) s₂
⊢ fderivWithin 𝕜 f₂ s₂ = smulRight 1 ∘ derivWithin f₂ s₂
[PROOFSTEP]
ext x
[GOAL]
case this.h.h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : UniqueDiffOn 𝕜 s₂
a✝ : DifferentiableOn 𝕜 f₂ s₂
h : ContDiffOn 𝕜 (↑n) (derivWithin f₂ s₂) s₂
x : 𝕜
⊢ ↑(fderivWithin 𝕜 f₂ s₂ x) 1 = ↑((smulRight 1 ∘ derivWithin f₂ s₂) x) 1
[PROOFSTEP]
simp [derivWithin]
[GOAL]
case mpr
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : UniqueDiffOn 𝕜 s₂
a✝ : DifferentiableOn 𝕜 f₂ s₂
h : ContDiffOn 𝕜 (↑n) (derivWithin f₂ s₂) s₂
this : fderivWithin 𝕜 f₂ s₂ = smulRight 1 ∘ derivWithin f₂ s₂
⊢ ContDiffOn 𝕜 (↑n) (fun y => fderivWithin 𝕜 f₂ s₂ y) s₂
[PROOFSTEP]
simp only [this]
[GOAL]
case mpr
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : UniqueDiffOn 𝕜 s₂
a✝ : DifferentiableOn 𝕜 f₂ s₂
h : ContDiffOn 𝕜 (↑n) (derivWithin f₂ s₂) s₂
this : fderivWithin 𝕜 f₂ s₂ = smulRight 1 ∘ derivWithin f₂ s₂
⊢ ContDiffOn 𝕜 (↑n) (fun y => (smulRight 1 ∘ derivWithin f₂ s₂) y) s₂
[PROOFSTEP]
apply ContDiff.comp_contDiffOn _ h
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : UniqueDiffOn 𝕜 s₂
a✝ : DifferentiableOn 𝕜 f₂ s₂
h : ContDiffOn 𝕜 (↑n) (derivWithin f₂ s₂) s₂
this : fderivWithin 𝕜 f₂ s₂ = smulRight 1 ∘ derivWithin f₂ s₂
⊢ ContDiff 𝕜 (↑n) (smulRight 1)
[PROOFSTEP]
have : IsBoundedBilinearMap 𝕜 fun _ : (𝕜 →L[𝕜] 𝕜) × F => _ := isBoundedBilinearMap_smulRight
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : UniqueDiffOn 𝕜 s₂
a✝ : DifferentiableOn 𝕜 f₂ s₂
h : ContDiffOn 𝕜 (↑n) (derivWithin f₂ s₂) s₂
this✝ : fderivWithin 𝕜 f₂ s₂ = smulRight 1 ∘ derivWithin f₂ s₂
this : IsBoundedBilinearMap 𝕜 fun x => smulRight x.fst x.snd
⊢ ContDiff 𝕜 (↑n) (smulRight 1)
[PROOFSTEP]
exact (this.isBoundedLinearMap_right _).contDiff
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : IsOpen s₂
⊢ ContDiffOn 𝕜 (↑(n + 1)) f₂ s₂ ↔ DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 (↑n) (deriv f₂) s₂
[PROOFSTEP]
rw [contDiffOn_succ_iff_derivWithin hs.uniqueDiffOn]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
hs : IsOpen s₂
⊢ DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 (↑n) (derivWithin f₂ s₂) s₂ ↔
DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 (↑n) (deriv f₂) s₂
[PROOFSTEP]
exact Iff.rfl.and (contDiffOn_congr fun _ => derivWithin_of_open hs)
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
hs : UniqueDiffOn 𝕜 s₂
⊢ ContDiffOn 𝕜 ⊤ f₂ s₂ ↔ DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (derivWithin f₂ s₂) s₂
[PROOFSTEP]
constructor
[GOAL]
case mp
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
hs : UniqueDiffOn 𝕜 s₂
⊢ ContDiffOn 𝕜 ⊤ f₂ s₂ → DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (derivWithin f₂ s₂) s₂
[PROOFSTEP]
intro h
[GOAL]
case mp
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
hs : UniqueDiffOn 𝕜 s₂
h : ContDiffOn 𝕜 ⊤ f₂ s₂
⊢ DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (derivWithin f₂ s₂) s₂
[PROOFSTEP]
refine' ⟨h.differentiableOn le_top, _⟩
[GOAL]
case mp
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
hs : UniqueDiffOn 𝕜 s₂
h : ContDiffOn 𝕜 ⊤ f₂ s₂
⊢ ContDiffOn 𝕜 ⊤ (derivWithin f₂ s₂) s₂
[PROOFSTEP]
refine contDiffOn_top.2 fun n => ((contDiffOn_succ_iff_derivWithin hs).1 ?_).2
[GOAL]
case mp
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
hs : UniqueDiffOn 𝕜 s₂
h : ContDiffOn 𝕜 ⊤ f₂ s₂
n : ℕ
⊢ ContDiffOn 𝕜 (↑(n + 1)) f₂ s₂
[PROOFSTEP]
exact h.of_le le_top
[GOAL]
case mpr
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
hs : UniqueDiffOn 𝕜 s₂
⊢ DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (derivWithin f₂ s₂) s₂ → ContDiffOn 𝕜 ⊤ f₂ s₂
[PROOFSTEP]
intro h
[GOAL]
case mpr
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
hs : UniqueDiffOn 𝕜 s₂
h : DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (derivWithin f₂ s₂) s₂
⊢ ContDiffOn 𝕜 ⊤ f₂ s₂
[PROOFSTEP]
refine' contDiffOn_top.2 fun n => _
[GOAL]
case mpr
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
hs : UniqueDiffOn 𝕜 s₂
h : DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (derivWithin f₂ s₂) s₂
n : ℕ
⊢ ContDiffOn 𝕜 (↑n) f₂ s₂
[PROOFSTEP]
have A : (n : ℕ∞) ≤ ∞ := le_top
[GOAL]
case mpr
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
hs : UniqueDiffOn 𝕜 s₂
h : DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (derivWithin f₂ s₂) s₂
n : ℕ
A : ↑n ≤ ⊤
⊢ ContDiffOn 𝕜 (↑n) f₂ s₂
[PROOFSTEP]
apply ((contDiffOn_succ_iff_derivWithin hs).2 ⟨h.1, h.2.of_le A⟩).of_le
[GOAL]
case mpr
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
hs : UniqueDiffOn 𝕜 s₂
h : DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (derivWithin f₂ s₂) s₂
n : ℕ
A : ↑n ≤ ⊤
⊢ ↑n ≤ ↑(n + 1)
[PROOFSTEP]
exact WithTop.coe_le_coe.2 (Nat.le_succ n)
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
hs : IsOpen s₂
⊢ ContDiffOn 𝕜 ⊤ f₂ s₂ ↔ DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (deriv f₂) s₂
[PROOFSTEP]
rw [contDiffOn_top_iff_derivWithin hs.uniqueDiffOn]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
hs : IsOpen s₂
⊢ DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (derivWithin f₂ s₂) s₂ ↔
DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (deriv f₂) s₂
[PROOFSTEP]
exact Iff.rfl.and <| contDiffOn_congr fun _ => derivWithin_of_open hs
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
hf : ContDiffOn 𝕜 n f₂ s₂
hs : UniqueDiffOn 𝕜 s₂
hmn : m + 1 ≤ n
⊢ ContDiffOn 𝕜 m (derivWithin f₂ s₂) s₂
[PROOFSTEP]
cases m
[GOAL]
case none
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
hf : ContDiffOn 𝕜 n f₂ s₂
hs : UniqueDiffOn 𝕜 s₂
hmn : none + 1 ≤ n
⊢ ContDiffOn 𝕜 none (derivWithin f₂ s₂) s₂
[PROOFSTEP]
change ∞ + 1 ≤ n at hmn
[GOAL]
case none
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
hf : ContDiffOn 𝕜 n f₂ s₂
hs : UniqueDiffOn 𝕜 s₂
hmn : ⊤ + 1 ≤ n
⊢ ContDiffOn 𝕜 none (derivWithin f₂ s₂) s₂
[PROOFSTEP]
have : n = ∞ := by simpa using hmn
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
hf : ContDiffOn 𝕜 n f₂ s₂
hs : UniqueDiffOn 𝕜 s₂
hmn : ⊤ + 1 ≤ n
⊢ n = ⊤
[PROOFSTEP]
simpa using hmn
[GOAL]
case none
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
hf : ContDiffOn 𝕜 n f₂ s₂
hs : UniqueDiffOn 𝕜 s₂
hmn : ⊤ + 1 ≤ n
this : n = ⊤
⊢ ContDiffOn 𝕜 none (derivWithin f₂ s₂) s₂
[PROOFSTEP]
rw [this] at hf
[GOAL]
case none
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
hf : ContDiffOn 𝕜 ⊤ f₂ s₂
hs : UniqueDiffOn 𝕜 s₂
hmn : ⊤ + 1 ≤ n
this : n = ⊤
⊢ ContDiffOn 𝕜 none (derivWithin f₂ s₂) s₂
[PROOFSTEP]
exact ((contDiffOn_top_iff_derivWithin hs).1 hf).2
[GOAL]
case some
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
hf : ContDiffOn 𝕜 n f₂ s₂
hs : UniqueDiffOn 𝕜 s₂
val✝ : ℕ
hmn : some val✝ + 1 ≤ n
⊢ ContDiffOn 𝕜 (some val✝) (derivWithin f₂ s₂) s₂
[PROOFSTEP]
change (Nat.succ _ : ℕ∞) ≤ n at hmn
[GOAL]
case some
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
hf : ContDiffOn 𝕜 n f₂ s₂
hs : UniqueDiffOn 𝕜 s₂
val✝ : ℕ
hmn : ↑(Nat.succ val✝) ≤ n
⊢ ContDiffOn 𝕜 (some val✝) (derivWithin f₂ s₂) s₂
[PROOFSTEP]
exact ((contDiffOn_succ_iff_derivWithin hs).1 (hf.of_le hmn)).2
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
⊢ ContDiff 𝕜 (↑(n + 1)) f₂ ↔ Differentiable 𝕜 f₂ ∧ ContDiff 𝕜 (↑n) (deriv f₂)
[PROOFSTEP]
simp only [← contDiffOn_univ, contDiffOn_succ_iff_deriv_of_open, isOpen_univ, differentiableOn_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
⊢ ContDiff 𝕜 ⊤ f₂ ↔ Differentiable 𝕜 f₂ ∧ ContDiff 𝕜 ⊤ (deriv f₂)
[PROOFSTEP]
simp only [← contDiffOn_univ, ← differentiableOn_univ, ← derivWithin_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f₂ : 𝕜 → F
s₂ : Set 𝕜
⊢ ContDiffOn 𝕜 ⊤ f₂ univ ↔ DifferentiableOn 𝕜 f₂ univ ∧ ContDiffOn 𝕜 ⊤ (derivWithin f₂ univ) univ
[PROOFSTEP]
rw [contDiffOn_top_iff_derivWithin uniqueDiffOn_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁵ : NormedAddCommGroup D
inst✝¹⁴ : NormedSpace 𝕜 D
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
𝕜' : Type u_3
inst✝⁵ : NontriviallyNormedField 𝕜'
inst✝⁴ : NormedAlgebra 𝕜 𝕜'
inst✝³ : NormedSpace 𝕜' E
inst✝² : IsScalarTower 𝕜 𝕜' E
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
p' : E → FormalMultilinearSeries 𝕜' E F
h : HasFTaylorSeriesUpToOn n f p' s
m : ℕ
hm : ↑m < n
x : E
hx : x ∈ s
⊢ HasFDerivWithinAt (fun x => FormalMultilinearSeries.restrictScalars 𝕜 (p' x) m)
(ContinuousMultilinearMap.curryLeft (FormalMultilinearSeries.restrictScalars 𝕜 (p' x) (Nat.succ m))) s x
[PROOFSTEP]
simpa only using
-- porting note: added `by simpa only using`(ContinuousMultilinearMap.restrictScalarsLinear
𝕜).hasFDerivAt.comp_hasFDerivWithinAt
x <|
(h.fderivWithin m hm x hx).restrictScalars 𝕜
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁵ : NormedAddCommGroup D
inst✝¹⁴ : NormedSpace 𝕜 D
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
𝕜' : Type u_3
inst✝⁵ : NontriviallyNormedField 𝕜'
inst✝⁴ : NormedAlgebra 𝕜 𝕜'
inst✝³ : NormedSpace 𝕜' E
inst✝² : IsScalarTower 𝕜 𝕜' E
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
p' : E → FormalMultilinearSeries 𝕜' E F
h : ContDiffWithinAt 𝕜' n f s x
m : ℕ
hm : ↑m ≤ n
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) f p u
[PROOFSTEP]
rcases h m hm with ⟨u, u_mem, p', hp'⟩
[GOAL]
case intro.intro.intro
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁵ : NormedAddCommGroup D
inst✝¹⁴ : NormedSpace 𝕜 D
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
𝕜' : Type u_3
inst✝⁵ : NontriviallyNormedField 𝕜'
inst✝⁴ : NormedAlgebra 𝕜 𝕜'
inst✝³ : NormedSpace 𝕜' E
inst✝² : IsScalarTower 𝕜 𝕜' E
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
p'✝ : E → FormalMultilinearSeries 𝕜' E F
h : ContDiffWithinAt 𝕜' n f s x
m : ℕ
hm : ↑m ≤ n
u : Set E
u_mem : u ∈ 𝓝[insert x s] x
p' : E → FormalMultilinearSeries 𝕜' E F
hp' : HasFTaylorSeriesUpToOn (↑m) f p' u
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) f p u
[PROOFSTEP]
exact ⟨u, u_mem, _, hp'.restrictScalars _⟩
[GOAL]
𝕜 : Type u_1
inst✝¹⁸ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁷ : NormedAddCommGroup D
inst✝¹⁶ : NormedSpace 𝕜 D
E : Type uE
inst✝¹⁵ : NormedAddCommGroup E
inst✝¹⁴ : NormedSpace 𝕜 E
F : Type uF
inst✝¹³ : NormedAddCommGroup F
inst✝¹² : NormedSpace 𝕜 F
G : Type uG
inst✝¹¹ : NormedAddCommGroup G
inst✝¹⁰ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁹ : NormedAddCommGroup X
inst✝⁸ : 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
Du Eu Fu Gu : Type u
inst✝⁷ : NormedAddCommGroup Du
inst✝⁶ : NormedSpace 𝕜 Du
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
n : ℕ
s : Set Du
x : Du
hf : ContDiffOn 𝕜 (↑n) f s
hg : ContDiffOn 𝕜 (↑n) g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
induction' n with n IH generalizing Eu Fu Gu
[GOAL]
case zero
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑Nat.zero) f s
hg : ContDiffOn 𝕜 (↑Nat.zero) g s
⊢ ‖iteratedFDerivWithin 𝕜 Nat.zero (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (Nat.zero + 1),
↑(Nat.choose Nat.zero i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (Nat.zero - i) g s x‖
[PROOFSTEP]
simp only [Nat.zero_eq, norm_iteratedFDerivWithin_zero, zero_add, Finset.range_one, Finset.sum_singleton,
Nat.choose_self, Nat.cast_one, one_mul, Nat.sub_zero, ← mul_assoc]
[GOAL]
case zero
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑Nat.zero) f s
hg : ContDiffOn 𝕜 (↑Nat.zero) g s
⊢ ‖↑(↑B (f x)) (g x)‖ ≤ ‖B‖ * ‖f x‖ * ‖g x‖
[PROOFSTEP]
apply B.le_op_norm₂
[GOAL]
case succ
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
⊢ ‖iteratedFDerivWithin 𝕜 (Nat.succ n) (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (Nat.succ n + 1),
↑(Nat.choose (Nat.succ n) i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ *
‖iteratedFDerivWithin 𝕜 (Nat.succ n - i) g s x‖
[PROOFSTEP]
have In : (n : ℕ∞) + 1 ≤ n.succ := by
simp only [Nat.cast_succ, le_refl]
-- Porting note: the next line is a hack allowing Lean to find the operator norm instance.
[GOAL]
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
⊢ ↑n + 1 ≤ ↑(Nat.succ n)
[PROOFSTEP]
simp only [Nat.cast_succ, le_refl]
-- Porting note: the next line is a hack allowing Lean to find the operator norm instance.
[GOAL]
case succ
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
⊢ ‖iteratedFDerivWithin 𝕜 (Nat.succ n) (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (Nat.succ n + 1),
↑(Nat.choose (Nat.succ n) i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ *
‖iteratedFDerivWithin 𝕜 (Nat.succ n - i) g s x‖
[PROOFSTEP]
let norm := @ContinuousLinearMap.hasOpNorm _ _ Eu ((Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) _ _ _ _ _ _ (RingHom.id 𝕜)
[GOAL]
case succ
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
⊢ ‖iteratedFDerivWithin 𝕜 (Nat.succ n) (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (Nat.succ n + 1),
↑(Nat.choose (Nat.succ n) i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ *
‖iteratedFDerivWithin 𝕜 (Nat.succ n - i) g s x‖
[PROOFSTEP]
have I1 :
‖iteratedFDerivWithin 𝕜 n (fun y : Du => B.precompR Du (f y) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i : ℕ in Finset.range (n + 1),
n.choose i * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖ :=
by
calc
‖iteratedFDerivWithin 𝕜 n (fun y : Du => B.precompR Du (f y) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B.precompR Du‖ *
∑ i : ℕ in Finset.range (n + 1),
n.choose i * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 g s) s x‖ :=
IH _ (hf.of_le (Nat.cast_le.2 (Nat.le_succ n))) (hg.fderivWithin hs In)
_ ≤
‖B‖ *
∑ i : ℕ in Finset.range (n + 1),
n.choose i * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 g s) s x‖ :=
(mul_le_mul_of_nonneg_right (B.norm_precompR_le Du) (Finset.sum_nonneg' fun i => by positivity))
_ = _ := by
congr 1
apply Finset.sum_congr rfl fun i hi => ?_
rw [Nat.succ_sub (Nat.lt_succ_iff.1 (Finset.mem_range.1 hi)), ← norm_iteratedFDerivWithin_fderivWithin hs hx]
-- Porting note: the next line is a hack allowing Lean to find the operator norm instance.
[GOAL]
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
[PROOFSTEP]
calc
‖iteratedFDerivWithin 𝕜 n (fun y : Du => B.precompR Du (f y) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B.precompR Du‖ *
∑ i : ℕ in Finset.range (n + 1),
n.choose i * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 g s) s x‖ :=
IH _ (hf.of_le (Nat.cast_le.2 (Nat.le_succ n))) (hg.fderivWithin hs In)
_ ≤
‖B‖ *
∑ i : ℕ in Finset.range (n + 1),
n.choose i * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 g s) s x‖ :=
(mul_le_mul_of_nonneg_right (B.norm_precompR_le Du) (Finset.sum_nonneg' fun i => by positivity))
_ = _ := by
congr 1
apply Finset.sum_congr rfl fun i hi => ?_
rw [Nat.succ_sub (Nat.lt_succ_iff.1 (Finset.mem_range.1 hi)), ← norm_iteratedFDerivWithin_fderivWithin hs hx]
-- Porting note: the next line is a hack allowing Lean to find the operator norm instance.
[GOAL]
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
i : ℕ
⊢ 0 ≤ ↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 g s) s x‖
[PROOFSTEP]
positivity
[GOAL]
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
⊢ ‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ *
‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 g s) s x‖ =
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
[PROOFSTEP]
congr 1
[GOAL]
case e_a
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
⊢ ∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 g s) s x‖ =
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
[PROOFSTEP]
apply Finset.sum_congr rfl fun i hi => ?_
[GOAL]
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
i : ℕ
hi : i ∈ Finset.range (n + 1)
⊢ ↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 g s) s x‖ =
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
[PROOFSTEP]
rw [Nat.succ_sub (Nat.lt_succ_iff.1 (Finset.mem_range.1 hi)), ← norm_iteratedFDerivWithin_fderivWithin hs hx]
-- Porting note: the next line is a hack allowing Lean to find the operator norm instance.
[GOAL]
case succ
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
⊢ ‖iteratedFDerivWithin 𝕜 (Nat.succ n) (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (Nat.succ n + 1),
↑(Nat.choose (Nat.succ n) i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ *
‖iteratedFDerivWithin 𝕜 (Nat.succ n - i) g s x‖
[PROOFSTEP]
let norm := @ContinuousLinearMap.hasOpNorm _ _ (Du →L[𝕜] Eu) (Fu →L[𝕜] Du →L[𝕜] Gu) _ _ _ _ _ _ (RingHom.id 𝕜)
[GOAL]
case succ
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm✝ : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
norm : Norm ((Du →L[𝕜] Eu) →L[𝕜] Fu →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
⊢ ‖iteratedFDerivWithin 𝕜 (Nat.succ n) (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (Nat.succ n + 1),
↑(Nat.choose (Nat.succ n) i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ *
‖iteratedFDerivWithin 𝕜 (Nat.succ n - i) g s x‖
[PROOFSTEP]
have I2 :
‖iteratedFDerivWithin 𝕜 n (fun y : Du => B.precompL Du (fderivWithin 𝕜 f s y) (g y)) s x‖ ≤
‖B‖ *
∑ i : ℕ in Finset.range (n + 1),
n.choose i * ‖iteratedFDerivWithin 𝕜 (i + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖ :=
calc
‖iteratedFDerivWithin 𝕜 n (fun y : Du => B.precompL Du (fderivWithin 𝕜 f s y) (g y)) s x‖ ≤
‖B.precompL Du‖ *
∑ i : ℕ in Finset.range (n + 1),
n.choose i * ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 f s) s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖ :=
IH _ (hf.fderivWithin hs In) (hg.of_le (Nat.cast_le.2 (Nat.le_succ n)))
_ ≤
‖B‖ *
∑ i : ℕ in Finset.range (n + 1),
n.choose i * ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 f s) s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖ :=
(mul_le_mul_of_nonneg_right (B.norm_precompL_le Du) (Finset.sum_nonneg' fun i => by positivity))
_ = _ := by
congr 1
apply Finset.sum_congr rfl fun i _ => ?_
rw [← norm_iteratedFDerivWithin_fderivWithin hs hx]
[GOAL]
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm✝ : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
norm : Norm ((Du →L[𝕜] Eu) →L[𝕜] Fu →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
i : ℕ
⊢ 0 ≤ ↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 f s) s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
positivity
[GOAL]
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm✝ : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
norm : Norm ((Du →L[𝕜] Eu) →L[𝕜] Fu →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
⊢ ‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 f s) s x‖ *
‖iteratedFDerivWithin 𝕜 (n - i) g s x‖ =
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 (i + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
congr 1
[GOAL]
case e_a
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm✝ : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
norm : Norm ((Du →L[𝕜] Eu) →L[𝕜] Fu →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
⊢ ∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 f s) s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖ =
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 (i + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
apply Finset.sum_congr rfl fun i _ => ?_
[GOAL]
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm✝ : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
norm : Norm ((Du →L[𝕜] Eu) →L[𝕜] Fu →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
i : ℕ
x✝ : i ∈ Finset.range (n + 1)
⊢ ↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 f s) s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖ =
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 (i + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
rw [← norm_iteratedFDerivWithin_fderivWithin hs hx]
[GOAL]
case succ
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm✝ : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
norm : Norm ((Du →L[𝕜] Eu) →L[𝕜] Fu →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I2 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 (i + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
⊢ ‖iteratedFDerivWithin 𝕜 (Nat.succ n) (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (Nat.succ n + 1),
↑(Nat.choose (Nat.succ n) i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ *
‖iteratedFDerivWithin 𝕜 (Nat.succ n - i) g s x‖
[PROOFSTEP]
have J :
iteratedFDerivWithin 𝕜 n (fun y : Du => fderivWithin 𝕜 (fun y : Du => B (f y) (g y)) s y) s x =
iteratedFDerivWithin 𝕜 n
(fun y => B.precompR Du (f y) (fderivWithin 𝕜 g s y) + B.precompL Du (fderivWithin 𝕜 f s y) (g y)) s x :=
by
apply iteratedFDerivWithin_congr (fun y hy => ?_) hx
have L : (1 : ℕ∞) ≤ n.succ := by simpa only [ENat.coe_one, Nat.one_le_cast] using Nat.succ_pos n
exact B.fderivWithin_of_bilinear (hf.differentiableOn L y hy) (hg.differentiableOn L y hy) (hs y hy)
[GOAL]
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm✝ : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
norm : Norm ((Du →L[𝕜] Eu) →L[𝕜] Fu →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I2 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 (i + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
⊢ iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 (fun y => ↑(↑B (f y)) (g y)) s y) s x =
iteratedFDerivWithin 𝕜 n
(fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y) + ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x
[PROOFSTEP]
apply iteratedFDerivWithin_congr (fun y hy => ?_) hx
[GOAL]
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm✝ : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
norm : Norm ((Du →L[𝕜] Eu) →L[𝕜] Fu →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I2 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 (i + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
y : Du
hy : y ∈ s
⊢ fderivWithin 𝕜 (fun y => ↑(↑B (f y)) (g y)) s y =
↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y) + ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)
[PROOFSTEP]
have L : (1 : ℕ∞) ≤ n.succ := by simpa only [ENat.coe_one, Nat.one_le_cast] using Nat.succ_pos n
[GOAL]
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm✝ : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
norm : Norm ((Du →L[𝕜] Eu) →L[𝕜] Fu →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I2 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 (i + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
y : Du
hy : y ∈ s
⊢ 1 ≤ ↑(Nat.succ n)
[PROOFSTEP]
simpa only [ENat.coe_one, Nat.one_le_cast] using Nat.succ_pos n
[GOAL]
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm✝ : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
norm : Norm ((Du →L[𝕜] Eu) →L[𝕜] Fu →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I2 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 (i + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
y : Du
hy : y ∈ s
L : 1 ≤ ↑(Nat.succ n)
⊢ fderivWithin 𝕜 (fun y => ↑(↑B (f y)) (g y)) s y =
↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y) + ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)
[PROOFSTEP]
exact B.fderivWithin_of_bilinear (hf.differentiableOn L y hy) (hg.differentiableOn L y hy) (hs y hy)
[GOAL]
case succ
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm✝ : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
norm : Norm ((Du →L[𝕜] Eu) →L[𝕜] Fu →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I2 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 (i + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
J :
iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 (fun y => ↑(↑B (f y)) (g y)) s y) s x =
iteratedFDerivWithin 𝕜 n
(fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y) + ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x
⊢ ‖iteratedFDerivWithin 𝕜 (Nat.succ n) (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (Nat.succ n + 1),
↑(Nat.choose (Nat.succ n) i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ *
‖iteratedFDerivWithin 𝕜 (Nat.succ n - i) g s x‖
[PROOFSTEP]
rw [← norm_iteratedFDerivWithin_fderivWithin hs hx, J]
[GOAL]
case succ
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm✝ : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
norm : Norm ((Du →L[𝕜] Eu) →L[𝕜] Fu →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I2 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 (i + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
J :
iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 (fun y => ↑(↑B (f y)) (g y)) s y) s x =
iteratedFDerivWithin 𝕜 n
(fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y) + ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x
⊢ ‖iteratedFDerivWithin 𝕜 n
(fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y) + ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s
x‖ ≤
‖B‖ *
∑ i in Finset.range (Nat.succ n + 1),
↑(Nat.choose (Nat.succ n) i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ *
‖iteratedFDerivWithin 𝕜 (Nat.succ n - i) g s x‖
[PROOFSTEP]
have A : ContDiffOn 𝕜 n (fun y => B.precompR Du (f y) (fderivWithin 𝕜 g s y)) s :=
(B.precompR Du).isBoundedBilinearMap.contDiff.comp_contDiff_on₂ (hf.of_le (Nat.cast_le.2 (Nat.le_succ n)))
(hg.fderivWithin hs In)
[GOAL]
case succ
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm✝ : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
norm : Norm ((Du →L[𝕜] Eu) →L[𝕜] Fu →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I2 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 (i + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
J :
iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 (fun y => ↑(↑B (f y)) (g y)) s y) s x =
iteratedFDerivWithin 𝕜 n
(fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y) + ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x
A : ContDiffOn 𝕜 (↑n) (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s
⊢ ‖iteratedFDerivWithin 𝕜 n
(fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y) + ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s
x‖ ≤
‖B‖ *
∑ i in Finset.range (Nat.succ n + 1),
↑(Nat.choose (Nat.succ n) i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ *
‖iteratedFDerivWithin 𝕜 (Nat.succ n - i) g s x‖
[PROOFSTEP]
have A' : ContDiffOn 𝕜 n (fun y => B.precompL Du (fderivWithin 𝕜 f s y) (g y)) s :=
(B.precompL Du).isBoundedBilinearMap.contDiff.comp_contDiff_on₂ (hf.fderivWithin hs In)
(hg.of_le (Nat.cast_le.2 (Nat.le_succ n)))
[GOAL]
case succ
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm✝ : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
norm : Norm ((Du →L[𝕜] Eu) →L[𝕜] Fu →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I2 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 (i + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
J :
iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 (fun y => ↑(↑B (f y)) (g y)) s y) s x =
iteratedFDerivWithin 𝕜 n
(fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y) + ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x
A : ContDiffOn 𝕜 (↑n) (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s
A' : ContDiffOn 𝕜 (↑n) (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s
⊢ ‖iteratedFDerivWithin 𝕜 n
(fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y) + ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s
x‖ ≤
‖B‖ *
∑ i in Finset.range (Nat.succ n + 1),
↑(Nat.choose (Nat.succ n) i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ *
‖iteratedFDerivWithin 𝕜 (Nat.succ n - i) g s x‖
[PROOFSTEP]
rw [iteratedFDerivWithin_add_apply' A A' hs hx]
[GOAL]
case succ
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm✝ : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
norm : Norm ((Du →L[𝕜] Eu) →L[𝕜] Fu →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I2 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 (i + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
J :
iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 (fun y => ↑(↑B (f y)) (g y)) s y) s x =
iteratedFDerivWithin 𝕜 n
(fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y) + ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x
A : ContDiffOn 𝕜 (↑n) (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s
A' : ContDiffOn 𝕜 (↑n) (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x +
iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (Nat.succ n + 1),
↑(Nat.choose (Nat.succ n) i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ *
‖iteratedFDerivWithin 𝕜 (Nat.succ n - i) g s x‖
[PROOFSTEP]
apply (norm_add_le _ _).trans ((add_le_add I1 I2).trans (le_of_eq ?_))
[GOAL]
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm✝ : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
norm : Norm ((Du →L[𝕜] Eu) →L[𝕜] Fu →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I2 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 (i + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
J :
iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 (fun y => ↑(↑B (f y)) (g y)) s y) s x =
iteratedFDerivWithin 𝕜 n
(fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y) + ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x
A : ContDiffOn 𝕜 (↑n) (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s
A' : ContDiffOn 𝕜 (↑n) (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s
⊢ ‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖ +
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 (i + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖ =
‖B‖ *
∑ i in Finset.range (Nat.succ n + 1),
↑(Nat.choose (Nat.succ n) i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ *
‖iteratedFDerivWithin 𝕜 (Nat.succ n - i) g s x‖
[PROOFSTEP]
simp_rw [← mul_add, mul_assoc]
[GOAL]
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm✝ : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
norm : Norm ((Du →L[𝕜] Eu) →L[𝕜] Fu →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I2 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 (i + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
J :
iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 (fun y => ↑(↑B (f y)) (g y)) s y) s x =
iteratedFDerivWithin 𝕜 n
(fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y) + ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x
A : ContDiffOn 𝕜 (↑n) (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s
A' : ContDiffOn 𝕜 (↑n) (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s
⊢ ‖B‖ *
(∑ x_1 in Finset.range (n + 1),
↑(Nat.choose n x_1) * (‖iteratedFDerivWithin 𝕜 x_1 f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - x_1) g s x‖) +
∑ x_1 in Finset.range (n + 1),
↑(Nat.choose n x_1) * (‖iteratedFDerivWithin 𝕜 (x_1 + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - x_1) g s x‖)) =
‖B‖ *
∑ x_1 in Finset.range (Nat.succ n + 1),
↑(Nat.choose (Nat.succ n) x_1) *
(‖iteratedFDerivWithin 𝕜 x_1 f s x‖ * ‖iteratedFDerivWithin 𝕜 (Nat.succ n - x_1) g s x‖)
[PROOFSTEP]
congr 1
[GOAL]
case e_a
𝕜 : Type u_1
inst✝²⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝²³ : NormedAddCommGroup D
inst✝²² : NormedSpace 𝕜 D
E : Type uE
inst✝²¹ : NormedAddCommGroup E
inst✝²⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝¹⁷ : NormedAddCommGroup G
inst✝¹⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : 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
Du Eu✝ Fu✝ Gu✝ : Type u
inst✝¹³ : NormedAddCommGroup Du
inst✝¹² : NormedSpace 𝕜 Du
inst✝¹¹ : NormedAddCommGroup Eu✝
inst✝¹⁰ : NormedSpace 𝕜 Eu✝
inst✝⁹ : NormedAddCommGroup Fu✝
inst✝⁸ : NormedSpace 𝕜 Fu✝
inst✝⁷ : NormedAddCommGroup Gu✝
inst✝⁶ : NormedSpace 𝕜 Gu✝
B✝ : Eu✝ →L[𝕜] Fu✝ →L[𝕜] Gu✝
f✝ : Du → Eu✝
g✝ : Du → Fu✝
n✝ : ℕ
s : Set Du
x : Du
hf✝ : ContDiffOn 𝕜 (↑n✝) f✝ s
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
IH :
∀ {Eu Fu Gu : Type u} [inst : NormedAddCommGroup Eu] [inst_1 : NormedSpace 𝕜 Eu] [inst_2 : NormedAddCommGroup Fu]
[inst_3 : NormedSpace 𝕜 Fu] [inst_4 : NormedAddCommGroup Gu] [inst_5 : NormedSpace 𝕜 Gu] (B : Eu →L[𝕜] Fu →L[𝕜] Gu)
{f : Du → Eu} {g : Du → Fu},
ContDiffOn 𝕜 (↑n) f s →
ContDiffOn 𝕜 (↑n) g s →
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
Eu Fu Gu : Type u
inst✝⁵ : NormedAddCommGroup Eu
inst✝⁴ : NormedSpace 𝕜 Eu
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
B : Eu →L[𝕜] Fu →L[𝕜] Gu
f : Du → Eu
g : Du → Fu
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g s
In : ↑n + 1 ≤ ↑(Nat.succ n)
norm✝ : Norm (Eu →L[𝕜] (Du →L[𝕜] Fu) →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I1 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - i) g s x‖
norm : Norm ((Du →L[𝕜] Eu) →L[𝕜] Fu →L[𝕜] Du →L[𝕜] Gu) := hasOpNorm
I2 :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 (i + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
J :
iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 (fun y => ↑(↑B (f y)) (g y)) s y) s x =
iteratedFDerivWithin 𝕜 n
(fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y) + ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s x
A : ContDiffOn 𝕜 (↑n) (fun y => ↑(↑(precompR Du B) (f y)) (fderivWithin 𝕜 g s y)) s
A' : ContDiffOn 𝕜 (↑n) (fun y => ↑(↑(precompL Du B) (fderivWithin 𝕜 f s y)) (g y)) s
⊢ ∑ x_1 in Finset.range (n + 1),
↑(Nat.choose n x_1) * (‖iteratedFDerivWithin 𝕜 x_1 f s x‖ * ‖iteratedFDerivWithin 𝕜 (n + 1 - x_1) g s x‖) +
∑ x_1 in Finset.range (n + 1),
↑(Nat.choose n x_1) * (‖iteratedFDerivWithin 𝕜 (x_1 + 1) f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - x_1) g s x‖) =
∑ x_1 in Finset.range (Nat.succ n + 1),
↑(Nat.choose (Nat.succ n) x_1) *
(‖iteratedFDerivWithin 𝕜 x_1 f s x‖ * ‖iteratedFDerivWithin 𝕜 (Nat.succ n - x_1) g s x‖)
[PROOFSTEP]
exact
(Finset.sum_choose_succ_mul (fun i j => ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 j g s x‖) n).symm
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
let Du : Type max uD uE uF uG := ULift.{max uE uF uG, uD} D
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
let Eu : Type max uD uE uF uG := ULift.{max uD uF uG, uE} E
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
let Fu : Type max uD uE uF uG := ULift.{max uD uE uG, uF} F
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
let Gu : Type max uD uE uF uG := ULift.{max uD uE uF, uG} G
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
have isoD : Du ≃ₗᵢ[𝕜] D := LinearIsometryEquiv.ulift 𝕜 D
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
have isoE : Eu ≃ₗᵢ[𝕜] E := LinearIsometryEquiv.ulift 𝕜 E
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
have isoF : Fu ≃ₗᵢ[𝕜] F := LinearIsometryEquiv.ulift 𝕜 F
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
have isoG : Gu ≃ₗᵢ[𝕜] G := LinearIsometryEquiv.ulift 𝕜 G
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
set fu : Du → Eu := isoE.symm ∘ f ∘ isoD with hfu
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
set gu : Du → Fu := isoF.symm ∘ g ∘ isoD with hgu
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
set Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G := ((B.comp (isoE : Eu →L[𝕜] E)).flip.comp (isoF : Fu →L[𝕜] F)).flip with hBu₀
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
let Bu : Eu →L[𝕜] Fu →L[𝕜] Gu
[GOAL]
case Bu
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
⊢ Eu →L[𝕜] Fu →L[𝕜] Gu
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu := ?Bu
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
exact
ContinuousLinearMap.compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu)
(ContinuousLinearMap.compL 𝕜 Fu G Gu (isoG.symm : G →L[𝕜] Gu)) Bu₀
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
have hBu :
Bu =
ContinuousLinearMap.compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu)
(ContinuousLinearMap.compL 𝕜 Fu G Gu (isoG.symm : G →L[𝕜] Gu)) Bu₀ :=
rfl
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
have Bu_eq : (fun y => Bu (fu y) (gu y)) = isoG.symm ∘ (fun y => B (f y) (g y)) ∘ isoD :=
by
ext1 y
rw [hBu]
iterate 2 rw [ContinuousLinearMap.compL_apply, ContinuousLinearMap.coe_comp', Function.comp_apply]
rw [hBu₀]
iterate 2 rw [ContinuousLinearMap.flip_apply, ContinuousLinearMap.coe_comp', Function.comp_apply]
rw [hfu, Function.comp_apply, LinearIsometryEquiv.coe_coe'', LinearIsometryEquiv.coe_coe'',
LinearIsometryEquiv.apply_symm_apply isoE, Function.comp_apply, hgu, LinearIsometryEquiv.coe_coe'',
Function.comp_apply, LinearIsometryEquiv.apply_symm_apply isoF]
simp only [Function.comp_apply]
-- All norms are preserved by the lifting process.
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
⊢ (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
[PROOFSTEP]
ext1 y
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
y : Du
⊢ ↑(↑Bu (fu y)) (gu y) = (↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD) y
[PROOFSTEP]
rw [hBu]
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
y : Du
⊢ ↑(↑(↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀)
(fu y))
(gu y) =
(↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD) y
[PROOFSTEP]
iterate 2 rw [ContinuousLinearMap.compL_apply, ContinuousLinearMap.coe_comp', Function.comp_apply]
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
y : Du
⊢ ↑(↑(↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀)
(fu y))
(gu y) =
(↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD) y
[PROOFSTEP]
rw [ContinuousLinearMap.compL_apply, ContinuousLinearMap.coe_comp', Function.comp_apply]
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
y : Du
⊢ ↑(↑(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)) (↑Bu₀ (fu y)))
(gu y) =
(↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD) y
[PROOFSTEP]
rw [ContinuousLinearMap.compL_apply, ContinuousLinearMap.coe_comp', Function.comp_apply]
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
y : Du
⊢ ↑↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv) (↑(↑Bu₀ (fu y)) (gu y)) =
(↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD) y
[PROOFSTEP]
rw [hBu₀]
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
y : Du
⊢ ↑↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)
(↑(↑(flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv)))
(fu y))
(gu y)) =
(↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD) y
[PROOFSTEP]
iterate 2 rw [ContinuousLinearMap.flip_apply, ContinuousLinearMap.coe_comp', Function.comp_apply]
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
y : Du
⊢ ↑↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)
(↑(↑(flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv)))
(fu y))
(gu y)) =
(↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD) y
[PROOFSTEP]
rw [ContinuousLinearMap.flip_apply, ContinuousLinearMap.coe_comp', Function.comp_apply]
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
y : Du
⊢ ↑↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)
(↑(↑(flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
(↑↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv) (gu y)))
(fu y)) =
(↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD) y
[PROOFSTEP]
rw [ContinuousLinearMap.flip_apply, ContinuousLinearMap.coe_comp', Function.comp_apply]
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
y : Du
⊢ ↑↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)
(↑(↑B (↑↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv) (fu y)))
(↑↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv) (gu y))) =
(↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD) y
[PROOFSTEP]
rw [hfu, Function.comp_apply, LinearIsometryEquiv.coe_coe'', LinearIsometryEquiv.coe_coe'',
LinearIsometryEquiv.apply_symm_apply isoE, Function.comp_apply, hgu, LinearIsometryEquiv.coe_coe'',
Function.comp_apply, LinearIsometryEquiv.apply_symm_apply isoF]
[GOAL]
case h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
y : Du
⊢ ↑(LinearIsometryEquiv.symm isoG) (↑(↑B (f (↑isoD y))) ((g ∘ ↑isoD) y)) =
(↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD) y
[PROOFSTEP]
simp only [Function.comp_apply]
-- All norms are preserved by the lifting process.
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
have Bu_le : ‖Bu‖ ≤ ‖B‖ :=
by
refine' ContinuousLinearMap.op_norm_le_bound _ (norm_nonneg _) fun y => _
refine' ContinuousLinearMap.op_norm_le_bound _ (by positivity) fun x => _
simp only [ContinuousLinearMap.compL_apply, ContinuousLinearMap.coe_comp', Function.comp_apply,
LinearIsometryEquiv.coe_coe'', ContinuousLinearMap.flip_apply, LinearIsometryEquiv.norm_map]
rw [ContinuousLinearMap.coe_comp', Function.comp_apply, ContinuousLinearMap.compL_apply,
ContinuousLinearMap.coe_comp', Function.comp_apply]
iterate 2 rw [ContinuousLinearMap.flip_apply, ContinuousLinearMap.coe_comp', Function.comp_apply]
simp only [LinearIsometryEquiv.coe_coe'', LinearIsometryEquiv.norm_map]
calc
‖B (isoE y) (isoF x)‖ ≤ ‖B (isoE y)‖ * ‖isoF x‖ := ContinuousLinearMap.le_op_norm _ _
_ ≤ ‖B‖ * ‖isoE y‖ * ‖isoF x‖ := (mul_le_mul_of_nonneg_right (ContinuousLinearMap.le_op_norm _ _) (norm_nonneg _))
_ = ‖B‖ * ‖y‖ * ‖x‖ := by simp only [LinearIsometryEquiv.norm_map]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
⊢ ‖Bu‖ ≤ ‖B‖
[PROOFSTEP]
refine' ContinuousLinearMap.op_norm_le_bound _ (norm_nonneg _) fun y => _
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
y : Eu
⊢ ‖↑Bu y‖ ≤ ‖B‖ * ‖y‖
[PROOFSTEP]
refine' ContinuousLinearMap.op_norm_le_bound _ (by positivity) fun x => _
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
y : Eu
⊢ 0 ≤ ‖B‖ * ‖y‖
[PROOFSTEP]
positivity
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x✝ : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x✝ ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
y : Eu
x : Fu
⊢ ‖↑(↑Bu y) x‖ ≤ ‖B‖ * ‖y‖ * ‖x‖
[PROOFSTEP]
simp only [ContinuousLinearMap.compL_apply, ContinuousLinearMap.coe_comp', Function.comp_apply,
LinearIsometryEquiv.coe_coe'', ContinuousLinearMap.flip_apply, LinearIsometryEquiv.norm_map]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x✝ : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x✝ ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
y : Eu
x : Fu
⊢ ‖↑(↑(comp (↑(compL 𝕜 (ULift F) G (ULift G)) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv))
(flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))))
y)
x‖ ≤
‖B‖ * ‖y‖ * ‖x‖
[PROOFSTEP]
rw [ContinuousLinearMap.coe_comp', Function.comp_apply, ContinuousLinearMap.compL_apply, ContinuousLinearMap.coe_comp',
Function.comp_apply]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x✝ : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x✝ ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
y : Eu
x : Fu
⊢ ‖↑↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)
(↑(↑(flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv)))
y)
x)‖ ≤
‖B‖ * ‖y‖ * ‖x‖
[PROOFSTEP]
iterate 2 rw [ContinuousLinearMap.flip_apply, ContinuousLinearMap.coe_comp', Function.comp_apply]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x✝ : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x✝ ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
y : Eu
x : Fu
⊢ ‖↑↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)
(↑(↑(flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv)))
y)
x)‖ ≤
‖B‖ * ‖y‖ * ‖x‖
[PROOFSTEP]
rw [ContinuousLinearMap.flip_apply, ContinuousLinearMap.coe_comp', Function.comp_apply]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x✝ : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x✝ ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
y : Eu
x : Fu
⊢ ‖↑↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)
(↑(↑(flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
(↑↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv) x))
y)‖ ≤
‖B‖ * ‖y‖ * ‖x‖
[PROOFSTEP]
rw [ContinuousLinearMap.flip_apply, ContinuousLinearMap.coe_comp', Function.comp_apply]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x✝ : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x✝ ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
y : Eu
x : Fu
⊢ ‖↑↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)
(↑(↑B (↑↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv) y))
(↑↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv) x))‖ ≤
‖B‖ * ‖y‖ * ‖x‖
[PROOFSTEP]
simp only [LinearIsometryEquiv.coe_coe'', LinearIsometryEquiv.norm_map]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x✝ : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x✝ ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
y : Eu
x : Fu
⊢ ‖↑(↑B (↑isoE y)) (↑isoF x)‖ ≤ ‖B‖ * ‖y‖ * ‖x‖
[PROOFSTEP]
calc
‖B (isoE y) (isoF x)‖ ≤ ‖B (isoE y)‖ * ‖isoF x‖ := ContinuousLinearMap.le_op_norm _ _
_ ≤ ‖B‖ * ‖isoE y‖ * ‖isoF x‖ := (mul_le_mul_of_nonneg_right (ContinuousLinearMap.le_op_norm _ _) (norm_nonneg _))
_ = ‖B‖ * ‖y‖ * ‖x‖ := by simp only [LinearIsometryEquiv.norm_map]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x✝ : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x✝ ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
y : Eu
x : Fu
⊢ ‖B‖ * ‖↑isoE y‖ * ‖↑isoF x‖ = ‖B‖ * ‖y‖ * ‖x‖
[PROOFSTEP]
simp only [LinearIsometryEquiv.norm_map]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
let su := isoD ⁻¹' s
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
have hsu : UniqueDiffOn 𝕜 su := isoD.toContinuousLinearEquiv.uniqueDiffOn_preimage_iff.2 hs
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
let xu := isoD.symm x
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
have hxu : xu ∈ su := by simpa only [Set.mem_preimage, LinearIsometryEquiv.apply_symm_apply] using hx
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
⊢ xu ∈ su
[PROOFSTEP]
simpa only [Set.mem_preimage, LinearIsometryEquiv.apply_symm_apply] using hx
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
have xu_x : isoD xu = x := by simp only [LinearIsometryEquiv.apply_symm_apply]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
⊢ ↑isoD xu = x
[PROOFSTEP]
simp only [LinearIsometryEquiv.apply_symm_apply]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
have hfu : ContDiffOn 𝕜 n fu su :=
isoE.symm.contDiff.comp_contDiffOn ((hf.of_le hn).comp_continuousLinearMap (isoD : Du →L[𝕜] D))
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
have hgu : ContDiffOn 𝕜 n gu su :=
isoF.symm.contDiff.comp_contDiffOn ((hg.of_le hn).comp_continuousLinearMap (isoD : Du →L[𝕜] D))
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
have Nfu : ∀ i, ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖ :=
by
intro i
rw [LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_left _ _ hsu hxu]
rw [LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_right _ _ hs, xu_x]
rwa [← xu_x] at hx
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
⊢ ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
[PROOFSTEP]
intro i
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
i : ℕ
⊢ ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
[PROOFSTEP]
rw [LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_left _ _ hsu hxu]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
i : ℕ
⊢ ‖iteratedFDerivWithin 𝕜 i (f ∘ ↑isoD) su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
[PROOFSTEP]
rw [LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_right _ _ hs, xu_x]
[GOAL]
case hx
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
i : ℕ
⊢ ↑isoD xu ∈ s
[PROOFSTEP]
rwa [← xu_x] at hx
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
have Ngu : ∀ i, ‖iteratedFDerivWithin 𝕜 i gu su xu‖ = ‖iteratedFDerivWithin 𝕜 i g s x‖ :=
by
intro i
rw [LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_left _ _ hsu hxu]
rw [LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_right _ _ hs, xu_x]
rwa [← xu_x] at hx
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
⊢ ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu su xu‖ = ‖iteratedFDerivWithin 𝕜 i g s x‖
[PROOFSTEP]
intro i
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
i : ℕ
⊢ ‖iteratedFDerivWithin 𝕜 i gu su xu‖ = ‖iteratedFDerivWithin 𝕜 i g s x‖
[PROOFSTEP]
rw [LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_left _ _ hsu hxu]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
i : ℕ
⊢ ‖iteratedFDerivWithin 𝕜 i (g ∘ ↑isoD) su xu‖ = ‖iteratedFDerivWithin 𝕜 i g s x‖
[PROOFSTEP]
rw [LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_right _ _ hs, xu_x]
[GOAL]
case hx
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
i : ℕ
⊢ ↑isoD xu ∈ s
[PROOFSTEP]
rwa [← xu_x] at hx
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
Ngu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu su xu‖ = ‖iteratedFDerivWithin 𝕜 i g s x‖
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
have NBu :
‖iteratedFDerivWithin 𝕜 n (fun y => Bu (fu y) (gu y)) su xu‖ =
‖iteratedFDerivWithin 𝕜 n (fun y => B (f y) (g y)) s x‖ :=
by
rw [Bu_eq]
rw [LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_left _ _ hsu hxu]
rw [LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_right _ _ hs, xu_x]
rwa [← xu_x] at hx
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
Ngu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu su xu‖ = ‖iteratedFDerivWithin 𝕜 i g s x‖
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑Bu (fu y)) (gu y)) su xu‖ =
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖
[PROOFSTEP]
rw [Bu_eq]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
Ngu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu su xu‖ = ‖iteratedFDerivWithin 𝕜 i g s x‖
⊢ ‖iteratedFDerivWithin 𝕜 n (↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD) su xu‖ =
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖
[PROOFSTEP]
rw [LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_left _ _ hsu hxu]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
Ngu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu su xu‖ = ‖iteratedFDerivWithin 𝕜 i g s x‖
⊢ ‖iteratedFDerivWithin 𝕜 n ((fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD) su xu‖ =
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖
[PROOFSTEP]
rw [LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_right _ _ hs, xu_x]
[GOAL]
case hx
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
Ngu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu su xu‖ = ‖iteratedFDerivWithin 𝕜 i g s x‖
⊢ ↑isoD xu ∈ s
[PROOFSTEP]
rwa [← xu_x] at hx
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
Ngu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu su xu‖ = ‖iteratedFDerivWithin 𝕜 i g s x‖
NBu :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑Bu (fu y)) (gu y)) su xu‖ =
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
have :
‖iteratedFDerivWithin 𝕜 n (fun y => Bu (fu y) (gu y)) su xu‖ ≤
‖Bu‖ *
∑ i in Finset.range (n + 1),
(n.choose i : ℝ) * ‖iteratedFDerivWithin 𝕜 i fu su xu‖ * ‖iteratedFDerivWithin 𝕜 (n - i) gu su xu‖ :=
Bu.norm_iteratedFDerivWithin_le_of_bilinear_aux hfu hgu hsu hxu
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
Ngu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu su xu‖ = ‖iteratedFDerivWithin 𝕜 i g s x‖
NBu :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑Bu (fu y)) (gu y)) su xu‖ =
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖
this :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑Bu (fu y)) (gu y)) su xu‖ ≤
‖Bu‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i fu su xu‖ * ‖iteratedFDerivWithin 𝕜 (n - i) gu su xu‖
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
simp only [Nfu, Ngu, NBu] at this
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
Ngu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu su xu‖ = ‖iteratedFDerivWithin 𝕜 i g s x‖
NBu :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑Bu (fu y)) (gu y)) su xu‖ =
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖
this :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖↑(↑(compL 𝕜 (ULift E) (ULift F →L[𝕜] G) (ULift F →L[𝕜] ULift G))
(↑(compL 𝕜 (ULift F) G (ULift G))
↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
(flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv)))‖ *
∑ x_1 in Finset.range (n + 1),
↑(Nat.choose n x_1) * ‖iteratedFDerivWithin 𝕜 x_1 f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - x_1) g s x‖
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
apply this.trans (mul_le_mul_of_nonneg_right Bu_le ?_)
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
Ngu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu su xu‖ = ‖iteratedFDerivWithin 𝕜 i g s x‖
NBu :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑Bu (fu y)) (gu y)) su xu‖ =
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖
this :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖↑(↑(compL 𝕜 (ULift E) (ULift F →L[𝕜] G) (ULift F →L[𝕜] ULift G))
(↑(compL 𝕜 (ULift F) G (ULift G))
↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
(flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv)))‖ *
∑ x_1 in Finset.range (n + 1),
↑(Nat.choose n x_1) * ‖iteratedFDerivWithin 𝕜 x_1 f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - x_1) g s x‖
⊢ 0 ≤
∑ x_1 in Finset.range (n + 1),
↑(Nat.choose n x_1) * ‖iteratedFDerivWithin 𝕜 x_1 f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - x_1) g s x‖
[PROOFSTEP]
exact Finset.sum_nonneg' fun i => by positivity
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift D
Eu : Type (max uD uE uF uG) := ULift E
Fu : Type (max uD uE uF uG) := ULift F
Gu : Type (max uD uE uF uG) := ULift G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
hfu✝ : fu = ↑(LinearIsometryEquiv.symm isoE) ∘ f ∘ ↑isoD
gu : Du → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
hgu✝ : gu = ↑(LinearIsometryEquiv.symm isoF) ∘ g ∘ ↑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv))) ↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
hBu₀ :
Bu₀ =
flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv))
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
hBu :
Bu =
↑(↑(compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
(↑(compL 𝕜 Fu G Gu) ↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
Bu₀
Bu_eq : (fun y => ↑(↑Bu (fu y)) (gu y)) = ↑(LinearIsometryEquiv.symm isoG) ∘ (fun y => ↑(↑B (f y)) (g y)) ∘ ↑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ↑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := ↑(LinearIsometryEquiv.symm isoD) x
hxu : xu ∈ su
xu_x : ↑isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
Ngu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu su xu‖ = ‖iteratedFDerivWithin 𝕜 i g s x‖
NBu :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑Bu (fu y)) (gu y)) su xu‖ =
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖
this :
‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
‖↑(↑(compL 𝕜 (ULift E) (ULift F →L[𝕜] G) (ULift F →L[𝕜] ULift G))
(↑(compL 𝕜 (ULift F) G (ULift G))
↑(ContinuousLinearEquiv.mk (LinearIsometryEquiv.symm isoG).toLinearEquiv)))
(flip
(comp (flip (comp B ↑(ContinuousLinearEquiv.mk isoE.toLinearEquiv)))
↑(ContinuousLinearEquiv.mk isoF.toLinearEquiv)))‖ *
∑ x_1 in Finset.range (n + 1),
↑(Nat.choose n x_1) * ‖iteratedFDerivWithin 𝕜 x_1 f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - x_1) g s x‖
i : ℕ
⊢ 0 ≤ ↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
positivity
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
hf : ContDiff 𝕜 N f
hg : ContDiff 𝕜 N g
x : D
n : ℕ
hn : ↑n ≤ N
⊢ ‖iteratedFDeriv 𝕜 n (fun y => ↑(↑B (f y)) (g y)) x‖ ≤
‖B‖ * ∑ i in Finset.range (n + 1), ↑(Nat.choose n i) * ‖iteratedFDeriv 𝕜 i f x‖ * ‖iteratedFDeriv 𝕜 (n - i) g x‖
[PROOFSTEP]
simp_rw [← iteratedFDerivWithin_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
hf : ContDiff 𝕜 N f
hg : ContDiff 𝕜 N g
x : D
n : ℕ
hn : ↑n ≤ N
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) univ x‖ ≤
‖B‖ *
∑ x_1 in Finset.range (n + 1),
↑(Nat.choose n x_1) * ‖iteratedFDerivWithin 𝕜 x_1 f univ x‖ * ‖iteratedFDerivWithin 𝕜 (n - x_1) g univ x‖
[PROOFSTEP]
exact B.norm_iteratedFDerivWithin_le_of_bilinear hf.contDiffOn hg.contDiffOn uniqueDiffOn_univ (mem_univ x) hn
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
hB : ‖B‖ ≤ 1
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) s x‖ ≤
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
apply (B.norm_iteratedFDerivWithin_le_of_bilinear hf hg hs hx hn).trans
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
hB : ‖B‖ ≤ 1
⊢ ‖B‖ *
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖ ≤
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
apply mul_le_of_le_one_left (Finset.sum_nonneg' fun i => ?_) hB
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
hB : ‖B‖ ≤ 1
i : ℕ
⊢ 0 ≤ ↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
positivity
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
hf : ContDiff 𝕜 N f
hg : ContDiff 𝕜 N g
x : D
n : ℕ
hn : ↑n ≤ N
hB : ‖B‖ ≤ 1
⊢ ‖iteratedFDeriv 𝕜 n (fun y => ↑(↑B (f y)) (g y)) x‖ ≤
∑ i in Finset.range (n + 1), ↑(Nat.choose n i) * ‖iteratedFDeriv 𝕜 i f x‖ * ‖iteratedFDeriv 𝕜 (n - i) g x‖
[PROOFSTEP]
simp_rw [← iteratedFDerivWithin_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
hf : ContDiff 𝕜 N f
hg : ContDiff 𝕜 N g
x : D
n : ℕ
hn : ↑n ≤ N
hB : ‖B‖ ≤ 1
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) univ x‖ ≤
∑ x_1 in Finset.range (n + 1),
↑(Nat.choose n x_1) * ‖iteratedFDerivWithin 𝕜 x_1 f univ x‖ * ‖iteratedFDerivWithin 𝕜 (n - x_1) g univ x‖
[PROOFSTEP]
exact
B.norm_iteratedFDerivWithin_le_of_bilinear_of_le_one hf.contDiffOn hg.contDiffOn uniqueDiffOn_univ (mem_univ x) hn hB
[GOAL]
𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹¹ : NormedAddCommGroup D
inst✝¹⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝³ : NormedAddCommGroup X
inst✝² : 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
A : Type u_3
inst✝¹ : NormedRing A
inst✝ : NormedAlgebra 𝕜 A
f g : E → A
N : ℕ∞
hf : ContDiff 𝕜 N f
hg : ContDiff 𝕜 N g
x : E
n : ℕ
hn : ↑n ≤ N
⊢ ‖iteratedFDeriv 𝕜 n (fun y => f y * g y) x‖ ≤
∑ i in Finset.range (n + 1), ↑(Nat.choose n i) * ‖iteratedFDeriv 𝕜 i f x‖ * ‖iteratedFDeriv 𝕜 (n - i) g x‖
[PROOFSTEP]
simp_rw [← iteratedFDerivWithin_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹¹ : NormedAddCommGroup D
inst✝¹⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
X : Type u_2
inst✝³ : NormedAddCommGroup X
inst✝² : 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
A : Type u_3
inst✝¹ : NormedRing A
inst✝ : NormedAlgebra 𝕜 A
f g : E → A
N : ℕ∞
hf : ContDiff 𝕜 N f
hg : ContDiff 𝕜 N g
x : E
n : ℕ
hn : ↑n ≤ N
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => f y * g y) univ x‖ ≤
∑ x_1 in Finset.range (n + 1),
↑(Nat.choose n x_1) * ‖iteratedFDerivWithin 𝕜 x_1 f univ x‖ * ‖iteratedFDerivWithin 𝕜 (n - x_1) g univ x‖
[PROOFSTEP]
exact norm_iteratedFDerivWithin_mul_le hf.contDiffOn hg.contDiffOn uniqueDiffOn_univ (mem_univ x) hn
[GOAL]
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹³ : NormedAddCommGroup D✝
inst✝¹² : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : 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
Fu Gu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
f : E → Fu
n : ℕ
s : Set E
t : Set Fu
x : E
hg : ContDiffOn 𝕜 (↑n) g t
hf : ContDiffOn 𝕜 (↑n) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
induction' n using Nat.case_strong_induction_on with n IH generalizing Gu
[GOAL]
case hz
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑0) g t
hf : ContDiffOn 𝕜 (↑0) f s
hC : ∀ (i : ℕ), i ≤ 0 → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ 0 → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
⊢ ‖iteratedFDerivWithin 𝕜 0 (g ∘ f) s x‖ ≤ ↑0! * C * D ^ 0
[PROOFSTEP]
simpa [norm_iteratedFDerivWithin_zero, Nat.factorial_zero, algebraMap.coe_one, one_mul, pow_zero, mul_one,
comp_apply] using hC 0 le_rfl
[GOAL]
case hi
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
⊢ ‖iteratedFDerivWithin 𝕜 (Nat.succ n) (g ∘ f) s x‖ ≤ ↑(Nat.succ n)! * C * D ^ Nat.succ n
[PROOFSTEP]
have M : (n : ℕ∞) < n.succ := Nat.cast_lt.2 n.lt_succ_self
[GOAL]
case hi
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
⊢ ‖iteratedFDerivWithin 𝕜 (Nat.succ n) (g ∘ f) s x‖ ≤ ↑(Nat.succ n)! * C * D ^ Nat.succ n
[PROOFSTEP]
have Cnonneg : 0 ≤ C := (norm_nonneg _).trans (hC 0 bot_le)
[GOAL]
case hi
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
⊢ ‖iteratedFDerivWithin 𝕜 (Nat.succ n) (g ∘ f) s x‖ ≤ ↑(Nat.succ n)! * C * D ^ Nat.succ n
[PROOFSTEP]
have Dnonneg : 0 ≤ D := by
have : 1 ≤ n + 1 := by simp only [le_add_iff_nonneg_left, zero_le']
simpa only [pow_one] using
(norm_nonneg _).trans
(hD 1 le_rfl this)
-- use the inductive assumption to bound the derivatives of `g' ∘ f`.
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
⊢ 0 ≤ D
[PROOFSTEP]
have : 1 ≤ n + 1 := by simp only [le_add_iff_nonneg_left, zero_le']
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
⊢ 1 ≤ n + 1
[PROOFSTEP]
simp only [le_add_iff_nonneg_left, zero_le']
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
this : 1 ≤ n + 1
⊢ 0 ≤ D
[PROOFSTEP]
simpa only [pow_one] using
(norm_nonneg _).trans
(hD 1 le_rfl this)
-- use the inductive assumption to bound the derivatives of `g' ∘ f`.
[GOAL]
case hi
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
⊢ ‖iteratedFDerivWithin 𝕜 (Nat.succ n) (g ∘ f) s x‖ ≤ ↑(Nat.succ n)! * C * D ^ Nat.succ n
[PROOFSTEP]
have I : ∀ i ∈ Finset.range (n + 1), ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ i ! * C * D ^ i
[GOAL]
case I
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
⊢ ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
[PROOFSTEP]
intro i hi
[GOAL]
case I
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
i : ℕ
hi : i ∈ Finset.range (n + 1)
⊢ ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
[PROOFSTEP]
simp only [Finset.mem_range_succ_iff] at hi
[GOAL]
case I
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
i : ℕ
hi : i ≤ n
⊢ ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
[PROOFSTEP]
apply IH i hi
[GOAL]
case I.hg
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
i : ℕ
hi : i ≤ n
⊢ ContDiffOn 𝕜 (↑i) (fderivWithin 𝕜 g t) t
[PROOFSTEP]
apply hg.fderivWithin ht
[GOAL]
case I.hg
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
i : ℕ
hi : i ≤ n
⊢ ↑i + 1 ≤ ↑(Nat.succ n)
[PROOFSTEP]
simp only [Nat.cast_succ]
[GOAL]
case I.hg
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
i : ℕ
hi : i ≤ n
⊢ ↑i + 1 ≤ ↑n + 1
[PROOFSTEP]
exact add_le_add_right (Nat.cast_le.2 hi) _
[GOAL]
case I.hf
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
i : ℕ
hi : i ≤ n
⊢ ContDiffOn 𝕜 (↑i) f s
[PROOFSTEP]
apply hf.of_le (Nat.cast_le.2 (hi.trans n.le_succ))
[GOAL]
case I.hC
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
i : ℕ
hi : i ≤ n
⊢ ∀ (i_1 : ℕ), i_1 ≤ i → ‖iteratedFDerivWithin 𝕜 i_1 (fderivWithin 𝕜 g t) t (f x)‖ ≤ C
[PROOFSTEP]
intro j hj
[GOAL]
case I.hC
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
i : ℕ
hi : i ≤ n
j : ℕ
hj : j ≤ i
⊢ ‖iteratedFDerivWithin 𝕜 j (fderivWithin 𝕜 g t) t (f x)‖ ≤ C
[PROOFSTEP]
have : ‖iteratedFDerivWithin 𝕜 j (fderivWithin 𝕜 g t) t (f x)‖ = ‖iteratedFDerivWithin 𝕜 (j + 1) g t (f x)‖ := by
rw [iteratedFDerivWithin_succ_eq_comp_right ht (hst hx), comp_apply, LinearIsometryEquiv.norm_map]
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
i : ℕ
hi : i ≤ n
j : ℕ
hj : j ≤ i
⊢ ‖iteratedFDerivWithin 𝕜 j (fderivWithin 𝕜 g t) t (f x)‖ = ‖iteratedFDerivWithin 𝕜 (j + 1) g t (f x)‖
[PROOFSTEP]
rw [iteratedFDerivWithin_succ_eq_comp_right ht (hst hx), comp_apply, LinearIsometryEquiv.norm_map]
[GOAL]
case I.hC
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
i : ℕ
hi : i ≤ n
j : ℕ
hj : j ≤ i
this : ‖iteratedFDerivWithin 𝕜 j (fderivWithin 𝕜 g t) t (f x)‖ = ‖iteratedFDerivWithin 𝕜 (j + 1) g t (f x)‖
⊢ ‖iteratedFDerivWithin 𝕜 j (fderivWithin 𝕜 g t) t (f x)‖ ≤ C
[PROOFSTEP]
rw [this]
[GOAL]
case I.hC
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
i : ℕ
hi : i ≤ n
j : ℕ
hj : j ≤ i
this : ‖iteratedFDerivWithin 𝕜 j (fderivWithin 𝕜 g t) t (f x)‖ = ‖iteratedFDerivWithin 𝕜 (j + 1) g t (f x)‖
⊢ ‖iteratedFDerivWithin 𝕜 (j + 1) g t (f x)‖ ≤ C
[PROOFSTEP]
exact hC (j + 1) (add_le_add (hj.trans hi) le_rfl)
[GOAL]
case I.hD
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
i : ℕ
hi : i ≤ n
⊢ ∀ (i_1 : ℕ), 1 ≤ i_1 → i_1 ≤ i → ‖iteratedFDerivWithin 𝕜 i_1 f s x‖ ≤ D ^ i_1
[PROOFSTEP]
intro j hj h'j
[GOAL]
case I.hD
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
i : ℕ
hi : i ≤ n
j : ℕ
hj : 1 ≤ j
h'j : j ≤ i
⊢ ‖iteratedFDerivWithin 𝕜 j f s x‖ ≤ D ^ j
[PROOFSTEP]
exact
hD j hj
(h'j.trans (hi.trans n.le_succ))
-- reformulate `hD` as a bound for the derivatives of `f'`.
[GOAL]
case hi
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
⊢ ‖iteratedFDerivWithin 𝕜 (Nat.succ n) (g ∘ f) s x‖ ≤ ↑(Nat.succ n)! * C * D ^ Nat.succ n
[PROOFSTEP]
have J : ∀ i, ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1) :=
by
intro i
have : ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ = ‖iteratedFDerivWithin 𝕜 (n - i + 1) f s x‖
· rw [iteratedFDerivWithin_succ_eq_comp_right hs hx, comp_apply, LinearIsometryEquiv.norm_map]
rw [this]
apply hD
· simp only [le_add_iff_nonneg_left, zero_le']
· apply Nat.succ_le_succ tsub_le_self
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
⊢ ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
[PROOFSTEP]
intro i
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
i : ℕ
⊢ ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
[PROOFSTEP]
have : ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ = ‖iteratedFDerivWithin 𝕜 (n - i + 1) f s x‖
[GOAL]
case this
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
i : ℕ
⊢ ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ = ‖iteratedFDerivWithin 𝕜 (n - i + 1) f s x‖
[PROOFSTEP]
rw [iteratedFDerivWithin_succ_eq_comp_right hs hx, comp_apply, LinearIsometryEquiv.norm_map]
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
i : ℕ
this : ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ = ‖iteratedFDerivWithin 𝕜 (n - i + 1) f s x‖
⊢ ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
[PROOFSTEP]
rw [this]
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
i : ℕ
this : ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ = ‖iteratedFDerivWithin 𝕜 (n - i + 1) f s x‖
⊢ ‖iteratedFDerivWithin 𝕜 (n - i + 1) f s x‖ ≤ D ^ (n - i + 1)
[PROOFSTEP]
apply hD
[GOAL]
case a
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
i : ℕ
this : ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ = ‖iteratedFDerivWithin 𝕜 (n - i + 1) f s x‖
⊢ 1 ≤ n - i + 1
[PROOFSTEP]
simp only [le_add_iff_nonneg_left, zero_le']
[GOAL]
case a
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
i : ℕ
this : ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ = ‖iteratedFDerivWithin 𝕜 (n - i + 1) f s x‖
⊢ n - i + 1 ≤ Nat.succ n
[PROOFSTEP]
apply Nat.succ_le_succ tsub_le_self
[GOAL]
case hi
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
⊢ ‖iteratedFDerivWithin 𝕜 (Nat.succ n) (g ∘ f) s x‖ ≤ ↑(Nat.succ n)! * C * D ^ Nat.succ n
[PROOFSTEP]
calc
‖iteratedFDerivWithin 𝕜 (n + 1) (g ∘ f) s x‖ =
‖iteratedFDerivWithin 𝕜 n (fun y : E => fderivWithin 𝕜 (g ∘ f) s y) s x‖ :=
by rw [iteratedFDerivWithin_succ_eq_comp_right hs hx, comp_apply, LinearIsometryEquiv.norm_map]
_ =
‖iteratedFDerivWithin 𝕜 n
(fun y : E => ContinuousLinearMap.compL 𝕜 E Fu Gu (fderivWithin 𝕜 g t (f y)) (fderivWithin 𝕜 f s y)) s x‖ :=
by
have L : (1 : ℕ∞) ≤ n.succ := by simpa only [ENat.coe_one, Nat.one_le_cast] using n.succ_pos
congr 1
refine' iteratedFDerivWithin_congr (fun y hy => _) hx _
apply fderivWithin.comp _ _ _ hst (hs y hy)
· exact hg.differentiableOn L _ (hst hy)
· exact hf.differentiableOn L _ hy
_ ≤
∑ i in Finset.range (n + 1),
(n.choose i : ℝ) * ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ *
‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ :=
by
have A : ContDiffOn 𝕜 n (fderivWithin 𝕜 g t ∘ f) s :=
by
apply ContDiffOn.comp _ (hf.of_le M.le) hst
apply hg.fderivWithin ht
simp only [Nat.cast_succ, le_refl]
have B : ContDiffOn 𝕜 n (fderivWithin 𝕜 f s) s :=
by
apply hf.fderivWithin hs
simp only [Nat.cast_succ, le_refl]
exact
(ContinuousLinearMap.compL 𝕜 E Fu Gu).norm_iteratedFDerivWithin_le_of_bilinear_of_le_one A B hs hx le_rfl
(ContinuousLinearMap.norm_compL_le 𝕜 E Fu Gu)
-- bound each of the terms using the estimates on previous derivatives (that use the inductive
-- assumption for `g' ∘ f`).
_ ≤ ∑ i in Finset.range (n + 1), (n.choose i : ℝ) * (i ! * C * D ^ i) * D ^ (n - i + 1) :=
by
apply Finset.sum_le_sum fun i hi => ?_
simp only [mul_assoc (n.choose i : ℝ)]
refine' mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg _)
apply mul_le_mul (I i hi) (J i) (norm_nonneg _)
positivity
-- We are left with trivial algebraic manipulations to see that this is smaller than
-- the claimed bound.
_ =
∑ i in Finset.range (n + 1),
-- porting note: had to insert a few more explicit type ascriptions in this and similar
-- expressions.(n ! : ℝ) * ((i ! : ℝ)⁻¹ * i !) * C * (D ^ i * D ^ (n - i + 1)) * ((n - i)! : ℝ)⁻¹ :=
by
apply Finset.sum_congr rfl fun i hi => ?_
simp only [Nat.cast_choose ℝ (Finset.mem_range_succ_iff.1 hi), div_eq_inv_mul, mul_inv]
ring
_ = ∑ i in Finset.range (n + 1), (n ! : ℝ) * 1 * C * D ^ (n + 1) * ((n - i)! : ℝ)⁻¹ :=
by
apply Finset.sum_congr rfl fun i hi => ?_
congr 2
· congr
apply inv_mul_cancel
simpa only [Ne.def, Nat.cast_eq_zero] using i.factorial_ne_zero
· rw [← pow_add]
congr 1
rw [Nat.add_succ, Nat.succ_inj']
exact Nat.add_sub_of_le (Finset.mem_range_succ_iff.1 hi)
_ ≤ ∑ i in Finset.range (n + 1), (n ! : ℝ) * 1 * C * D ^ (n + 1) * 1 :=
by
apply Finset.sum_le_sum fun i _hi => ?_
refine' mul_le_mul_of_nonneg_left _ (by positivity)
apply inv_le_one
simpa only [Nat.one_le_cast] using (n - i).factorial_pos
_ = (n + 1)! * C * D ^ (n + 1) := by
simp only [mul_assoc, mul_one, Finset.sum_const, Finset.card_range, nsmul_eq_mul, Nat.factorial_succ, Nat.cast_mul]
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
⊢ ‖iteratedFDerivWithin 𝕜 (n + 1) (g ∘ f) s x‖ = ‖iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 (g ∘ f) s y) s x‖
[PROOFSTEP]
rw [iteratedFDerivWithin_succ_eq_comp_right hs hx, comp_apply, LinearIsometryEquiv.norm_map]
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 (g ∘ f) s y) s x‖ =
‖iteratedFDerivWithin 𝕜 n
(fun y => ↑(↑(ContinuousLinearMap.compL 𝕜 E Fu Gu) (fderivWithin 𝕜 g t (f y))) (fderivWithin 𝕜 f s y)) s x‖
[PROOFSTEP]
have L : (1 : ℕ∞) ≤ n.succ := by simpa only [ENat.coe_one, Nat.one_le_cast] using n.succ_pos
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
⊢ 1 ≤ ↑(Nat.succ n)
[PROOFSTEP]
simpa only [ENat.coe_one, Nat.one_le_cast] using n.succ_pos
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
L : 1 ≤ ↑(Nat.succ n)
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 (g ∘ f) s y) s x‖ =
‖iteratedFDerivWithin 𝕜 n
(fun y => ↑(↑(ContinuousLinearMap.compL 𝕜 E Fu Gu) (fderivWithin 𝕜 g t (f y))) (fderivWithin 𝕜 f s y)) s x‖
[PROOFSTEP]
congr 1
[GOAL]
case e_a
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
L : 1 ≤ ↑(Nat.succ n)
⊢ iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 (g ∘ f) s y) s x =
iteratedFDerivWithin 𝕜 n
(fun y => ↑(↑(ContinuousLinearMap.compL 𝕜 E Fu Gu) (fderivWithin 𝕜 g t (f y))) (fderivWithin 𝕜 f s y)) s x
[PROOFSTEP]
refine' iteratedFDerivWithin_congr (fun y hy => _) hx _
[GOAL]
case e_a
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
L : 1 ≤ ↑(Nat.succ n)
y : E
hy : y ∈ s
⊢ fderivWithin 𝕜 (g ∘ f) s y =
↑(↑(ContinuousLinearMap.compL 𝕜 E Fu Gu) (fderivWithin 𝕜 g t (f y))) (fderivWithin 𝕜 f s y)
[PROOFSTEP]
apply fderivWithin.comp _ _ _ hst (hs y hy)
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
L : 1 ≤ ↑(Nat.succ n)
y : E
hy : y ∈ s
⊢ DifferentiableWithinAt 𝕜 g t (f y)
[PROOFSTEP]
exact hg.differentiableOn L _ (hst hy)
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
L : 1 ≤ ↑(Nat.succ n)
y : E
hy : y ∈ s
⊢ DifferentiableWithinAt 𝕜 f s y
[PROOFSTEP]
exact hf.differentiableOn L _ hy
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
⊢ ‖iteratedFDerivWithin 𝕜 n
(fun y => ↑(↑(ContinuousLinearMap.compL 𝕜 E Fu Gu) (fderivWithin 𝕜 g t (f y))) (fderivWithin 𝕜 f s y)) s x‖ ≤
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ *
‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖
[PROOFSTEP]
have A : ContDiffOn 𝕜 n (fderivWithin 𝕜 g t ∘ f) s :=
by
apply ContDiffOn.comp _ (hf.of_le M.le) hst
apply hg.fderivWithin ht
simp only [Nat.cast_succ, le_refl]
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
⊢ ContDiffOn 𝕜 (↑n) (fderivWithin 𝕜 g t ∘ f) s
[PROOFSTEP]
apply ContDiffOn.comp _ (hf.of_le M.le) hst
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
⊢ ContDiffOn 𝕜 (↑n) (fderivWithin 𝕜 g t) t
[PROOFSTEP]
apply hg.fderivWithin ht
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
⊢ ↑n + 1 ≤ ↑(Nat.succ n)
[PROOFSTEP]
simp only [Nat.cast_succ, le_refl]
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
A : ContDiffOn 𝕜 (↑n) (fderivWithin 𝕜 g t ∘ f) s
⊢ ‖iteratedFDerivWithin 𝕜 n
(fun y => ↑(↑(ContinuousLinearMap.compL 𝕜 E Fu Gu) (fderivWithin 𝕜 g t (f y))) (fderivWithin 𝕜 f s y)) s x‖ ≤
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ *
‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖
[PROOFSTEP]
have B : ContDiffOn 𝕜 n (fderivWithin 𝕜 f s) s :=
by
apply hf.fderivWithin hs
simp only [Nat.cast_succ, le_refl]
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
A : ContDiffOn 𝕜 (↑n) (fderivWithin 𝕜 g t ∘ f) s
⊢ ContDiffOn 𝕜 (↑n) (fderivWithin 𝕜 f s) s
[PROOFSTEP]
apply hf.fderivWithin hs
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
A : ContDiffOn 𝕜 (↑n) (fderivWithin 𝕜 g t ∘ f) s
⊢ ↑n + 1 ≤ ↑(Nat.succ n)
[PROOFSTEP]
simp only [Nat.cast_succ, le_refl]
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
A : ContDiffOn 𝕜 (↑n) (fderivWithin 𝕜 g t ∘ f) s
B : ContDiffOn 𝕜 (↑n) (fderivWithin 𝕜 f s) s
⊢ ‖iteratedFDerivWithin 𝕜 n
(fun y => ↑(↑(ContinuousLinearMap.compL 𝕜 E Fu Gu) (fderivWithin 𝕜 g t (f y))) (fderivWithin 𝕜 f s y)) s x‖ ≤
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ *
‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖
[PROOFSTEP]
exact
(ContinuousLinearMap.compL 𝕜 E Fu Gu).norm_iteratedFDerivWithin_le_of_bilinear_of_le_one A B hs hx le_rfl
(ContinuousLinearMap.norm_compL_le 𝕜 E Fu Gu)
-- bound each of the terms using the estimates on previous derivatives (that use the inductive
-- assumption for `g' ∘ f`).
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
⊢ ∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ *
‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤
∑ i in Finset.range (n + 1), ↑(Nat.choose n i) * (↑i ! * C * D ^ i) * D ^ (n - i + 1)
[PROOFSTEP]
apply Finset.sum_le_sum fun i hi => ?_
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
i : ℕ
hi : i ∈ Finset.range (n + 1)
⊢ ↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ *
‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤
↑(Nat.choose n i) * (↑i ! * C * D ^ i) * D ^ (n - i + 1)
[PROOFSTEP]
simp only [mul_assoc (n.choose i : ℝ)]
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
i : ℕ
hi : i ∈ Finset.range (n + 1)
⊢ ↑(Nat.choose n i) *
(‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ *
‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖) ≤
↑(Nat.choose n i) * (↑i ! * C * D ^ i * D ^ (n - i + 1))
[PROOFSTEP]
refine' mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg _)
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
i : ℕ
hi : i ∈ Finset.range (n + 1)
⊢ ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤
↑i ! * C * D ^ i * D ^ (n - i + 1)
[PROOFSTEP]
apply mul_le_mul (I i hi) (J i) (norm_nonneg _)
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
i : ℕ
hi : i ∈ Finset.range (n + 1)
⊢ 0 ≤ ↑i ! * C * D ^ i
[PROOFSTEP]
positivity
-- We are left with trivial algebraic manipulations to see that this is smaller than
-- the claimed bound.
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
⊢ ∑ i in Finset.range (n + 1), ↑(Nat.choose n i) * (↑i ! * C * D ^ i) * D ^ (n - i + 1) =
∑ i in Finset.range (n + 1), ↑n ! * ((↑i !)⁻¹ * ↑i !) * C * (D ^ i * D ^ (n - i + 1)) * (↑(n - i)!)⁻¹
[PROOFSTEP]
apply Finset.sum_congr rfl fun i hi => ?_
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
i : ℕ
hi : i ∈ Finset.range (n + 1)
⊢ ↑(Nat.choose n i) * (↑i ! * C * D ^ i) * D ^ (n - i + 1) =
↑n ! * ((↑i !)⁻¹ * ↑i !) * C * (D ^ i * D ^ (n - i + 1)) * (↑(n - i)!)⁻¹
[PROOFSTEP]
simp only [Nat.cast_choose ℝ (Finset.mem_range_succ_iff.1 hi), div_eq_inv_mul, mul_inv]
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
i : ℕ
hi : i ∈ Finset.range (n + 1)
⊢ (↑i !)⁻¹ * (↑(n - i)!)⁻¹ * ↑n ! * (↑i ! * C * D ^ i) * D ^ (n - i + 1) =
↑n ! * ((↑i !)⁻¹ * ↑i !) * C * (D ^ i * D ^ (n - i + 1)) * (↑(n - i)!)⁻¹
[PROOFSTEP]
ring
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
⊢ ∑ i in Finset.range (n + 1), ↑n ! * ((↑i !)⁻¹ * ↑i !) * C * (D ^ i * D ^ (n - i + 1)) * (↑(n - i)!)⁻¹ =
∑ i in Finset.range (n + 1), ↑n ! * 1 * C * D ^ (n + 1) * (↑(n - i)!)⁻¹
[PROOFSTEP]
apply Finset.sum_congr rfl fun i hi => ?_
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
i : ℕ
hi : i ∈ Finset.range (n + 1)
⊢ ↑n ! * ((↑i !)⁻¹ * ↑i !) * C * (D ^ i * D ^ (n - i + 1)) * (↑(n - i)!)⁻¹ = ↑n ! * 1 * C * D ^ (n + 1) * (↑(n - i)!)⁻¹
[PROOFSTEP]
congr 2
[GOAL]
case e_a.e_a
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
i : ℕ
hi : i ∈ Finset.range (n + 1)
⊢ ↑n ! * ((↑i !)⁻¹ * ↑i !) * C = ↑n ! * 1 * C
[PROOFSTEP]
congr
[GOAL]
case e_a.e_a.e_a.e_a
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
i : ℕ
hi : i ∈ Finset.range (n + 1)
⊢ (↑i !)⁻¹ * ↑i ! = 1
[PROOFSTEP]
apply inv_mul_cancel
[GOAL]
case e_a.e_a.e_a.e_a.h
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
i : ℕ
hi : i ∈ Finset.range (n + 1)
⊢ ↑i ! ≠ 0
[PROOFSTEP]
simpa only [Ne.def, Nat.cast_eq_zero] using i.factorial_ne_zero
[GOAL]
case e_a.e_a
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
i : ℕ
hi : i ∈ Finset.range (n + 1)
⊢ D ^ i * D ^ (n - i + 1) = D ^ (n + 1)
[PROOFSTEP]
rw [← pow_add]
[GOAL]
case e_a.e_a
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
i : ℕ
hi : i ∈ Finset.range (n + 1)
⊢ D ^ (i + (n - i + 1)) = D ^ (n + 1)
[PROOFSTEP]
congr 1
[GOAL]
case e_a.e_a.e_a
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
i : ℕ
hi : i ∈ Finset.range (n + 1)
⊢ i + (n - i + 1) = n + 1
[PROOFSTEP]
rw [Nat.add_succ, Nat.succ_inj']
[GOAL]
case e_a.e_a.e_a
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
i : ℕ
hi : i ∈ Finset.range (n + 1)
⊢ i + (n - i) = n
[PROOFSTEP]
exact Nat.add_sub_of_le (Finset.mem_range_succ_iff.1 hi)
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
⊢ ∑ i in Finset.range (n + 1), ↑n ! * 1 * C * D ^ (n + 1) * (↑(n - i)!)⁻¹ ≤
∑ i in Finset.range (n + 1), ↑n ! * 1 * C * D ^ (n + 1) * 1
[PROOFSTEP]
apply Finset.sum_le_sum fun i _hi => ?_
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
i : ℕ
_hi : i ∈ Finset.range (n + 1)
⊢ ↑n ! * 1 * C * D ^ (n + 1) * (↑(n - i)!)⁻¹ ≤ ↑n ! * 1 * C * D ^ (n + 1) * 1
[PROOFSTEP]
refine' mul_le_mul_of_nonneg_left _ (by positivity)
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
i : ℕ
_hi : i ∈ Finset.range (n + 1)
⊢ 0 ≤ ↑n ! * 1 * C * D ^ (n + 1)
[PROOFSTEP]
positivity
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
i : ℕ
_hi : i ∈ Finset.range (n + 1)
⊢ (↑(n - i)!)⁻¹ ≤ 1
[PROOFSTEP]
apply inv_le_one
[GOAL]
case ha
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
i : ℕ
_hi : i ∈ Finset.range (n + 1)
⊢ 1 ≤ ↑(n - i)!
[PROOFSTEP]
simpa only [Nat.one_le_cast] using (n - i).factorial_pos
[GOAL]
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝¹⁵ : NormedAddCommGroup D✝
inst✝¹⁴ : NormedSpace 𝕜 D✝
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : 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
Fu Gu✝ : Type u
inst✝⁵ : NormedAddCommGroup Fu
inst✝⁴ : NormedSpace 𝕜 Fu
inst✝³ : NormedAddCommGroup Gu✝
inst✝² : NormedSpace 𝕜 Gu✝
g✝ : Fu → Gu✝
f : E → Fu
n✝ : ℕ
s : Set E
t : Set Fu
x : E
hg✝ : ContDiffOn 𝕜 (↑n✝) g✝ t
hf✝ : ContDiffOn 𝕜 (↑n✝) f s
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC✝ : ∀ (i : ℕ), i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i g✝ t (f x)‖ ≤ C
hD✝ : ∀ (i : ℕ), 1 ≤ i → i ≤ n✝ → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
n : ℕ
IH :
∀ (m : ℕ),
m ≤ n →
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ (i : ℕ), i ≤ m → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(Nat.succ n)) g t
hf : ContDiffOn 𝕜 (↑(Nat.succ n)) f s
hC : ∀ (i : ℕ), i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ Nat.succ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑(Nat.succ n)
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ (i : ℕ), i ∈ Finset.range (n + 1) → ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
⊢ ∑ i in Finset.range (n + 1), ↑n ! * 1 * C * D ^ (n + 1) * 1 = ↑(n + 1)! * C * D ^ (n + 1)
[PROOFSTEP]
simp only [mul_assoc, mul_one, Finset.sum_const, Finset.card_range, nsmul_eq_mul, Nat.factorial_succ, Nat.cast_mul]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
let Fu : Type max uF uG := ULift.{uG, uF} F
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
Fu : Type (max uF uG) := ULift F
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
let Gu : Type max uF uG := ULift.{uF, uG} G
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
have isoF : Fu ≃ₗᵢ[𝕜] F := LinearIsometryEquiv.ulift 𝕜 F
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
have isoG : Gu ≃ₗᵢ[𝕜] G := LinearIsometryEquiv.ulift 𝕜 G
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
let fu : E → Fu := isoF.symm ∘ f
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
let gu : Fu → Gu := isoG.symm ∘ g ∘ isoF
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
let tu := isoF ⁻¹' t
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
have htu : UniqueDiffOn 𝕜 tu := isoF.toContinuousLinearEquiv.uniqueDiffOn_preimage_iff.2 ht
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
have hstu : MapsTo fu s tu := fun y hy ↦ by
simpa only [mem_preimage, comp_apply, LinearIsometryEquiv.apply_symm_apply] using hst hy
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
y : E
hy : y ∈ s
⊢ fu y ∈ tu
[PROOFSTEP]
simpa only [mem_preimage, comp_apply, LinearIsometryEquiv.apply_symm_apply] using hst hy
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
have Ffu : isoF (fu x) = f x := by
simp only [comp_apply, LinearIsometryEquiv.apply_symm_apply]
-- All norms are preserved by the lifting process.
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
⊢ ↑isoF (fu x) = f x
[PROOFSTEP]
simp only [comp_apply, LinearIsometryEquiv.apply_symm_apply]
-- All norms are preserved by the lifting process.
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
Ffu : ↑isoF (fu x) = f x
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
have hfu : ContDiffOn 𝕜 n fu s := isoF.symm.contDiff.comp_contDiffOn (hf.of_le hn)
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
Ffu : ↑isoF (fu x) = f x
hfu : ContDiffOn 𝕜 (↑n) fu s
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
have hgu : ContDiffOn 𝕜 n gu tu :=
isoG.symm.contDiff.comp_contDiffOn ((hg.of_le hn).comp_continuousLinearMap (isoF : Fu →L[𝕜] F))
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
Ffu : ↑isoF (fu x) = f x
hfu : ContDiffOn 𝕜 (↑n) fu s
hgu : ContDiffOn 𝕜 (↑n) gu tu
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
have Nfu : ∀ i, ‖iteratedFDerivWithin 𝕜 i fu s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖ := fun i ↦ by
rw [LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_left _ _ hs hx]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
Ffu : ↑isoF (fu x) = f x
hfu : ContDiffOn 𝕜 (↑n) fu s
hgu : ContDiffOn 𝕜 (↑n) gu tu
i : ℕ
⊢ ‖iteratedFDerivWithin 𝕜 i fu s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
[PROOFSTEP]
rw [LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_left _ _ hs hx]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
Ffu : ↑isoF (fu x) = f x
hfu : ContDiffOn 𝕜 (↑n) fu s
hgu : ContDiffOn 𝕜 (↑n) gu tu
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
simp_rw [← Nfu] at hD
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
Ffu : ↑isoF (fu x) = f x
hfu : ContDiffOn 𝕜 (↑n) fu s
hgu : ContDiffOn 𝕜 (↑n) gu tu
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoF) ∘ f) s x‖ ≤ D ^ i
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
have Ngu : ∀ i, ‖iteratedFDerivWithin 𝕜 i gu tu (fu x)‖ = ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ := fun i ↦
by
rw [LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_left _ _ htu (hstu hx)]
rw [LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_right _ _ ht, Ffu]
rw [Ffu]
exact hst hx
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
Ffu : ↑isoF (fu x) = f x
hfu : ContDiffOn 𝕜 (↑n) fu s
hgu : ContDiffOn 𝕜 (↑n) gu tu
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoF) ∘ f) s x‖ ≤ D ^ i
i : ℕ
⊢ ‖iteratedFDerivWithin 𝕜 i gu tu (fu x)‖ = ‖iteratedFDerivWithin 𝕜 i g t (f x)‖
[PROOFSTEP]
rw [LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_left _ _ htu (hstu hx)]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
Ffu : ↑isoF (fu x) = f x
hfu : ContDiffOn 𝕜 (↑n) fu s
hgu : ContDiffOn 𝕜 (↑n) gu tu
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoF) ∘ f) s x‖ ≤ D ^ i
i : ℕ
⊢ ‖iteratedFDerivWithin 𝕜 i (g ∘ ↑isoF) tu (fu x)‖ = ‖iteratedFDerivWithin 𝕜 i g t (f x)‖
[PROOFSTEP]
rw [LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_right _ _ ht, Ffu]
[GOAL]
case hx
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
Ffu : ↑isoF (fu x) = f x
hfu : ContDiffOn 𝕜 (↑n) fu s
hgu : ContDiffOn 𝕜 (↑n) gu tu
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoF) ∘ f) s x‖ ≤ D ^ i
i : ℕ
⊢ ↑isoF (fu x) ∈ t
[PROOFSTEP]
rw [Ffu]
[GOAL]
case hx
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
Ffu : ↑isoF (fu x) = f x
hfu : ContDiffOn 𝕜 (↑n) fu s
hgu : ContDiffOn 𝕜 (↑n) gu tu
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoF) ∘ f) s x‖ ≤ D ^ i
i : ℕ
⊢ f x ∈ t
[PROOFSTEP]
exact hst hx
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
Ffu : ↑isoF (fu x) = f x
hfu : ContDiffOn 𝕜 (↑n) fu s
hgu : ContDiffOn 𝕜 (↑n) gu tu
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoF) ∘ f) s x‖ ≤ D ^ i
Ngu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu tu (fu x)‖ = ‖iteratedFDerivWithin 𝕜 i g t (f x)‖
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
simp_rw [← Ngu] at hC
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
Ffu : ↑isoF (fu x) = f x
hfu : ContDiffOn 𝕜 (↑n) fu s
hgu : ContDiffOn 𝕜 (↑n) gu tu
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoF) ∘ f) s x‖ ≤ D ^ i
Ngu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu tu (fu x)‖ = ‖iteratedFDerivWithin 𝕜 i g t (f x)‖
hC :
∀ (i : ℕ),
i ≤ n →
‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF) (↑isoF ⁻¹' t)
((↑(LinearIsometryEquiv.symm isoF) ∘ f) x)‖ ≤
C
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
have Nfgu : ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ = ‖iteratedFDerivWithin 𝕜 n (gu ∘ fu) s x‖ :=
by
have : gu ∘ fu = isoG.symm ∘ g ∘ f := by
ext x
simp only [comp_apply, LinearIsometryEquiv.map_eq_iff, LinearIsometryEquiv.apply_symm_apply]
rw [this, LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_left _ _ hs hx]
-- deduce the required bound from the one for `gu ∘ fu`.
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
Ffu : ↑isoF (fu x) = f x
hfu : ContDiffOn 𝕜 (↑n) fu s
hgu : ContDiffOn 𝕜 (↑n) gu tu
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoF) ∘ f) s x‖ ≤ D ^ i
Ngu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu tu (fu x)‖ = ‖iteratedFDerivWithin 𝕜 i g t (f x)‖
hC :
∀ (i : ℕ),
i ≤ n →
‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF) (↑isoF ⁻¹' t)
((↑(LinearIsometryEquiv.symm isoF) ∘ f) x)‖ ≤
C
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ = ‖iteratedFDerivWithin 𝕜 n (gu ∘ fu) s x‖
[PROOFSTEP]
have : gu ∘ fu = isoG.symm ∘ g ∘ f := by
ext x
simp only [comp_apply, LinearIsometryEquiv.map_eq_iff, LinearIsometryEquiv.apply_symm_apply]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
Ffu : ↑isoF (fu x) = f x
hfu : ContDiffOn 𝕜 (↑n) fu s
hgu : ContDiffOn 𝕜 (↑n) gu tu
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoF) ∘ f) s x‖ ≤ D ^ i
Ngu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu tu (fu x)‖ = ‖iteratedFDerivWithin 𝕜 i g t (f x)‖
hC :
∀ (i : ℕ),
i ≤ n →
‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF) (↑isoF ⁻¹' t)
((↑(LinearIsometryEquiv.symm isoF) ∘ f) x)‖ ≤
C
⊢ gu ∘ fu = ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ f
[PROOFSTEP]
ext x
[GOAL]
case h.h
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x✝ : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x✝ ∈ s
C D : ℝ
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
Ffu : ↑isoF (fu x✝) = f x✝
hfu : ContDiffOn 𝕜 (↑n) fu s
hgu : ContDiffOn 𝕜 (↑n) gu tu
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu s x✝‖ = ‖iteratedFDerivWithin 𝕜 i f s x✝‖
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoF) ∘ f) s x✝‖ ≤ D ^ i
Ngu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu tu (fu x✝)‖ = ‖iteratedFDerivWithin 𝕜 i g t (f x✝)‖
hC :
∀ (i : ℕ),
i ≤ n →
‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF) (↑isoF ⁻¹' t)
((↑(LinearIsometryEquiv.symm isoF) ∘ f) x✝)‖ ≤
C
x : E
⊢ ((gu ∘ fu) x).down = ((↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ f) x).down
[PROOFSTEP]
simp only [comp_apply, LinearIsometryEquiv.map_eq_iff, LinearIsometryEquiv.apply_symm_apply]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
Ffu : ↑isoF (fu x) = f x
hfu : ContDiffOn 𝕜 (↑n) fu s
hgu : ContDiffOn 𝕜 (↑n) gu tu
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoF) ∘ f) s x‖ ≤ D ^ i
Ngu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu tu (fu x)‖ = ‖iteratedFDerivWithin 𝕜 i g t (f x)‖
hC :
∀ (i : ℕ),
i ≤ n →
‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF) (↑isoF ⁻¹' t)
((↑(LinearIsometryEquiv.symm isoF) ∘ f) x)‖ ≤
C
this : gu ∘ fu = ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ f
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ = ‖iteratedFDerivWithin 𝕜 n (gu ∘ fu) s x‖
[PROOFSTEP]
rw [this, LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_left _ _ hs hx]
-- deduce the required bound from the one for `gu ∘ fu`.
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
Ffu : ↑isoF (fu x) = f x
hfu : ContDiffOn 𝕜 (↑n) fu s
hgu : ContDiffOn 𝕜 (↑n) gu tu
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoF) ∘ f) s x‖ ≤ D ^ i
Ngu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu tu (fu x)‖ = ‖iteratedFDerivWithin 𝕜 i g t (f x)‖
hC :
∀ (i : ℕ),
i ≤ n →
‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF) (↑isoF ⁻¹' t)
((↑(LinearIsometryEquiv.symm isoF) ∘ f) x)‖ ≤
C
Nfgu : ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ = ‖iteratedFDerivWithin 𝕜 n (gu ∘ fu) s x‖
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
rw [Nfgu]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
s : Set E
t : Set F
x : E
N : ℕ∞
hg : ContDiffOn 𝕜 N g t
hf : ContDiffOn 𝕜 N f s
hn : ↑n ≤ N
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
Fu : Type (max uF uG) := ULift F
Gu : Type (max uF uG) := ULift G
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : E → Fu := ↑(LinearIsometryEquiv.symm isoF) ∘ f
gu : Fu → Gu := ↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF
tu : Set Fu := ↑isoF ⁻¹' t
htu : UniqueDiffOn 𝕜 tu
hstu : MapsTo fu s tu
Ffu : ↑isoF (fu x) = f x
hfu : ContDiffOn 𝕜 (↑n) fu s
hgu : ContDiffOn 𝕜 (↑n) gu tu
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu s x‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoF) ∘ f) s x‖ ≤ D ^ i
Ngu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i gu tu (fu x)‖ = ‖iteratedFDerivWithin 𝕜 i g t (f x)‖
hC :
∀ (i : ℕ),
i ≤ n →
‖iteratedFDerivWithin 𝕜 i (↑(LinearIsometryEquiv.symm isoG) ∘ g ∘ ↑isoF) (↑isoF ⁻¹' t)
((↑(LinearIsometryEquiv.symm isoF) ∘ f) x)‖ ≤
C
Nfgu : ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ = ‖iteratedFDerivWithin 𝕜 n (gu ∘ fu) s x‖
⊢ ‖iteratedFDerivWithin 𝕜 n (gu ∘ fu) s x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
exact norm_iteratedFDerivWithin_comp_le_aux hgu hfu htu hs hstu hx hC hD
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
N : ℕ∞
hg : ContDiff 𝕜 N g
hf : ContDiff 𝕜 N f
hn : ↑n ≤ N
x : E
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDeriv 𝕜 i g (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDeriv 𝕜 i f x‖ ≤ D ^ i
⊢ ‖iteratedFDeriv 𝕜 n (g ∘ f) x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
simp_rw [← iteratedFDerivWithin_univ] at hC hD ⊢
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D✝ : Type uD
inst✝⁹ : NormedAddCommGroup D✝
inst✝⁸ : NormedSpace 𝕜 D✝
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
g : F → G
f : E → F
n : ℕ
N : ℕ∞
hg : ContDiff 𝕜 N g
hf : ContDiff 𝕜 N f
hn : ↑n ≤ N
x : E
C D : ℝ
hC : ∀ (i : ℕ), i ≤ n → ‖iteratedFDerivWithin 𝕜 i g univ (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f univ x‖ ≤ D ^ i
⊢ ‖iteratedFDerivWithin 𝕜 n (g ∘ f) univ x‖ ≤ ↑n ! * C * D ^ n
[PROOFSTEP]
exact
norm_iteratedFDerivWithin_comp_le hg.contDiffOn hf.contDiffOn hn uniqueDiffOn_univ uniqueDiffOn_univ (mapsTo_univ _ _)
(mem_univ x) hC hD
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F →L[𝕜] G
g : E → F
s : Set E
x : E
N : ℕ∞
n : ℕ
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
hn : ↑n ≤ N
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(f y) (g y)) s x‖ ≤
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
let B : (F →L[𝕜] G) →L[𝕜] F →L[𝕜] G := ContinuousLinearMap.flip (ContinuousLinearMap.apply 𝕜 G)
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F →L[𝕜] G
g : E → F
s : Set E
x : E
N : ℕ∞
n : ℕ
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
hn : ↑n ≤ N
B : (F →L[𝕜] G) →L[𝕜] F →L[𝕜] G := ContinuousLinearMap.flip (ContinuousLinearMap.apply 𝕜 G)
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(f y) (g y)) s x‖ ≤
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
have hB : ‖B‖ ≤ 1 := by
simp only [ContinuousLinearMap.op_norm_flip, ContinuousLinearMap.apply]
refine' ContinuousLinearMap.op_norm_le_bound _ zero_le_one fun f => _
simp only [ContinuousLinearMap.coe_id', id.def, one_mul]
rfl
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F →L[𝕜] G
g : E → F
s : Set E
x : E
N : ℕ∞
n : ℕ
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
hn : ↑n ≤ N
B : (F →L[𝕜] G) →L[𝕜] F →L[𝕜] G := ContinuousLinearMap.flip (ContinuousLinearMap.apply 𝕜 G)
⊢ ‖B‖ ≤ 1
[PROOFSTEP]
simp only [ContinuousLinearMap.op_norm_flip, ContinuousLinearMap.apply]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F →L[𝕜] G
g : E → F
s : Set E
x : E
N : ℕ∞
n : ℕ
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
hn : ↑n ≤ N
B : (F →L[𝕜] G) →L[𝕜] F →L[𝕜] G := ContinuousLinearMap.flip (ContinuousLinearMap.apply 𝕜 G)
⊢ ‖ContinuousLinearMap.id 𝕜 (F →L[𝕜] G)‖ ≤ 1
[PROOFSTEP]
refine' ContinuousLinearMap.op_norm_le_bound _ zero_le_one fun f => _
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f✝ : E → F →L[𝕜] G
g : E → F
s : Set E
x : E
N : ℕ∞
n : ℕ
hf : ContDiffOn 𝕜 N f✝ s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
hn : ↑n ≤ N
B : (F →L[𝕜] G) →L[𝕜] F →L[𝕜] G := ContinuousLinearMap.flip (ContinuousLinearMap.apply 𝕜 G)
f : F →L[𝕜] G
⊢ ‖↑(ContinuousLinearMap.id 𝕜 (F →L[𝕜] G)) f‖ ≤ 1 * ‖f‖
[PROOFSTEP]
simp only [ContinuousLinearMap.coe_id', id.def, one_mul]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f✝ : E → F →L[𝕜] G
g : E → F
s : Set E
x : E
N : ℕ∞
n : ℕ
hf : ContDiffOn 𝕜 N f✝ s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
hn : ↑n ≤ N
B : (F →L[𝕜] G) →L[𝕜] F →L[𝕜] G := ContinuousLinearMap.flip (ContinuousLinearMap.apply 𝕜 G)
f : F →L[𝕜] G
⊢ ‖f‖ ≤ ‖f‖
[PROOFSTEP]
rfl
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F →L[𝕜] G
g : E → F
s : Set E
x : E
N : ℕ∞
n : ℕ
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
hn : ↑n ≤ N
B : (F →L[𝕜] G) →L[𝕜] F →L[𝕜] G := ContinuousLinearMap.flip (ContinuousLinearMap.apply 𝕜 G)
hB : ‖B‖ ≤ 1
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(f y) (g y)) s x‖ ≤
∑ i in Finset.range (n + 1),
↑(Nat.choose n i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
[PROOFSTEP]
exact B.norm_iteratedFDerivWithin_le_of_bilinear_of_le_one hf hg hs hx hn hB
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F →L[𝕜] G
g : E → F
N : ℕ∞
n : ℕ
hf : ContDiff 𝕜 N f
hg : ContDiff 𝕜 N g
x : E
hn : ↑n ≤ N
⊢ ‖iteratedFDeriv 𝕜 n (fun y => ↑(f y) (g y)) x‖ ≤
∑ i in Finset.range (n + 1), ↑(Nat.choose n i) * ‖iteratedFDeriv 𝕜 i f x‖ * ‖iteratedFDeriv 𝕜 (n - i) g x‖
[PROOFSTEP]
simp only [← iteratedFDerivWithin_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F →L[𝕜] G
g : E → F
N : ℕ∞
n : ℕ
hf : ContDiff 𝕜 N f
hg : ContDiff 𝕜 N g
x : E
hn : ↑n ≤ N
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(f y) (g y)) univ x‖ ≤
∑ x_1 in Finset.range (n + 1),
↑(Nat.choose n x_1) * ‖iteratedFDerivWithin 𝕜 x_1 f univ x‖ * ‖iteratedFDerivWithin 𝕜 (n - x_1) g univ x‖
[PROOFSTEP]
exact norm_iteratedFDerivWithin_clm_apply hf.contDiffOn hg.contDiffOn uniqueDiffOn_univ (Set.mem_univ x) hn
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F →L[𝕜] G
c : F
s : Set E
x : E
N : ℕ∞
n : ℕ
hf : ContDiffOn 𝕜 N f s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
hn : ↑n ≤ N
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(f y) c) s x‖ ≤ ‖c‖ * ‖iteratedFDerivWithin 𝕜 n f s x‖
[PROOFSTEP]
let g : (F →L[𝕜] G) →L[𝕜] G := ContinuousLinearMap.apply 𝕜 G c
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F →L[𝕜] G
c : F
s : Set E
x : E
N : ℕ∞
n : ℕ
hf : ContDiffOn 𝕜 N f s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
hn : ↑n ≤ N
g : (F →L[𝕜] G) →L[𝕜] G := ↑(ContinuousLinearMap.apply 𝕜 G) c
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(f y) c) s x‖ ≤ ‖c‖ * ‖iteratedFDerivWithin 𝕜 n f s x‖
[PROOFSTEP]
have h := g.norm_compContinuousMultilinearMap_le (iteratedFDerivWithin 𝕜 n f s x)
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F →L[𝕜] G
c : F
s : Set E
x : E
N : ℕ∞
n : ℕ
hf : ContDiffOn 𝕜 N f s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
hn : ↑n ≤ N
g : (F →L[𝕜] G) →L[𝕜] G := ↑(ContinuousLinearMap.apply 𝕜 G) c
h :
‖ContinuousLinearMap.compContinuousMultilinearMap g (iteratedFDerivWithin 𝕜 n f s x)‖ ≤
‖g‖ * ‖iteratedFDerivWithin 𝕜 n f s x‖
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(f y) c) s x‖ ≤ ‖c‖ * ‖iteratedFDerivWithin 𝕜 n f s x‖
[PROOFSTEP]
rw [← g.iteratedFDerivWithin_comp_left hf hs hx hn] at h
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F →L[𝕜] G
c : F
s : Set E
x : E
N : ℕ∞
n : ℕ
hf : ContDiffOn 𝕜 N f s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
hn : ↑n ≤ N
g : (F →L[𝕜] G) →L[𝕜] G := ↑(ContinuousLinearMap.apply 𝕜 G) c
h : ‖iteratedFDerivWithin 𝕜 n (↑g ∘ f) s x‖ ≤ ‖g‖ * ‖iteratedFDerivWithin 𝕜 n f s x‖
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(f y) c) s x‖ ≤ ‖c‖ * ‖iteratedFDerivWithin 𝕜 n f s x‖
[PROOFSTEP]
refine' h.trans (mul_le_mul_of_nonneg_right _ (norm_nonneg _))
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F →L[𝕜] G
c : F
s : Set E
x : E
N : ℕ∞
n : ℕ
hf : ContDiffOn 𝕜 N f s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
hn : ↑n ≤ N
g : (F →L[𝕜] G) →L[𝕜] G := ↑(ContinuousLinearMap.apply 𝕜 G) c
h : ‖iteratedFDerivWithin 𝕜 n (↑g ∘ f) s x‖ ≤ ‖g‖ * ‖iteratedFDerivWithin 𝕜 n f s x‖
⊢ ‖g‖ ≤ ‖c‖
[PROOFSTEP]
refine' g.op_norm_le_bound (norm_nonneg _) fun f => _
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f✝ : E → F →L[𝕜] G
c : F
s : Set E
x : E
N : ℕ∞
n : ℕ
hf : ContDiffOn 𝕜 N f✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
hn : ↑n ≤ N
g : (F →L[𝕜] G) →L[𝕜] G := ↑(ContinuousLinearMap.apply 𝕜 G) c
h : ‖iteratedFDerivWithin 𝕜 n (↑g ∘ f✝) s x‖ ≤ ‖g‖ * ‖iteratedFDerivWithin 𝕜 n f✝ s x‖
f : F →L[𝕜] G
⊢ ‖↑g f‖ ≤ ‖c‖ * ‖f‖
[PROOFSTEP]
rw [ContinuousLinearMap.apply_apply, mul_comm]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f✝ : E → F →L[𝕜] G
c : F
s : Set E
x : E
N : ℕ∞
n : ℕ
hf : ContDiffOn 𝕜 N f✝ s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
hn : ↑n ≤ N
g : (F →L[𝕜] G) →L[𝕜] G := ↑(ContinuousLinearMap.apply 𝕜 G) c
h : ‖iteratedFDerivWithin 𝕜 n (↑g ∘ f✝) s x‖ ≤ ‖g‖ * ‖iteratedFDerivWithin 𝕜 n f✝ s x‖
f : F →L[𝕜] G
⊢ ‖↑f c‖ ≤ ‖f‖ * ‖c‖
[PROOFSTEP]
exact f.le_op_norm c
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F →L[𝕜] G
c : F
x : E
N : ℕ∞
n : ℕ
hf : ContDiff 𝕜 N f
hn : ↑n ≤ N
⊢ ‖iteratedFDeriv 𝕜 n (fun y => ↑(f y) c) x‖ ≤ ‖c‖ * ‖iteratedFDeriv 𝕜 n f x‖
[PROOFSTEP]
simp only [← iteratedFDerivWithin_univ]
[GOAL]
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : 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
f : E → F →L[𝕜] G
c : F
x : E
N : ℕ∞
n : ℕ
hf : ContDiff 𝕜 N f
hn : ↑n ≤ N
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(f y) c) univ x‖ ≤ ‖c‖ * ‖iteratedFDerivWithin 𝕜 n f univ x‖
[PROOFSTEP]
exact norm_iteratedFDerivWithin_clm_apply_const hf.contDiffOn uniqueDiffOn_univ (Set.mem_univ x) hn
|
Require Import GHC.Base.
Import GHC.Base.Notations.
Require Import Proofs.GHC.Base.
Require Import Data.Map.Internal.
Import GHC.Num.Notations.
Require Import OrdTactic.
Require Import Psatz.
Require Import Tactics.
Set Bullet Behavior "Strict Subproofs".
(** ** Tactics for pointer equality *)
Ltac destruct_ptrEq := lazymatch goal with
| |- context [if PtrEquality.ptrEq ?x ?y && PtrEquality.ptrEq ?x2 ?y2 then _ else _]
=> let Hpe := fresh "Hpe" in
let Hpe1 := fresh "Hpe1" in
let Hpe2 := fresh "Hpe2" in
destruct (PtrEquality.ptrEq x y && PtrEquality.ptrEq x2 y2) eqn:Hpe;
[ rewrite andb_true_iff in Hpe;
destruct Hpe as [Hpe1 Hpe2];
apply PtrEquality.ptrEq_eq in Hpe1;
apply PtrEquality.ptrEq_eq in Hpe2;
subst
| clear Hpe]
| |- context [if PtrEquality.ptrEq ?x ?y then _ else _]
=> let Hpe := fresh "Hpe" in
destruct (PtrEquality.ptrEq x y) eqn:Hpe;
[ apply PtrEquality.ptrEq_eq in Hpe; subst
| clear Hpe]
end.
(** * Tactics for option-valued functions *)
Section oro.
Context {a : Type}.
Definition oro : option a -> option a -> option a :=
fun x y => match x with
| Some v => Some v
| None => y
end.
Infix "|||" := oro.
Definition ando : option a -> option a -> option a :=
fun x y => match y with None => None | _ => x end.
Infix "&&&" := ando.
Definition diffo : option a -> option a -> option a :=
fun x y => match y with
| Some v => None
| None => x
end.
Lemma oro_None_l : forall x, None ||| x = x.
Proof. intros. destruct x; reflexivity. Qed.
Lemma oro_None_r : forall x, x ||| None = x.
Proof. intros. destruct x; reflexivity. Qed.
Lemma oro_Some_l : forall x y, Some x ||| y = Some x.
Proof. intros. reflexivity. Qed.
Lemma oro_Some_iff: forall x y v, x ||| y = Some v <-> (x = Some v \/ (x = None /\ y = Some v)).
Proof. intros. destruct x, y; simpl; intuition congruence. Qed.
Lemma ando_None_l : forall x, None &&& x = None.
Proof. intros. destruct x; reflexivity. Qed.
Lemma ando_None_r : forall x, x &&& None = None.
Proof. intros. destruct x; reflexivity. Qed.
Lemma ando_Some_r : forall x y, x &&& Some y = x.
Proof. intros. reflexivity. Qed.
Definition SomeIf (b : bool) (x : a) : option a :=
if b then Some x else None.
Lemma SomeIf_eq_Some : forall b x y,
SomeIf b x = Some y <-> b = true /\ x = y.
Proof. intros. destruct b; simpl in *; intuition try congruence. Qed.
Lemma SomeIf_eq_None : forall b x,
SomeIf b x = None <-> b = false.
Proof. intros. destruct b; simpl in *; intuition try congruence. Qed.
Definition isSome (x : option a) : bool := if x then true else false.
Lemma isSome_oro : forall x y, isSome (x ||| y) = isSome x || isSome y.
Proof. intros. destruct x, y; reflexivity. Qed.
Lemma isSome_ando : forall x y, isSome (x &&& y) = isSome x && isSome y.
Proof. intros. destruct x, y; reflexivity. Qed.
Lemma isSome_SomeIf : forall b x, isSome (SomeIf b x) = b.
Proof. intros. destruct b; reflexivity. Qed.
End oro.
Infix "|||" := oro.
Infix "&&&" := ando.
Ltac simpl_options := repeat lazymatch goal with
| |- context [true || ?x] => rewrite (orb_true_l x)
| H: context [true || ?x] |- _ => rewrite (orb_true_l x) in H
| |- context [?x || true] => rewrite (orb_true_r x)
| H: context [?x || true] |- _ => rewrite (orb_true_r x) in H
| |- context [false || ?x] => rewrite (orb_false_l x)
| H: context [false || ?x] |- _ => rewrite (orb_false_l x) in H
| |- context [?x || false] => rewrite (orb_false_r x)
| H: context [?x || false] |- _ => rewrite (orb_false_r x) in H
| |- context [None ||| ?x] => rewrite (oro_None_l x)
| H: context [None ||| ?x] |- _ => rewrite (oro_None_l x) in H
| |- context [?x ||| None] => rewrite (oro_None_r x)
| H: context [?x ||| None] |- _ => rewrite (oro_None_r x) in H
| |- context [Some ?x ||| ?y] => rewrite (oro_Some_l x y)
| H: context [Some ?x ||| ?y] |- _ => rewrite (oro_Some_l x y) in H
| |- context [None &&& ?x] => rewrite (ando_None_l x)
| H: context [None &&& ?x] |- _ => rewrite (ando_None_l x) in H
| |- context [?x &&& None] => rewrite (ando_None_r x)
| H: context [?x &&& None] |- _ => rewrite (ando_None_r x) in H
| |- context [?x &&& Some ?y] => rewrite (ando_Some_r x y)
| H: context [?x &&& Some ?y] |- _ => rewrite (ando_Some_r x y) in H
| |- context [isSome (?x &&& ?y)] => rewrite (isSome_ando x y)
| H: context [isSome (?x &&& ?y)] |- _ => rewrite (isSome_ando x y) in H
| |- context [isSome (?x ||| ?y)] => rewrite (isSome_oro x y)
| H: context [isSome (?x ||| ?y)] |- _ => rewrite (isSome_oro x y) in H
| |- context [isSome (Some ?x)] => simpl (isSome (Some x))
| H: context [isSome (Some ?x)] |- _ => simpl (isSome (Some x)) in H
| |- context [isSome None] => simpl (isSome None)
| H: context [isSome None] |- _ => simpl (isSome None) in H
| |- context [isSome (SomeIf ?b ?x)] => rewrite (isSome_SomeIf b x)
| H: context [isSome (SomeIf ?b ?x)] |- _ => rewrite (isSome_SomeIf b x) in H
| |- context [SomeIf false ?x] => simpl (SomeIf false x)
| H: context [SomeIf false ?x] |- _ => simpl (SomeIf false x) in H
| |- context [SomeIf true ?x] => simpl (SomeIf true x)
| H: context [SomeIf true ?x] |- _ => simpl (SomeIf true x) in H
| |- context [SomeIf ?b ?x = Some ?y] => rewrite (SomeIf_eq_Some b x y)
| H: context [SomeIf ?b ?x = Some ?y] |- _ => rewrite (SomeIf_eq_Some b x y) in H; destruct H; subst
| |- context [SomeIf ?b ?x = None] => rewrite (SomeIf_eq_None b x)
| H: context [SomeIf ?b ?x = None] |- _ => rewrite (SomeIf_eq_None b x) in H; subst
end; lazy match in *.
Section WF.
Context {e : Type} {a : Type} {HEq : Eq_ e} {HOrd : Ord e} {HEqLaws : EqLaws e} {HOrdLaws : OrdLaws e}.
(** ** Utilities for working with [Ord] *)
(* We don’t have a OrdLawful class yet. We need to introduce that,
add it to the context, and derive all axioms from that.
*)
Lemma compare_Eq : forall (x y : e),
compare x y = Eq <-> x == y = true.
Proof. order e. Qed.
Lemma compare_Lt : forall (x y : e),
compare x y = Lt <-> x < y = true.
Proof. order e. Qed.
Lemma compare_Gt : forall (x y : e),
compare x y = Gt <-> x > y = true.
Proof. order e. Qed.
Lemma lt_eq_r : forall x y z,
x < y = true ->
z == y = true ->
x < z = true.
Proof. order e. Qed.
Lemma lt_eq_l : forall x y z,
x < y = true ->
z == x = true ->
z < y = true.
Proof. order e. Qed.
Lemma lt_not_eq : forall (x y : e),
x < y = true -> x == y = false.
Proof. order e. Qed.
Lemma gt_not_eq : forall (x y : e),
x > y = true -> x == y = false.
Proof. order e. Qed.
Lemma lt_gt : forall (x y : e), (x > y) = (y < x).
Proof. order e. Qed.
Lemma lt_trans : forall (x y z : e),
x < y = true -> y < z = true -> x < z = true.
Proof. order e. Qed.
(** This is just like size, but with a type signature that does not confuse [lia] *)
Definition size (s : Map e a) : Z :=
match s with | Bin sz _ _ _ _ => sz
| Tip => 0 end.
Lemma size_size: Internal.size = size.
Proof. reflexivity. Qed.
(** * Well-formedness *)
(* Bounds may be absent (infinity) *)
Definition bound := (option e)%type.
(** A suitable comparision operator for bounds.
If someone feels like it, then you may introduce nice notation. *)
Definition isLB : bound -> e -> bool :=
fun lb e => match lb with
| Some lb => lb < e
| None => true
end.
Definition isUB : bound -> e -> bool :=
fun ub e => match ub with
| Some ub => e < ub
| None => true
end.
Ltac order_Bounds :=
intros;
simpl isUB in *;
simpl isLB in *;
repeat (congruence || lazymatch goal with
| H : isUB ?ub _ = false |- _ => destruct ub; simpl isUB in *
| |- isUB ?ub _ = _ => destruct ub; simpl isUB in *
| H : isLB ?lb _ = false |- _ => destruct lb; simpl isLB in *
| |- isLB ?lb _ = _ => destruct lb; simpl isLB in *
end);
order e.
Lemma isLB_lt:
forall lb x y,
isLB lb x = true->
x < y = true ->
isLB lb y = true.
Proof. order_Bounds. Qed.
Lemma isUB_lt:
forall ub x y,
isUB ub x = true->
y < x = true ->
isUB ub y = true.
Proof. order_Bounds. Qed.
(** The balancing property of a binary node *)
Definition balance_prop sz1 sz2 :=
(sz1 + sz2 <= 1 \/ sz1 <= delta * sz2 /\ sz2 <= delta * sz1)%Z.
(** One precondition for [balanceL]: The left tree has been inserted to (but not by too much).
This is mechanically derived from the context in the call to [balanceL] in [link], and
unfortunately not very educational.
*)
Definition balance_prop_inserted sz1 sz2 :=
(delta * sz1 <= delta*delta*sz2 + delta*sz2 + sz2 /\ sz2 <= sz1)%Z.
(* NB: this does not work:
Definition balance_prop_inserted sz1 sz2 := balance_prop sz1 sz2.
*)
Fixpoint sem (s : Map e a) (i : e) : option a :=
match s with | Bin _ x v s1 s2 => sem s1 i ||| SomeIf (i == x) v ||| sem s2 i
| Tip => None end.
Lemma sem_resp_eq : forall s i j,
i == j = true -> sem s i = sem s j.
Proof.
intros.
induction s.
* simpl.
rewrite IHs1, IHs2.
replace (j == k) with (i == k) by order e.
reflexivity.
* reflexivity.
Qed.
(** This inductive predicate describes when sets are well-formed within
(exclusive) bounds.
*)
Inductive Bounded : Map e a -> bound -> bound -> Prop :=
| BoundedTip : forall lb ub,
Bounded Tip lb ub
| BoundedBin :
forall lb ub,
forall s1,
forall s2,
forall x v sz,
Bounded s1 lb (Some x) ->
Bounded s2 (Some x) ub ->
isLB lb x = true ->
isUB ub x = true ->
sz = (1 + size s1 + size s2)%Z ->
balance_prop (size s1) (size s2) ->
Bounded (Bin sz x v s1 s2) lb ub.
(** ** Lemmas related to well-formedness *)
(** There are no values outside the bounds *)
Lemma sem_outside_below:
forall {s lb ub i},
Bounded s lb ub ->
isLB lb i = false ->
sem s i = None.
Proof.
intros ???? HD ?.
induction HD; intros; subst; simpl in *; intuition.
rewrite H2.
rewrite IHHD2 by order_Bounds.
simpl_options.
order_Bounds.
Qed.
Lemma sem_outside_above:
forall {s lb ub i},
Bounded s lb ub ->
isUB ub i = false ->
sem s i = None.
Proof.
intros ???? HD ?.
induction HD; intros; subst; simpl in *; intuition.
rewrite H2.
rewrite IHHD1 by order_Bounds.
simpl_options.
order_Bounds.
Qed.
Lemma sem_inside:
forall {s lb ub i v},
Bounded s lb ub ->
sem s i = Some v ->
isLB lb i = true /\ isUB ub i = true.
Proof.
intros ????? HD ?.
induction HD; intros; subst; simpl in *; rewrite ?oro_Some_iff in H; intuition; try congruence;
simpl_options;
order_Bounds.
Qed.
Lemma sem_inside_isSome:
forall {s lb ub i},
Bounded s lb ub ->
isSome (sem s i) = true ->
isLB lb i = true /\ isUB ub i = true.
Proof.
intros ???? HD ?.
destruct (sem s i) eqn:H1; simpl in *; try congruence.
eapply sem_inside; eassumption.
Qed.
(* We use this as a rewrite rule because
[simpl (size (Bin _ _ _ _ ))]
simplifies the [ 1 + _ ] which is annoying. *)
Lemma size_Bin: forall sz x v (s1 s2 : Map e a),
size (Bin sz x v s1 s2) = sz.
Proof. intros. reflexivity. Qed.
(* Pose the proof [prf], unless it already exists. *)
Ltac pose_new prf :=
let prop := type of prf in
match goal with
| [ H : prop |- _] => fail 1
| _ => pose proof prf
end.
(* Pose the [prop], using [prf], unless it already exists. *)
Ltac assert_new prop prf :=
match goal with
| [ H : prop |- _] => fail 1
| _ => assert prop by prf
end.
Lemma size_nonneg:
forall {s lb ub},
Bounded s lb ub -> (0 <= size s)%Z.
Proof.
intros ??? HD.
induction HD.
* simpl. lia.
* simpl. lia.
Qed.
Ltac postive_sizes :=
repeat match goal with [ H : Bounded ?s _ _ |- _ ] => pose_new (size_nonneg H) end.
Lemma size_0_iff_tip:
forall {s lb ub},
Bounded s lb ub -> (size s = 0)%Z <-> s = Tip.
Proof.
induction 1.
* intuition.
* postive_sizes;
rewrite ?size_Bin in *.
intuition try (congruence || lia).
Qed.
(** The main point of the balancing condition: Logarithmic height (Same as SetProofs)*)
Fixpoint height (s :Map e a) : Z := match s with
| Tip => 0%Z
| Bin _ _ _ s1 s2 => (1 + max (height s1) (height s2))%Z
end.
Lemma height_nonneg:
forall m, (0 <= height m)%Z.
Proof. induction m; cbn -[Z.add]; lia. Qed.
Ltac postive_heights :=
repeat match goal with [ m : Map e a |- _ ] => pose_new (height_nonneg m) end.
Lemma size_height_1:
forall {m lb ub},
Bounded m lb ub -> (size m = 1)%Z -> height m = 1%Z.
Proof.
intros.
destruct H.
+ inversion H0.
+ destruct H, H1; cbn -[Z.add] in *; postive_sizes; try lia; try reflexivity.
Qed.
Lemma Bounded_size_bound : forall m lb ub,
Bounded m lb ub -> (4^(height m - 1) <= size m*3^(height m - 1))%Z.
Proof.
intros ??? HB. induction HB.
* simpl. reflexivity.
* cbn -[Z.add].
postive_sizes.
postive_heights.
+ unfold balance_prop, delta, fromInteger, Num_Integer__ in H2.
apply Z.max_case_strong; intro Hle.
- destruct (Z.leb_spec (size s1 + size s2) 1).
** assert (size s1 = 0 \/ size s1 = 1)%Z as Hsmall by lia.
destruct Hsmall.
++ rewrite (size_0_iff_tip HB1) in *. subst. cbn -[N.add Z.add Z.mul] in *.
simpl Z.sub.
lia.
++ assert (size s2 = 0)%Z by lia.
rewrite (size_0_iff_tip HB2) in *. subst. cbn -[N.add Z.add Z.mul] in *.
replace (height s1) with 1%Z in *
by (symmetry; eapply size_height_1; eassumption).
simpl Z.sub.
lia.
** destruct H2; only 1: lia.
assert (height s1 <> 0%Z)
by (destruct s1; cbn -[Z.add]; postive_heights; simpl size in *; try lia).
replace (((1 + height s1) - 1))%Z with (Z.succ (height s1 - 1)) by lia.
rewrite !Z.pow_succ_r by lia.
etransitivity; only 1: (apply Z.mul_le_mono_nonneg_l; [lia | eassumption]).
rewrite !Z.mul_assoc.
apply Z.mul_le_mono_nonneg_r; only 1: (apply Z.pow_nonneg; lia).
lia.
- destruct (Z.leb_spec (size s1 + size s2) 1).
** assert (size s2 = 0 \/ size s2 = 1)%Z as Hsmall by lia.
destruct Hsmall.
++ rewrite (size_0_iff_tip HB2) in *. subst. cbn -[N.add Z.add Z.mul] in *.
simpl Z.sub.
lia.
++ assert (size s1 = 0)%Z by lia.
rewrite (size_0_iff_tip HB1) in *. subst. cbn -[N.add Z.add Z.mul] in *.
replace (height s2) with 1%Z in *
by (symmetry; eapply size_height_1; eassumption).
simpl Z.sub.
lia.
** destruct H2; only 1: lia.
assert (height s1 <> 0%Z)
by (destruct s1; cbn -[Z.add]; postive_heights; simpl size in *; try lia).
replace (((1 + height s2) - 1))%Z with (Z.succ (height s2 - 1)) by lia.
rewrite !Z.pow_succ_r by lia.
etransitivity; only 1: (apply Z.mul_le_mono_nonneg_l; [lia | eassumption]).
rewrite !Z.mul_assoc.
apply Z.mul_le_mono_nonneg_r; only 1: (apply Z.pow_nonneg; lia).
lia.
Qed.
Lemma Z_log2_pow2:
forall y,
(0 <= y)%Z ->
(Z.log2 (y ^ 2) <= 2 * Z.log2 y + 1)%Z.
Proof.
intros.
replace (y ^ 2)%Z with (y * y)%Z by lia.
etransitivity; only 1: (apply Z.log2_mul_above; assumption).
lia.
Qed.
Lemma Z_log2_pow3:
forall y,
(0 <= y)%Z ->
(Z.log2 (y ^ 3) <= 3 * Z.log2 y + 2)%Z.
Proof.
intros.
replace (y ^ 3)%Z with (y^2 * y)%Z by lia.
assert (0 <= y^2)%Z by (apply Z.pow_nonneg; assumption).
etransitivity; only 1: (apply Z.log2_mul_above; assumption).
enough ((Z.log2 (y^2) <= 2 * Z.log2 y + 1)%Z) by lia.
apply Z_log2_pow2.
assumption.
Qed.
(* Frustratingly, concluding this lemma from the one above took more time
than proving that. *)
Lemma Bounded_logarithmic_height : forall m lb ub,
Bounded m lb ub -> (height m <= 3 * Z.log2 (size m) + 3)%Z.
Proof.
intros ??? HB.
pose proof (Bounded_size_bound m lb ub HB).
postive_heights.
postive_sizes.
assert (size m = 0 \/ 0 < size m)%Z by lia. destruct H2.
* apply (size_0_iff_tip HB) in H2.
subst. simpl. intro Htmp. inversion Htmp.
* clear H1.
enough (height m - 1 <= 3 * Z.log2 (size m) + 2)%Z by lia.
assert (0 < height m)%Z by (induction HB; cbn -[Z.add] in *; postive_heights; try lia).
assert (0 <= height m - 1)%Z by lia.
generalize dependent (height m - 1)%Z; intros h ??.
generalize dependent (size m); intros sz ??.
clear dependent m. clear lb ub. clear dependent e.
assert (0 < 3 ^ h)%Z by (apply Z.pow_pos_nonneg; lia).
assert (0 < 4 ^ h)%Z by (apply Z.pow_pos_nonneg; lia).
assert (0 < sz ^ 3)%Z by (apply Z.pow_pos_nonneg; lia).
etransitivity; only 2: (apply Z_log2_pow3; lia).
apply Z.log2_le_pow2; only 1: assumption.
eapply Zmult_lt_0_le_reg_r. apply H0.
eapply Zmult_lt_0_le_reg_r. apply H0.
eapply Zmult_lt_0_le_reg_r. apply H0.
rewrite <- !Z.pow_mul_l.
simpl (2 * 3 * 3 * 3)%Z.
etransitivity. apply Z.pow_le_mono_l with (b := (4^3)%Z). lia.
rewrite <- Z.pow_mul_r by lia.
rewrite Z.mul_comm.
rewrite -> Z.pow_mul_r by lia.
etransitivity. apply Z.pow_le_mono_l. split. lia. eapply H.
lia.
Qed.
Lemma Bounded_change_ub:
forall s lb ub ub',
Bounded s lb (Some ub) ->
ub <= ub' = true ->
Bounded s lb (Some ub').
Proof.
intros ???? HD Heq.
remember (Some ub) as ubo.
induction HD; subst.
* apply BoundedTip; auto.
* intuition.
eapply BoundedBin; try eassumption; try reflexivity.
order_Bounds.
Qed.
Lemma Bounded_change_lb:
forall s lb lb' ub,
Bounded s (Some lb) ub ->
lb' <= lb = true ->
Bounded s (Some lb') ub.
Proof.
intros ???? HD Heq.
remember (Some lb) as lbo.
induction HD; subst.
* apply BoundedTip; reflexivity.
* intuition.
eapply BoundedBin; try eassumption; try reflexivity.
order_Bounds.
Qed.
(* Bounded_change_ub and Bounded_relax_ub could be united with
a isNonStrictUB predicate *)
Lemma Bounded_relax_ub:
forall s lb ub ub',
Bounded s lb (Some ub) ->
isUB ub' ub = true ->
Bounded s lb ub'.
Proof.
intros ???? HD Heq.
remember (Some ub) as ubo.
induction HD; subst.
* apply BoundedTip; auto.
* intuition.
eapply BoundedBin; try eassumption; try reflexivity.
order_Bounds.
Qed.
Lemma Bounded_relax_lb:
forall s lb lb' ub,
Bounded s (Some lb) ub ->
isLB lb' lb = true ->
Bounded s lb' ub.
Proof.
intros ???? HD Heq.
remember (Some lb) as lbo.
induction HD; subst.
* apply BoundedTip; reflexivity.
* intuition.
eapply BoundedBin; try eassumption; try reflexivity.
order_Bounds.
Qed.
Lemma Bounded_relax_ub_None:
forall s lb ub,
Bounded s lb ub ->
Bounded s lb None.
Proof.
intros ??? HD.
induction HD; subst.
* apply BoundedTip; reflexivity.
* eapply BoundedBin; try eassumption; try reflexivity.
Qed.
Lemma Bounded_relax_lb_None:
forall s lb ub,
Bounded s lb ub ->
Bounded s None ub.
Proof.
intros ??? HD.
induction HD; subst.
* apply BoundedTip; reflexivity.
* eapply BoundedBin; try eassumption; try reflexivity.
Qed.
(** ** Tactics for Boundedness etc. *)
(** Learns bounds of values found in some set in the context *)
Ltac inside_bounds :=
repeat lazymatch goal with
| H : Bounded ?s _ _, H2 : sem ?s ?i = Some _ |- _ =>
apply (sem_inside H) in H2; destruct H2
| H : Bounded ?s _ _, H2 : isSome (sem ?s ?i) = true |- _ =>
apply (sem_inside_isSome H) in H2; destruct H2
end.
(** Solve [isLB] and [isUB] goals. *)
Ltac solve_Bounds := first
[ eassumption
| solve [inside_bounds; order_Bounds]
| idtac "solve_Bounds gave up"
].
(* Solve equations of the form
forall i, f i = f0 i || f1 i
possibly using equations from the context.
Fails if it does not start with [forall i,], but may leave a partially solve goal.
*)
Ltac f_solver_simple :=
let i := fresh "i" in
intro i;
try reflexivity; (* for when we have an existential variable *)
repeat multimatch goal with [ H : (forall i, _) |- _] => specialize (H i) end;
repeat match goal with [ H : ?f = _ |- context [?f i] ] => rewrite H in *; clear H end;
simpl sem in *; simpl_options;
try reflexivity.
(** This auxillary tactic destructs one boolean or option atom in the argument *)
Ltac split_bool_go expr :=
lazymatch expr with
| true => fail
| false => fail
| Some _ => fail
| None => fail
| match ?x with _ => _ end => split_bool_go x || (simpl x; cbv match)
| negb ?x => split_bool_go x
| ?x && ?y => split_bool_go x || split_bool_go y
| ?x || ?y => split_bool_go x || split_bool_go y
| xorb ?x ?y => split_bool_go x || split_bool_go y
| ?x ||| ?y => split_bool_go x || split_bool_go y
| ?x &&& ?y => split_bool_go x || split_bool_go y
| diffo ?x ?y => split_bool_go y || split_bool_go x
| SomeIf ?b ?x => split_bool_go b
| ?bexpr => destruct bexpr eqn:?
end.
(** This auxillary tactic destructs one boolean or option atom in the goal *)
Ltac split_bool :=
match goal with
| |- ?lhs = ?rhs => split_bool_go lhs || split_bool_go rhs
(* A bit ad-hoc, could be improved: *)
| H : ?x ||| ?y = Some _ |- _ => split_bool_go x
| H : ?x ||| ?y = None |- _ => split_bool_go x
| H : context [?x &&& ?y] |- _ => split_bool_go y
| H : context [?x &&& ?y] |- _ => split_bool_go y
| H : diffo ?x ?y = Some _ |- _ => split_bool_go y
| H : diffo ?x ?y = None |- _ => split_bool_go y
| H : ?x || ?y = true |- _ => split_bool_go x
| H : ?x || ?y = false |- _ => split_bool_go x
| H : ?x && ?y = true |- _ => split_bool_go x
| H : ?x && ?y = false |- _ => split_bool_go x
end.
Ltac f_solver_cleanup :=
simpl negb in *;
simpl_options;
try congruence;
repeat lazymatch goal with
| H1 : true = true |- _ => clear H1
| H1 : true = _ |- _ => symmetry in H1
| H1 : false = false |- _ => clear H1
| H1 : false = _ |- _ => symmetry in H1
| H1 : Some _ = Some _ |- _ => inversion H1; subst; clear H1
| H1 : Some _ = _ |- _ => symmetry in H1
| H1 : None = None |- _ => clear H1
| H1 : None = _ |- _ => symmetry in H1
end;
(* Find equalities *)
repeat lazymatch goal with
| H1 : (?i == ?j) = true , H2 : sem ?s ?i = Some ?a, H3 : sem ?s ?j = Some ?b |- _
=> rewrite (sem_resp_eq s i j H1) in H2; rewrite H2 in H3; inversion H3; subst; clear H3
end;
(* Try to solve it *)
try solve [exfalso; inside_bounds; order_Bounds];
try reflexivity;
(* Find conradiction *)
try lazymatch goal with
| H1 : (?i == ?j) = true , H2 : sem ?s ?i = Some _, H3 : sem ?s ?j = None |- _
=> exfalso; rewrite (sem_resp_eq s i j H1) in H2; congruence
| H1 : (?i == ?j) = true , H2 : isSome (sem ?s ?i) = true, H3 : sem ?s ?j = None |- _
=> exfalso; rewrite <- (sem_resp_eq s i j H1) in H3; rewrite H3 in H2; simpl in H2; congruence
| H1 : (?i == ?j) = true , H2 : isSome (sem ?s ?i) = false, H3 : sem ?s ?j = Some _ |- _
=> exfalso; rewrite <- (sem_resp_eq s i j H1) in H3; rewrite H3 in H2; simpl in H2; congruence
| H1 : (?i == ?j) = true , H2 : sem ?s ?i = None, H3 : sem ?s ?j = Some _ |- _
=> exfalso; rewrite (sem_resp_eq s i j H1) in H2; congruence
| H1 : (?i == ?j) = true , H2 : sem ?s ?i = None, H3 : isSome (sem ?s ?j) = true |- _
=> exfalso; rewrite (sem_resp_eq s i j H1) in H2; rewrite H2 in H3; simpl in H3; congruence
| H1 : (?i == ?j) = true , H2 : sem ?s ?i = Some _, H3 : isSome (sem ?s ?j) = false |- _
=> exfalso; rewrite (sem_resp_eq s i j H1) in H2; rewrite H2 in H3; simpl in H3; congruence
end.
Ltac f_solver_step := first
[ split_bool
| lazymatch goal with H : context [if ?x == ?y then _ else _] |- _
=> destruct (x == y) eqn:?
end
(* | exfalso *)
].
Ltac f_solver := f_solver_simple; f_solver_cleanup; repeat (f_solver_step; f_solver_cleanup).
(** A variant of [lia] that unfolds a few specific things and knows that
the size of a well-formed tree is positive. *)
Ltac lia_sizes :=
postive_sizes;
unfold balance_prop_inserted, balance_prop, delta, ratio in *;
unfold fromInteger, op_zg__, op_zl__, op_zt__, op_zp__,
Num_Integer__, Ord_Integer___,
op_zg____, op_zl____ in *;
rewrite ?size_size in *;
rewrite ?size_Bin in *; simpl (size Tip) in *;
lia.
(** A tactic to solve questions about size. *)
Ltac solve_size := first
[ assumption
| reflexivity
| lia_sizes
| idtac "solve_size gave up"
].
(** Solve goals of Bounded. Should be back-tracking free, I think. *)
Ltac solve_Bounded := eassumption || lazymatch goal with
| [ |- Bounded Tip _ _ ]
=> apply BoundedTip
| [ H : Bounded ?s ?lb (Some ?ub) |- Bounded ?s ?lb (Some ?ub') ]
=> apply (Bounded_change_ub _ _ _ _ H); solve_Bounds
| [ H : Bounded ?s (Some ?lb) ?ub |- Bounded ?s (Some ?lb') ?ub ]
=> apply (Bounded_change_lb _ _ _ _ H); solve_Bounds
| [ H : Bounded ?s ?lb (Some ?ub) |- Bounded ?s ?lb ?ub' ]
=> apply (Bounded_relax_ub _ _ _ _ H); solve_Bounds
| [ H : Bounded ?s (Some ?lb) ?ub |- Bounded ?s ?lb' ?ub ]
=> apply (Bounded_relax_lb _ _ _ _ H); solve_Bounds
| [ |- Bounded (Bin _ _ _ _ _) _ _ ]
=> apply BoundedBin;
[ solve_Bounded
| solve_Bounded
| solve_Bounds
| solve_Bounds
| solve_size
| solve_size
]
| |- ?H => fail "solve_Bounded gave up on" H
end.
(** We now have special tactics for the three kinds of preconditions most
our lemmas below have. So we can write a tactic that correctly chooses the
right tactic.
Why not simply use [first [solve_Bounded|solve_Bounds|solve_size]]?
Because that would involve backtracking which hides error messages from us,
and is possibly too slow.
*)
Ltac solve_Precondition := lazymatch goal with
| |- Bounded _ _ _ => solve_Bounded
| |- isLB _ _ = true => solve_Bounds
| |- isUB _ _ = true => solve_Bounds
| |- context [map_size] => simpl; lia (* in well-founded recursion *)
| |- _ = _ => solve_size
| |- context [balance_prop] => solve_size
| |- ?H => fail "solve_Precondition does not recognize this goal: " H
end.
(** ** A setup for complete specification *)
(** A proposition of the form [Desc s lb ub sz f] tells us
everything we need to know about [s].
Therefore, it is phrased as an induction lemma which replaces
the concrete Set (e.g. [insert y s]) with a fresh variable [s'],
and adds all interesting bits about it to the context.
To prove a [Desc] statement, use [apply showDesc].
To use a [Desc] statement, use [applyDesc HD] or [apply foo_Desc].
*)
Definition Desc s lb ub sz f : Prop :=
forall (P : Map e a -> Prop),
(forall s,
Bounded s lb ub ->
size s = sz ->
(forall i, sem s i = f i) ->
P s) ->
P s.
Local Inductive HIDE (P : Prop) := unhide : P -> HIDE P.
Local Lemma hide : forall {P : Prop}, HIDE P -> P. Proof. intros. inversion H. assumption. Qed.
Ltac applyDesc lem :=
apply hide;
eapply lem;
[ solve_Precondition ..
| let s := fresh "s" in
let HB := fresh "HB" in
let Hsz := fresh "Hsz" in
let Hsem := fresh "Hsem" in
intros s HB Hsz Hsem;
apply unhide;
try replace (size s) in *;
try replace (sem s) in *;
try assumption
].
Lemma showDesc :
forall s lb ub sz f,
Bounded s lb ub /\ size s = sz /\ (forall i, sem s i = f i) ->
Desc s lb ub sz f.
Proof.
intros. intros P HP. apply HP; intuition.
Qed.
Lemma Desc_change_f:
forall s lb ub sz f f',
(forall i, f' i = f i) ->
Desc s lb ub sz f' <-> Desc s lb ub sz f.
Proof.
intros.
split; intro HD; applyDesc HD;
(apply showDesc; split; [solve_Bounded | split; [solve_size | simpl sem; try solve [f_solver]]]);
intuition.
Qed.
(** A variant that does not indicate anything about [size]. *)
Definition Desc' s lb ub f : Prop :=
forall (P : Map e a -> Prop),
(forall s,
Bounded s lb ub ->
True -> (* So that we can still use [applyDesc] here *)
(forall i, sem s i = f i) ->
P s) ->
P s.
Lemma showDesc' :
forall s lb ub f,
Bounded s lb ub /\ (forall i, sem s i = f i) ->
Desc' s lb ub f.
Proof.
intros. intros P HP. apply HP; intuition.
Qed.
Ltac solve_Desc :=
lazymatch goal with
| |- (Desc _ _ _ _ _)
=> apply showDesc; split; [solve_Bounded | split; [solve_size | simpl sem; try solve [f_solver]]]
| |- (Desc' _ _ _ _)
=> apply showDesc'; split; [solve_Bounded | simpl sem; try solve [f_solver]]
| |- ?P
=> fail "solve_Desc: Goal not a Desc or Desc' proposition: " P
end.
(** ** The actual [WF] predicate *)
(** And any set that has a bounds is well-formed *)
Definition WF (s : Map e a) : Prop := Bounded s None None.
Lemma Desc_WF:
forall s sz f,
Desc s None None sz f -> WF s.
Proof.
intros ??? HD.
unfold WF.
(* Unfortunately, [apply HD] does not work unless we have [size s] and [sem s]
in the context. *)
assert (Bounded s None None /\ size s = size s /\ sem s = sem s) by (apply HD; auto).
intuition.
Qed.
Lemma Desc_WF':
forall m sz f lb ub,
Desc m lb ub sz f -> WF m.
Proof.
intros m sz f lb ub HD.
unfold WF.
(* Unfortunately, [apply HD] does not work unless we have [size s] and [sem s]
in the context. *)
assert (Bounded m lb ub /\ size m = size m /\ sem m = sem m) by (apply HD; auto).
intuition.
destruct ub; destruct lb.
- eapply Bounded_relax_lb; eauto;
eapply Bounded_relax_ub; eauto.
- eapply Bounded_relax_ub; eauto.
- eapply Bounded_relax_lb; eauto.
- auto.
Qed.
(** For every set in the context, try to see if [lia] knows it is empty. *)
Ltac find_Tip :=
match goal with [ H : Bounded ?s _ _ |- _ ] =>
assert_new (size s = 0)%Z lia_sizes;
rewrite (size_0_iff_tip H) in *;
subst s;
inversion H;
clear H;
subst
end.
Require Import Coq.Program.Tactics.
Open Scope Z_scope.
(** ** Verification of [empty] *)
Lemma empty_Desc:
forall lb ub,
Desc empty lb ub 0 (fun _ => None).
Proof. intros. unfold empty. solve_Desc. Qed.
Lemma empty_WF: WF empty.
Proof. intros. unfold empty. eapply Desc_WF. apply empty_Desc. Qed.
(** ** Verification of [null] *)
Lemma null_spec:
forall s, WF s -> null s = true <-> s = Tip.
Proof. intros. unfold null. inversion H; simpl; intuition (congruence || lia_sizes). Qed.
(** ** Verification of [singleton] *)
Lemma singleton_Desc:
forall x (v : a) lb ub,
isLB lb x = true ->
isUB ub x = true ->
Desc (singleton x v) lb ub 1 (fun i => SomeIf (i == x) v).
Proof.
intros.
unfold singleton.
unfold fromInteger, Num_Integer__.
solve_Desc.
Qed.
Lemma singleton_WF:
forall x v, WF (singleton x v).
Proof. intros. eapply Desc_WF. eapply singleton_Desc; reflexivity. Qed.
(** ** Verifying the various balancing operations *)
(** *** Verification of [balanceL] *)
Lemma balanceL_Desc:
forall x v s1 s2 lb ub,
Bounded s1 lb (Some x) ->
Bounded s2 (Some x) ub ->
isLB lb x = true ->
isUB ub x = true->
balance_prop (size s1) (size s2) \/
balance_prop_inserted (size s1 - 1) (size s2) /\ (1 <= size s1)%Z \/
balance_prop (size s1) (size s2 + 1) ->
Desc (balanceL x v s1 s2) lb ub (1 + size s1 + size s2) (fun i => sem s1 i ||| SomeIf (i == x) v ||| sem s2 i).
Proof.
intros.
unfold balanceL.
unfold op_zg__, op_zl__, Ord_Integer___, op_zg____, op_zl____.
repeat lazymatch goal with [ H : Bounded ?s _ _ |- context [match ?s with _ => _ end] ] => inversion H; subst; clear H end;
repeat lazymatch goal with [ |- context [if (?x <? ?y)%Z then _ else _] ] => destruct (Z.ltb_spec x y) end;
rewrite ?size_Bin in *; simpl (size Tip) in *; simpl sem;
simpl isLB in *;
simpl isUB in *.
all: try solve [exfalso; lia_sizes]. (* Some are simply impossible *)
all: repeat find_Tip.
all: try solve [solve_Desc].
Qed.
Lemma balanceL_noop :
forall x y s1 s2 lb ub,
Bounded s1 lb (Some x) ->
Bounded s2 (Some x) ub ->
isLB lb x = true ->
isUB ub x = true->
balance_prop (size s1) (size s2) ->
balanceL x y s1 s2 = Bin (1 + size s1 + size s2) x y s1 s2.
Proof.
intros.
unfold balanceL.
unfold op_zg__, op_zl__, Ord_Integer___, op_zg____, op_zl____.
repeat lazymatch goal with [ H : Bounded ?s _ _ |- context [match ?s with _ => _ end] ] => inversion H; subst; clear H end;
repeat lazymatch goal with [ |- context [if (?x <? ?y)%Z then _ else _] ] => destruct (Z.ltb_spec x y) end;
rewrite ?size_Bin in *; simpl (size Tip) in *; simpl sem;
simpl isLB in *;
simpl isUB in *.
all: try solve [exfalso; lia_sizes]. (* Some are simply impossible *)
all: repeat find_Tip.
all: try reflexivity.
Qed.
(** *** Verification of [balanceR] *)
Lemma balanceR_Desc:
forall x v s1 s2 lb ub,
Bounded s1 lb (Some x) ->
Bounded s2 (Some x) ub ->
isLB lb x = true ->
isUB ub x = true->
balance_prop (size s1) (size s2) \/
balance_prop_inserted (size s2 - 1) (size s1) /\ (1 <= size s2)%Z \/
balance_prop (size s1 + 1) (size s2) ->
Desc (balanceR x v s1 s2) lb ub (1 + size s1 + size s2) (fun i => sem s1 i ||| SomeIf (i == x) v ||| sem s2 i).
Proof.
intros.
unfold balanceR.
unfold op_zg__, op_zl__, Ord_Integer___, op_zg____, op_zl____.
repeat lazymatch goal with [ H : Bounded ?s _ _ |- context [match ?s with _ => _ end] ] => inversion H; subst; clear H end;
repeat lazymatch goal with [ |- context [if (?x <? ?y)%Z then _ else _] ] => destruct (Z.ltb_spec x y) end;
rewrite ?size_Bin in *; simpl (size Tip) in *; simpl sem;
simpl isLB in *;
simpl isUB in *.
all: try solve [exfalso; lia_sizes]. (* Some are simply impossible *)
all: repeat find_Tip.
all: try solve [solve_Desc].
Qed.
Lemma balanceR_noop :
forall x y s1 s2 lb ub,
Bounded s1 lb (Some x) ->
Bounded s2 (Some x) ub ->
isLB lb x = true ->
isUB ub x = true->
balance_prop (size s1) (size s2) ->
balanceR x y s1 s2 = Bin (1 + size s1 + size s2) x y s1 s2.
Proof.
intros.
unfold balanceR.
unfold op_zg__, op_zl__, Ord_Integer___, op_zg____, op_zl____.
repeat lazymatch goal with [ H : Bounded ?s _ _ |- context [match ?s with _ => _ end] ] => inversion H; subst; clear H end;
repeat lazymatch goal with [ |- context [if (?x <? ?y)%Z then _ else _] ] => destruct (Z.ltb_spec x y) end;
rewrite ?size_Bin in *; simpl (size Tip) in *; simpl sem;
simpl isLB in *;
simpl isUB in *.
all: try solve [exfalso; lia_sizes]. (* Some are simply impossible *)
all: repeat find_Tip.
all: try reflexivity.
Qed.
(** ** Verification of [balance] *)
Lemma balance_Desc:
forall x v s1 s2 lb ub,
Bounded s1 lb (Some x) ->
Bounded s2 (Some x) ub ->
isLB lb x = true ->
isUB ub x = true ->
balance_prop (size s1) (size s2) \/
balance_prop_inserted (size s2 - 1) (size s1) /\ (1 <= size s2)%Z \/
balance_prop (size s1 + 1) (size s2) \/
balance_prop_inserted (size s1 - 1) (size s2) /\ (1 <= size s1)%Z \/
balance_prop (size s1) (size s2 + 1) ->
Desc (balance x v s1 s2) lb ub (1 + size s1 + size s2) (fun i => sem s1 i ||| SomeIf (i == x) v ||| sem s2 i).
Proof.
intros. unfold balance.
unfold op_zg__, op_zl__, Ord_Integer___, op_zg____, op_zl____.
repeat lazymatch goal with [ H : Bounded ?s _ _ |- context [match ?s with _ => _ end] ] => inversion H; subst; clear H end;
repeat lazymatch goal with [ |- context [if (?x <? ?y)%Z then _ else _] ] => destruct (Z.ltb_spec x y) end;
rewrite ?size_Bin in *; simpl (size Tip) in *; simpl sem;
simpl isLB in *;
simpl isUB in *.
all: try solve [exfalso; lia_sizes]. (* Some are simply impossible *)
all: repeat find_Tip.
all: try solve [solve_Desc].
Qed.
Lemma balance_noop :
forall x y s1 s2 lb ub,
Bounded s1 lb (Some x) ->
Bounded s2 (Some x) ub ->
isLB lb x = true ->
isUB ub x = true->
balance_prop (size s1) (size s2) ->
balance x y s1 s2 = Bin (1 + size s1 + size s2) x y s1 s2.
Proof.
intros.
unfold balance.
unfold op_zg__, op_zl__, Ord_Integer___, op_zg____, op_zl____.
repeat lazymatch goal with [ H : Bounded ?s _ _ |- context [match ?s with _ => _ end] ] => inversion H; subst; clear H end;
repeat lazymatch goal with [ |- context [if (?x <? ?y)%Z then _ else _] ] => destruct (Z.ltb_spec x y) end;
rewrite ?size_Bin in *; simpl (size Tip) in *; simpl sem;
simpl isLB in *;
simpl isUB in *.
all: try solve [exfalso; lia_sizes]. (* Some are simply impossible *)
all: repeat find_Tip.
all: try reflexivity.
Qed.
(** *** Verification of [link] *)
Lemma link_eq (x : e) (v : a) (s1: Map e a) (s2: Map e a) :
link x v s1 s2 =
match s1, s2 with
| Tip , r => insertMin x v r
| l , Tip => insertMax x v l
| (Bin sizeL y vy ly ry as l) , (Bin sizeR z vz lz rz as r) =>
if Sumbool.sumbool_of_bool ((delta GHC.Num.* sizeL) GHC.Base.< sizeR)
then balanceL z vz (link x v l lz) rz
else if Sumbool.sumbool_of_bool ((delta GHC.Num.* sizeR) GHC.Base.< sizeL)
then balanceR y vy ly (link x v ry r)
else bin x v l r
end.
Proof.
destruct s1; [|reflexivity].
destruct s2; [|reflexivity].
unfold link at 1, link_func at 1.
lazymatch goal with
|- Wf.Fix_sub ?A ?R ?Rwf ?P ?F_sub ?x = ?rhs =>
apply (@Wf.WfExtensionality.fix_sub_eq_ext A R Rwf P F_sub x)
end.
Qed.
(** *** Verification of [insertMax] *)
Lemma insertMax_Desc:
forall x v s1 lb ub,
Bounded s1 lb (Some x) ->
isLB lb x = true ->
isUB ub x = true->
Desc (insertMax x v s1) lb ub (1 + size s1) (fun i => sem s1 i ||| SomeIf (i == x) v).
Proof.
intros.
remember (Some x) as ub'. revert dependent x.
induction H; intros; subst; cbn - [Z.add SomeIf].
* applyDesc singleton_Desc.
solve_Desc.
* clear IHBounded1.
applyDesc IHBounded2.
applyDesc balanceR_Desc.
solve_Desc.
Qed.
(** *** Verification of [insertMin] *)
Lemma insertMin_Desc:
forall x v s2 lb ub,
Bounded s2 (Some x) ub ->
isLB lb x = true ->
isUB ub x = true->
Desc (insertMin x v s2) lb ub (1 + size s2) (fun i => SomeIf (i == x) v ||| sem s2 i).
Proof.
intros.
remember (Some x) as ub'. revert dependent x.
induction H; intros; subst; cbn - [Z.add].
* applyDesc singleton_Desc.
solve_Desc.
* clear IHBounded2.
applyDesc IHBounded1.
applyDesc balanceL_Desc.
solve_Desc.
Qed.
(* [program_simpl] calls [simpl], which is very confusing due to [1 + _]. So
ask [Next Obligation] to use this only when it solves the goal completely. *)
Local Obligation Tactic := try solve [program_simpl].
Program Fixpoint link_Desc (x : e) (v : a) (s1: Map e a) (s2: Map e a)
{measure (map_size s1 + map_size s2)} :
forall lb ub,
Bounded s1 lb (Some x) ->
Bounded s2 (Some x) ub ->
isLB lb x = true ->
isUB ub x = true->
Desc (link x v s1 s2) lb ub (1 + size s1 + size s2)
(fun i => sem s1 i ||| SomeIf (i == x) v ||| sem s2 i)
:= _.
Next Obligation.
intros.
rewrite link_eq.
inversion H; subst; clear H;
inversion H0; subst; clear H0.
* simpl insertMin.
applyDesc singleton_Desc.
solve_Desc.
* applyDesc insertMin_Desc.
solve_Desc.
* applyDesc insertMax_Desc.
solve_Desc.
* destruct (Sumbool.sumbool_of_bool _);
only 2: destruct (Sumbool.sumbool_of_bool _);
rewrite ?Z.ltb_lt, ?Z.ltb_ge in *.
- applyDesc link_Desc.
applyDesc balanceL_Desc.
solve_Desc.
- applyDesc link_Desc.
applyDesc balanceR_Desc.
solve_Desc.
- clear link_Desc.
unfold bin.
solve_Desc.
Qed.
End WF. |
/-
Copyright (c) 2017 Microsoft Corporation. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Author: Leonardo de Moura
-/
prelude
import init.data.nat init.data.fin.basic
namespace fin
open nat
variable {n : nat}
protected def succ : fin n → fin (succ n)
| ⟨a, h⟩ := ⟨nat.succ a, succ_lt_succ h⟩
def of_nat {n : nat} (a : nat) : fin (succ n) :=
⟨a % succ n, nat.mod_lt _ (nat.zero_lt_succ _)⟩
private lemma mlt {n b : nat} : ∀ {a}, n > a → b % n < n
| 0 h := nat.mod_lt _ h
| (a+1) h :=
have n > 0, from lt_trans (nat.zero_lt_succ _) h,
nat.mod_lt _ this
protected def add : fin n → fin n → fin n
| ⟨a, h⟩ ⟨b, _⟩ := ⟨(a + b) % n, mlt h⟩
protected def mul : fin n → fin n → fin n
| ⟨a, h⟩ ⟨b, _⟩ := ⟨(a * b) % n, mlt h⟩
private lemma sublt {a b n : nat} (h : a < n) : a - b < n :=
lt_of_le_of_lt (nat.sub_le a b) h
protected def sub : fin n → fin n → fin n
| ⟨a, h⟩ ⟨b, _⟩ := ⟨(a + (n - b)) % n, mlt h⟩
private lemma modlt {a b n : nat} (h₁ : a < n) (h₂ : b < n) : a % b < n :=
begin
cases b with b,
{simp [mod_zero], assumption},
{have h : a % (succ b) < succ b,
apply nat.mod_lt _ (nat.zero_lt_succ _),
exact lt_trans h h₂}
end
protected def mod : fin n → fin n → fin n
| ⟨a, h₁⟩ ⟨b, h₂⟩ := ⟨a % b, modlt h₁ h₂⟩
private lemma divlt {a b n : nat} (h : a < n) : a / b < n :=
lt_of_le_of_lt (nat.div_le_self a b) h
protected def div : fin n → fin n → fin n
| ⟨a, h⟩ ⟨b, _⟩ := ⟨a / b, divlt h⟩
instance : has_zero (fin (succ n)) := ⟨⟨0, succ_pos n⟩⟩
instance : has_one (fin (succ n)) := ⟨of_nat 1⟩
instance : has_add (fin n) := ⟨fin.add⟩
instance : has_sub (fin n) := ⟨fin.sub⟩
instance : has_mul (fin n) := ⟨fin.mul⟩
instance : has_mod (fin n) := ⟨fin.mod⟩
instance : has_div (fin n) := ⟨fin.div⟩
lemma of_nat_zero : @of_nat n 0 = 0 := rfl
lemma add_def (a b : fin n) : (a + b).val = (a.val + b.val) % n :=
show (fin.add a b).val = (a.val + b.val) % n, from
by cases a; cases b; simp [fin.add]
lemma mul_def (a b : fin n) : (a * b).val = (a.val * b.val) % n :=
show (fin.mul a b).val = (a.val * b.val) % n, from
by cases a; cases b; simp [fin.mul]
lemma sub_def (a b : fin n) : (a - b).val = (a.val + (n - b.val)) % n :=
by cases a; cases b; refl
lemma mod_def (a b : fin n) : (a % b).val = a.val % b.val :=
show (fin.mod a b).val = a.val % b.val, from
by cases a; cases b; simp [fin.mod]
lemma div_def (a b : fin n) : (a / b).val = a.val / b.val :=
show (fin.div a b).val = a.val / b.val, from
by cases a; cases b; simp [fin.div]
lemma lt_def (a b : fin n) : (a < b) = (a.val < b.val) :=
show (fin.lt a b) = (a.val < b.val), from
by cases a; cases b; simp [fin.lt]
lemma le_def (a b : fin n) : (a ≤ b) = (a.val ≤ b.val) :=
show (fin.le a b) = (a.val ≤ b.val), from
by cases a; cases b; simp [fin.le]
lemma val_zero : (0 : fin (succ n)).val = 0 := rfl
def pred {n : nat} : ∀ i : fin (succ n), i ≠ 0 → fin n
| ⟨a, h₁⟩ h₂ := ⟨a.pred,
begin
have this : a ≠ 0,
{ have aux₁ := vne_of_ne h₂,
dsimp at aux₁, rw val_zero at aux₁, exact aux₁ },
exact nat.pred_lt_pred this h₁
end⟩
end fin
|
module bug where
data True : Set where
tt : True
data Sigma (x : True) : Set where
pair : True -> Sigma x
postulate
p : True
T : True -> Sigma p -> Set
T tt (pair _) = True
postulate
S : True -> Sigma p -> Set
z : Sigma p
z = pair p
postulate
build : (q : Sigma p) -> T p q -> True
pz : T p z
|
SUBROUTINE GOVER(NI,NJ,XI,XJ,R,SG)
************************************************************************
* *
* GOVER CALCULATES THE OVERLAP INTEGRALS USING A GAUSSIAN EXPANSION *
* STO-6G BY R.F. STEWART, J. CHEM. PHYS., 52 431-438, 1970 *
* *
* ON INPUT NI = ATOMIC NUMBER OF FIRST ATOM *
* NJ = ATOMIC NUMBER OF SECOND ATOM *
* R = INTERATOMIC DISTANCE IN ANGSTROMS *
* ON EXIT S = 9X9 ARRAY OF OVERLAPS, IN ORDER S,PX,PY, *
* PZ *
* *
************************************************************************
IMPLICIT DOUBLE PRECISION (A-H,O-Z)
INCLUDE 'SIZES'
COMMON /NATYPE/ NZTYPE(107), MTYPE(10),LTYPE
COMMON /TEMP/ C(60,6), Z(60,6)
COMMON /NATORB/ NATORB(107)
DIMENSION S(6,6), XI(3),XJ(3), SG(9,9)
DATA NGAUSS/6/
C
C FIND START AND END OF GAUSSIAN
C
IFA=NZTYPE(NI)*4-3
IF(C(IFA+1,1).NE.0.D0)THEN
ILA=IFA+3
ELSE
ILA=IFA
ENDIF
IFB=NZTYPE(NJ)*4-3
IF(C(IFB+1,1).NE.0.D0)THEN
ILB=IFB+3
ELSE
ILB=IFB
ENDIF
C
C CONVERT R INTO AU
C
R=R/0.529167D0
R = R**2
KA=0
DO 80 I=IFA,ILA
KA=KA+1
NAT=KA-1
KB=0
DO 80 J=IFB,ILB
KB=KB+1
NBT=KB-1
C
C DECIDE IS IT AN S-S, S-P, P-S, OR P-P OVERLAP
C
IF(NAT.GT.0.AND.NBT.GT.0) THEN
C P-P
IS=4
TOMB=(XI(NAT)-XJ(NAT))*(XI(NBT)
1-XJ(NBT))*3.5711928576D0
ELSEIF(NAT.GT.0) THEN
C P-S
IS=3
TOMB=(XI(NAT)-XJ(NAT))*1.88976D0
ELSEIF(NBT.GT.0) THEN
C S-P
IS=2
TOMB=(XI(NBT)-XJ(NBT))*1.88976D0
ELSE
C S-S
IS=1
ENDIF
DO 60 K=1,NGAUSS
DO 60 L=1,NGAUSS
S(K,L)=0.0D0
AMB=Z(I,K)+Z(J,L)
APB=Z(I,K)*Z(J,L)
ADB=APB/AMB
C
C CHECK OF OVERLAP IS NON-ZERO BEFORE STARTING
C
IF((ADB*R).LT.90.D0) THEN
ABN=1.0D0
GO TO(50,10,20,30),IS
10 ABN=2.*TOMB*Z(I,K)*SQRT(Z(J,L))/AMB
GO TO 50
20 ABN=-2.*TOMB*Z(J,L)*SQRT(Z(I,K))/AMB
GO TO 50
30 ABN=-ADB*TOMB
IF(NAT.EQ.NBT) ABN=ABN+0.5D0
40 ABN=4.0D0*ABN*SQRT(APB)/AMB
50 S(K,L)=SQRT((2.*SQRT(APB)/AMB)**3)*EXP(-ADB*R)*ABN
ENDIF
60 CONTINUE
SG(KA,KB)=0.0D0
DO 70 K=1,NGAUSS
DO 70 L=1,NGAUSS
70 SG(KA,KB)=SG(KA,KB)+S(K,L)*C(I,K)*C(J,L)
80 CONTINUE
RETURN
END
|
% !TeX root = ../../python-snippets.tex
\section{Bytecode}
This section contains snippets for investigating Pythons bytecode.
\subsection{Disassemble Bytecode - String Conversion}
Ever wanted to know what a string conversion using f-strings or \lstinline{str()} looks like in bytecode?
The following snippet shows you exactly that!
\lstinputlisting[caption=disassemble\_bytecode.py]{../standard_lib/disassemble_bytecode.py}
For displaying the bytecode of a function the builtin \lstinline{dis} module is used.
\begin{lstlisting}[caption=Output of disassemble\_bytecode.py]
$ python disassemble_bytecode.py
============================== f-strings ==============================
5 0 LOAD_FAST 0 (number)
2 FORMAT_VALUE 0
4 RETURN_VALUE
================================ str() ================================
9 0 LOAD_GLOBAL 0 (str)
2 LOAD_FAST 0 (number)
4 CALL_FUNCTION 1
6 RETURN_VALUE
\end{lstlisting}
\subsection{Human Readable Bytecode}
If you are using Pythons \lstinline{dis} module to get some insights into what's happening behind the scenes, you may like this recipe as it provides a way to print the output in a much more human readable way.
\lstinputlisting[caption=human\_readable\_bytecode.py]{../standard_lib/human_readable_bytecode.py}
\begin{lstlisting}[caption=Output of human\_readable\_bytecode.py]
$ python human_readable_bytecode.py
LOAD_CONST: 0
RETURN_VALUE: 0
\end{lstlisting}
\textbf{Note:} Even though we didn't put a return statement at the end of \lstinline{foo}, Python added it.
That's because every function in Python needs a return statement (specified by the underlying protocols).
|
[STATEMENT]
lemma iso_categoryE[elim]:
assumes "\<AA> \<approx>\<^sub>C\<^bsub>\<alpha>\<^esub> \<BB>"
obtains \<FF> where "\<FF> : \<AA> \<mapsto>\<mapsto>\<^sub>C\<^sub>.\<^sub>i\<^sub>s\<^sub>o\<^bsub>\<alpha>\<^esub> \<BB>"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. (\<And>\<FF>. \<FF> : \<AA> \<mapsto>\<mapsto>\<^sub>C\<^sub>.\<^sub>i\<^sub>s\<^sub>o\<^bsub>\<alpha>\<^esub> \<BB> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
\<AA> \<approx>\<^sub>C\<^bsub>\<alpha>\<^esub> \<BB>
goal (1 subgoal):
1. (\<And>\<FF>. \<FF> : \<AA> \<mapsto>\<mapsto>\<^sub>C\<^sub>.\<^sub>i\<^sub>s\<^sub>o\<^bsub>\<alpha>\<^esub> \<BB> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by auto |
[STATEMENT]
lemma OclAdd\<^sub>I\<^sub>n\<^sub>t\<^sub>e\<^sub>g\<^sub>e\<^sub>r_zero2[simp,code_unfold] :
"(\<zero> +\<^sub>i\<^sub>n\<^sub>t x) = (if \<upsilon> x and not (\<delta> x) then invalid else x endif)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. (\<zero> +\<^sub>i\<^sub>n\<^sub>t x) = (if \<upsilon> x and not (\<delta> x) then invalid else x endif)
[PROOF STEP]
by(subst OclAdd\<^sub>I\<^sub>n\<^sub>t\<^sub>e\<^sub>g\<^sub>e\<^sub>r_commute, simp) |
(* Title: HOL/Auth/n_german_lemma_on_inv__44.thy
Author: Yongjian Li and Kaiqiang Duan, State Key Lab of Computer Science, Institute of Software, Chinese Academy of Sciences
Copyright 2016 State Key Lab of Computer Science, Institute of Software, Chinese Academy of Sciences
*)
header{*The n_german Protocol Case Study*}
theory n_german_lemma_on_inv__44 imports n_german_base
begin
section{*All lemmas on causal relation between inv__44 and some rule r*}
lemma n_SendInvEVsinv__44:
assumes a1: "(\<exists> i. i\<le>N\<and>r=n_SendInvE i)" and
a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain i where a1:"i\<le>N\<and>r=n_SendInvE i" apply fastforce done
from a2 obtain p__Inv3 p__Inv4 where a2:"p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4" apply fastforce done
have "(i=p__Inv4)\<or>(i=p__Inv3)\<or>(i~=p__Inv3\<and>i~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(i=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(i=p__Inv3)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(i~=p__Inv3\<and>i~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_SendInvSVsinv__44:
assumes a1: "(\<exists> i. i\<le>N\<and>r=n_SendInvS i)" and
a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain i where a1:"i\<le>N\<and>r=n_SendInvS i" apply fastforce done
from a2 obtain p__Inv3 p__Inv4 where a2:"p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4" apply fastforce done
have "(i=p__Inv4)\<or>(i=p__Inv3)\<or>(i~=p__Inv3\<and>i~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(i=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(i=p__Inv3)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(i~=p__Inv3\<and>i~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_SendInvAckVsinv__44:
assumes a1: "(\<exists> i. i\<le>N\<and>r=n_SendInvAck i)" and
a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain i where a1:"i\<le>N\<and>r=n_SendInvAck i" apply fastforce done
from a2 obtain p__Inv3 p__Inv4 where a2:"p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4" apply fastforce done
have "(i=p__Inv4)\<or>(i=p__Inv3)\<or>(i~=p__Inv3\<and>i~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(i=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(i=p__Inv3)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(i~=p__Inv3\<and>i~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_RecvInvAckVsinv__44:
assumes a1: "(\<exists> i. i\<le>N\<and>r=n_RecvInvAck i)" and
a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain i where a1:"i\<le>N\<and>r=n_RecvInvAck i" apply fastforce done
from a2 obtain p__Inv3 p__Inv4 where a2:"p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4" apply fastforce done
have "(i=p__Inv4)\<or>(i=p__Inv3)\<or>(i~=p__Inv3\<and>i~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(i=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(i=p__Inv3)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(i~=p__Inv3\<and>i~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_SendGntSVsinv__44:
assumes a1: "(\<exists> i. i\<le>N\<and>r=n_SendGntS i)" and
a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain i where a1:"i\<le>N\<and>r=n_SendGntS i" apply fastforce done
from a2 obtain p__Inv3 p__Inv4 where a2:"p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4" apply fastforce done
have "(i=p__Inv4)\<or>(i=p__Inv3)\<or>(i~=p__Inv3\<and>i~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(i=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(i=p__Inv3)"
have "?P3 s"
apply (cut_tac a1 a2 b1, simp, rule_tac x="(neg (andForm (eqn (IVar (Ident ''ExGntd'')) (Const false)) (eqn (IVar (Field (Para (Ident ''Chan2'') p__Inv4) ''Cmd'')) (Const GntE))))" in exI, auto) done
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(i~=p__Inv3\<and>i~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_SendGntEVsinv__44:
assumes a1: "(\<exists> i. i\<le>N\<and>r=n_SendGntE N i)" and
a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain i where a1:"i\<le>N\<and>r=n_SendGntE N i" apply fastforce done
from a2 obtain p__Inv3 p__Inv4 where a2:"p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4" apply fastforce done
have "(i=p__Inv4)\<or>(i=p__Inv3)\<or>(i~=p__Inv3\<and>i~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(i=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(i=p__Inv3)"
have "?P3 s"
apply (cut_tac a1 a2 b1, simp, rule_tac x="(neg (andForm (eqn (IVar (Ident ''ExGntd'')) (Const false)) (eqn (IVar (Field (Para (Ident ''Chan2'') p__Inv4) ''Cmd'')) (Const GntE))))" in exI, auto) done
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(i~=p__Inv3\<and>i~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_RecvGntSVsinv__44:
assumes a1: "(\<exists> i. i\<le>N\<and>r=n_RecvGntS i)" and
a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain i where a1:"i\<le>N\<and>r=n_RecvGntS i" apply fastforce done
from a2 obtain p__Inv3 p__Inv4 where a2:"p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4" apply fastforce done
have "(i=p__Inv4)\<or>(i=p__Inv3)\<or>(i~=p__Inv3\<and>i~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(i=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(i=p__Inv3)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(i~=p__Inv3\<and>i~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_RecvGntEVsinv__44:
assumes a1: "(\<exists> i. i\<le>N\<and>r=n_RecvGntE i)" and
a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4)"
shows "invHoldForRule s f r (invariants N)" (is "?P1 s \<or> ?P2 s \<or> ?P3 s")
proof -
from a1 obtain i where a1:"i\<le>N\<and>r=n_RecvGntE i" apply fastforce done
from a2 obtain p__Inv3 p__Inv4 where a2:"p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4" apply fastforce done
have "(i=p__Inv4)\<or>(i=p__Inv3)\<or>(i~=p__Inv3\<and>i~=p__Inv4)" apply (cut_tac a1 a2, auto) done
moreover {
assume b1: "(i=p__Inv4)"
have "?P1 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(i=p__Inv3)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
moreover {
assume b1: "(i~=p__Inv3\<and>i~=p__Inv4)"
have "?P2 s"
proof(cut_tac a1 a2 b1, auto) qed
then have "invHoldForRule s f r (invariants N)" by auto
}
ultimately show "invHoldForRule s f r (invariants N)" by satx
qed
lemma n_StoreVsinv__44:
assumes a1: "\<exists> i d. i\<le>N\<and>d\<le>N\<and>r=n_Store i d" and
a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_SendReqESVsinv__44:
assumes a1: "\<exists> i. i\<le>N\<and>r=n_SendReqES i" and
a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_RecvReqVsinv__44:
assumes a1: "\<exists> i. i\<le>N\<and>r=n_RecvReq N i" and
a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_SendReqSVsinv__44:
assumes a1: "\<exists> j. j\<le>N\<and>r=n_SendReqS j" and
a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
lemma n_SendReqEIVsinv__44:
assumes a1: "\<exists> i. i\<le>N\<and>r=n_SendReqEI i" and
a2: "(\<exists> p__Inv3 p__Inv4. p__Inv3\<le>N\<and>p__Inv4\<le>N\<and>p__Inv3~=p__Inv4\<and>f=inv__44 p__Inv3 p__Inv4)"
shows "invHoldForRule s f r (invariants N)"
apply (rule noEffectOnRule, cut_tac a1 a2, auto) done
end
|
//
// Copyright (c) 2021 Richard Hodges ([email protected])
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Official repository: https://github.com/madmongo1/boost_connector
//
#ifndef BOOST_CONNECTOR_PROPERTY_MAP_HPP
#define BOOST_CONNECTOR_PROPERTY_MAP_HPP
#include <boost/connector/property_value.hpp>
#include <ostream>
#include <unordered_map>
namespace boost::connector
{
struct property_map_layer
{
using parent_type = std::shared_ptr< property_map_layer const >;
property_map_layer(parent_type parent = nullptr)
: parent_(std::move(parent))
, map_()
{
}
property_value const *
query(std::string const &key) const
{
property_value const *result = nullptr;
if (auto i = map_.find(key); i != map_.end())
result = &i->second;
else if (parent_)
result = parent_->query(key);
return result;
}
template < class T >
void
set(std::string_view name, T &&value)
{
static thread_local std::string key;
key.assign(name.begin(), name.end());
auto i = map_.find(key);
if (i == map_.end())
map_.emplace_hint(i, key, property_value(std::forward< T >(value)));
else
i->second = property_value(std::forward< T >(value));
}
parent_type parent_;
std::
unordered_map< std::string, property_value, boost::hash< std::string > >
map_;
};
struct property_map
{
property_map(std::shared_ptr< property_map_layer > impl = nullptr)
: impl_(std::move(impl))
{
}
property_value const *
query(std::string const &key) const
{
return impl_->query(key);
}
std::shared_ptr< property_map_layer > const &
get_implementation() const
{
return impl_;
}
std::shared_ptr< property_map_layer > impl_;
};
struct mutable_property_map
{
mutable_property_map(property_map_layer::parent_type parent_layer = nullptr);
template < class T >
mutable_property_map &&
set(std::string_view name, T &&value)
{
impl_->set(name, std::forward< T >(value));
return std::move(*this);
}
template < class T >
mutable_property_map &&
set(std::string_view name, std::string_view sv)
{
impl_->set(name, std::string(sv.begin(), sv.end()));
return std::move(*this);
}
template < class T >
mutable_property_map &&
set(std::string_view name, const char *sv)
{
impl_->set(name, std::string(sv));
return std::move(*this);
}
std::shared_ptr< property_map_layer > &&
get_implementation() &&
{
return std::move(impl_);
}
std::shared_ptr< property_map_layer > impl_;
};
inline mutable_property_map
mutate(property_map const &source_map)
{
return mutable_property_map(source_map.get_implementation());
}
inline property_map
fix(mutable_property_map &&m)
{
return property_map(std::move(m).get_implementation());
}
} // namespace boost::connector
#endif // BOOST_CONNECTOR_PROPERTY_MAP_HPP
|
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Semigroup.Morphism where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Isomorphism
open import Cubical.Functions.Embedding
open import Cubical.Algebra
open import Cubical.Algebra.Magma.Morphism
private
variable
s t : Level
IsSemigroupHom : (S : Semigroup s) (T : Semigroup t) → (⟨ S ⟩ → ⟨ T ⟩) → Type (ℓ-max s t)
IsSemigroupHom S T fun = Homomorphic₂ fun (Semigroup._•_ S) (Semigroup._•_ T)
record SemigroupHom (S : Semigroup s) (T : Semigroup t) : Type (ℓ-max s t) where
constructor semigrouphom
field
fun : ⟨ S ⟩ → ⟨ T ⟩
isHom : IsSemigroupHom S T fun
record SemigroupEquiv (S : Semigroup s) (T : Semigroup t) : Type (ℓ-max s t) where
constructor semigroupequiv
field
eq : ⟨ S ⟩ ≃ ⟨ T ⟩
isHom : IsSemigroupHom S T (equivFun eq)
hom : SemigroupHom S T
hom = record { isHom = isHom }
instance
SemigroupHomOperators : HomOperators (Semigroup s) (Semigroup t) (ℓ-max s t)
SemigroupHomOperators = record { _⟶ᴴ_ = SemigroupHom; _≃ᴴ_ = SemigroupEquiv }
private
variable
S : Semigroup s
T : Semigroup t
SemigroupHom→MagmaHom : (S ⟶ᴴ T) → (Semigroup.magma S ⟶ᴴ Semigroup.magma T)
SemigroupHom→MagmaHom hom .MagmaHom.fun = hom .SemigroupHom.fun
SemigroupHom→MagmaHom hom .MagmaHom.isHom = hom .SemigroupHom.isHom
MagmaHom→SemigroupHom : (Semigroup.magma S ⟶ᴴ Semigroup.magma T) → (S ⟶ᴴ T)
MagmaHom→SemigroupHom hom .SemigroupHom.fun = hom .MagmaHom.fun
MagmaHom→SemigroupHom hom .SemigroupHom.isHom = hom .MagmaHom.isHom
SemigroupHom≃MagmaHom : (S ⟶ᴴ T) ≃ (Semigroup.magma S ⟶ᴴ Semigroup.magma T)
SemigroupHom≃MagmaHom = isoToEquiv (iso SemigroupHom→MagmaHom MagmaHom→SemigroupHom (λ _ → refl) (λ _ → refl))
SemigroupEquiv→MagmaEquiv : S ≃ᴴ T → Semigroup.magma S ≃ᴴ Semigroup.magma T
SemigroupEquiv→MagmaEquiv eq .MagmaEquiv.eq = eq .SemigroupEquiv.eq
SemigroupEquiv→MagmaEquiv eq .MagmaEquiv.isHom = eq .SemigroupEquiv.isHom
MagmaEquiv→SemigroupEquiv : Semigroup.magma S ≃ᴴ Semigroup.magma T → S ≃ᴴ T
MagmaEquiv→SemigroupEquiv eq .SemigroupEquiv.eq = eq .MagmaEquiv.eq
MagmaEquiv→SemigroupEquiv eq .SemigroupEquiv.isHom = eq .MagmaEquiv.isHom
SemigroupEquiv≃MagmaEquiv : (S ≃ᴴ T) ≃ (Semigroup.magma S ≃ᴴ Semigroup.magma T)
SemigroupEquiv≃MagmaEquiv = isoToEquiv (iso SemigroupEquiv→MagmaEquiv MagmaEquiv→SemigroupEquiv (λ _ → refl) (λ _ → refl))
|
Mini series I am collecting!
What if a threat was so great that someone had to gather the greatest heroes of all time and anywhere together to combat? One single great threat needs the single greatest team-up. Here is my team.
Usually considered street-level characters, but I think they're above that classification. Consider this my "People on Midnighter's Level/Could Beat Him in a Good Fight" list.
This list is dedicated to the Native American super hero whether they are indigenous to North, South, or Central America; the Caribbean; or are of Native American descent.
Characters in the land of Limbo. Save them from their fate, Powers-That-Be !
A list of Heroes with tragic past/ emotional problem, trying to find their place in the world.
These are the characters that I think are awesome, male or female, and I'll explain why they are on here. They can be heroes or villians.
These are villains that I've dubbed the greatest of all time.
Heroes who start their heroics by simply do it and not by the need to satisfy a death in a family or other tragedy.
Random list of artists whom I believe make the best eye candy!
Alright, as a comic fan, there is more than just the characters, there are the awesome stories that go along with it. This is a list of some my favorite comic book stories of all time. |
# This script finds the consensus category per clip and video for original, umbrella duiker, and umbrella designations.
# Umbrella duiker: all duikers together as duiker, all hogs together as hog, large ungulate and small antelope together as hoofed animal.
# Umbrella: duikers, large ungulate, and small antelope together as ungulate, all hogs together as hog.
# How to find the consensus category per clip:
# The consensus category is the single category with a proportion of the responses >=0.5.
# If there are 2 categories that are each 50% of the responses, or if there is one category that is most frequenet but at a proportion less than 0.5, then the clip doesn't reach consensus.
# The proportion agreement for each clip is the proportion of classifications that match the expert category, regardless of what the consensus category is.
# The consensus proportion is the proportion of responses that belong to the consensus category (range 0.5-1).
# If a clip has 1, 2, or 3 nonblank classifications and the rest are blank, then that clip is instead considered "presence undetermined".
# To find the video consensus:
# First remove any presence undetermined clips.
# A video with all blank clips is consensus blank. If not all clips are consensus blank, then consider only clips that are not consensus blank.
# If all remaining nonblank clips are nonconsensus, then the video is nonconsensus.
# Otherwise, consider only clip(s) that have the highest consensus proportion. If those remaining clips reach a consensus on different categories, the video does not reach consensus. If the remaining clips all reach consensus on the same category, then the video reaches consensus on that category.
# The proportion agreement for the video is the average proportion agreement of the clips that were considered for the consensus category determination.
# Replace "YourPathHere" with respective file path
# Note: "species" in this script is the same as a "category" mentioned in the paper
#############################################
# Original category designation #
#############################################
# Bring in expert data
# expert.data<-read.table("YourPathHere/expert_data_for_analysis_CandS_Species_ID_MS.txt", sep="\t", header=T)
expert.data<-read.table("YourPathHere/expert_data_for_analysis_CandS_Species_ID_MS.txt", sep="\t", header=T)
nrow(expert.data)
#11896
######################## Find consensus species per clip
# class.data<-read.table("YourPathHere/class_data_for_analysis_CandS_Species_ID_MS.txt", sep="\t", header=T)
class.data<-read.table("YourPathHere/class_data_for_analysis_CandS_Species_ID_MS.txt", sep="\t", header=T)
nrow(class.data)
#313505
class.data<-class.data[order(class.data$Clip.ID),]
#create summ.data to house summaries for each clip
summ.data<-data.frame(Clip.ID=sort(unique(class.data$Clip.ID)), Video.ID=NA, Expert.Species=NA, Consensus.Species=NA, Consensus.Prop=NA, Prop.Agreement=NA, Number.Blanks=NA, Number.Nonblanks=NA)
summ.data$Video.ID<-class.data$Video.ID[match(summ.data$Clip.ID, class.data$Clip.ID)]
summ.data$Expert.Species<-expert.data$Species[match(summ.data$Video.ID, expert.data$Video.ID)]
nrow(summ.data)
#47584
consensus.threshold<-0.5
# Summarize the consensus per clip and proportion agreement to expert.id
start.time<-Sys.time()
for(i in 1:nrow(summ.data)){
cat(i, round(i/47584*100, 2), "% \n")
flush.console()
sub.class<-class.data[class.data$Clip.ID==summ.data$Clip.ID[i],]
sub.Expert.Species<-expert.data$Species[expert.data$Video.ID==summ.data$Video.ID[i]]
Number.Blanks<-sum(sub.class$Species=="blank")
Number.Nonblanks<-sum(sub.class$Species!="blank")
summ.data$Number.Blanks[i]<-Number.Blanks
summ.data$Number.Nonblanks[i]<-Number.Nonblanks
# if the clip is only blanks, then species is blank
if(Number.Nonblanks==0){
summ.data$Consensus.Species[i]<-"blank"
summ.data$Consensus.Prop[i]<-1
summ.data$Prop.Agreement[i]<-mean(sub.class$Species==sub.Expert.Species)
# if there are enough nonblanks to find a consensus, find a consensus using nonblank classifications only
} else if(Number.Nonblanks>=4){
sub.class<-sub.class[sub.class$Species!="blank",]
sp.table<-table(sub.class$Species)
max.prop<-max(sp.table)/sum(sp.table)
max.sp<-names(sp.table[sp.table==max(sp.table)])
# if only one species has the maximum proportion of responses, and the prop is at least 0.5, then clip reaches consensus on that species
if(length(max.sp)==1 & max.prop>=consensus.threshold){
summ.data$Consensus.Species[i]<-max.sp
summ.data$Consensus.Prop[i]<-max.prop
summ.data$Prop.Agreement[i]<-mean(sub.class$Species==sub.Expert.Species)
# otherwise doesn't reach consensus
} else {
summ.data$Consensus.Species[i]<-"no consensus"
}
# if there are too few nonblank clips, then it's presence undetermined
} else if(Number.Nonblanks<=3){
summ.data$Consensus.Species[i]<-"presence undetermined"
}
}
end.time<-Sys.time()
end.time - start.time
#19 mins
sum(is.na(summ.data$Consensus.Species))
#0
table(summ.data$Consensus.Species)
# bird blank chimpanzee
# 288 29360 672
# dark duiker elephant giant forest hog
# 48 6 11
# hippopotamus human Jentink's duiker
# 76 881 123
# large ungulate leopard no consensus
# 4 89 2028
# other (non-primate) other (primate) pangolin
# 142 1994 13
# porcupine presence undetermined red duiker
# 26 1763 2632
# red river hog rodent small antelope
# 453 165 32
# small cat small grey duiker warthog
# 10 6583 10
# zebra duiker
# 175
# write.table(summ.data, "YourPathHere/consensus_per_clip_original_CandS_Species_ID_MS.txt", sep="\t", row.names=F, col.names=T)
write.table(summ.data, "YourPathHere/consensus_per_clip_original_CandS_Species_ID_MS.txt", sep="\t", row.names=F, col.names=T)
######################## Find consensus species per video
clip.cons.data<-read.table("YourPathHere/consensus_per_clip_original_CandS_Species_ID_MS.txt", sep="\t", header=T, stringsAsFactor=F)
nrow(clip.cons.data)
#47584
length(unique(clip.cons.data$Video.ID))
#11896
clip.cons.data<-clip.cons.data[order(clip.cons.data$Video.ID),]
video.cons<-data.frame(Video.ID=unique(clip.cons.data$Video.ID), Expert.Species=NA, Consensus.Species=NA, Consensus.Prop=NA, Prop.Agreement=NA, Consensus.Type=NA)
video.cons$Expert.Species<-clip.cons.data$Expert.Species[match(video.cons$Video.ID, clip.cons.data$Video.ID)]
nrow(video.cons)
#11896
start.time<-Sys.time()
for(i in 1:nrow(video.cons)){
# cat(i, round(i/11896*100, 2), "% \n")
sub.cons<-clip.cons.data[clip.cons.data$Video.ID==video.cons$Video.ID[i],]
# First remove any clips that are presence undetermined
sub.cons<-sub.cons[sub.cons$Consensus.Species!="presence undetermined",]
# If there are any remaining clips, get consensus
if(nrow(sub.cons)>0){
# If there are only blanks, then video is blank
if(sum(sub.cons$Consensus.Species=="blank")==nrow(sub.cons)){
video.cons$Consensus.Type[i]<-"Consensus blank"
video.cons$Consensus.Species[i]<-"blank"
# If there are only nonblank nonconsensus clips, don't continue, video is non consensus
} else if(sum(sub.cons$Consensus.Species=="no consensus")==sum(sub.cons$Consensus.Species!="blank")){
video.cons$Consensus.Type[i]<-"All nonblank clips are nonconsensus"
video.cons$Consensus.Species[i]<-"no consensus"
} else {
# Remove any nonconsensus species and blanks
sub.cons<-sub.cons[!sub.cons$Consensus.Species %in% c("no consensus","blank"),]
# Keep only rows that have the highest consensus prop
sub.cons<-sub.cons[sub.cons$Consensus.Prop==max(sub.cons$Consensus.Prop),]
# If there are multiple species present, then no consensus
if(length(unique(sub.cons$Consensus.Species))>1){
video.cons$Consensus.Type[i]<-"Conflicting consensus species"
video.cons$Consensus.Species[i]<-"no consensus"
# If there's just one species present, then video reaches consensus on that species, at that max proportion, with the average Prop.Agreement
} else {
video.cons$Consensus.Type[i]<-"Consensus reached"
video.cons$Consensus.Species[i]<-sub.cons$Consensus.Species[1]
video.cons$Consensus.Prop[i]<-sub.cons$Consensus.Prop[1]
video.cons$Prop.Agreement[i]<-mean(sub.cons$Prop.Agreement)
}
}
# Otherwise whole video is presence undetermined
} else {
video.cons$Consensus.Species[i]<-"presence undetermined"
video.cons$Consensus.Type[i]<-"presence undetermined"
}
}
end.time<-Sys.time()
end.time - start.time
#28 seconds
table(video.cons$Consensus.Type, useNA="always")
# All nonblank clips are nonconsensus Conflicting consensus species
# 615 19
# Consensus blank Consensus reached
# 3665 7595
# presence undetermined <NA>
# 2 0
table(video.cons$Consensus.Type, video.cons$Expert.Species=="blank")
# FALSE TRUE
# All nonblank clips are nonconsensus 608 7
# Conflicting consensus species 19 0
# Consensus blank 1106 2559
# Consensus reached 7544 51
# presence undetermined 2 0
######## Remove presence undetermined videos
video.cons<-video.cons[video.cons$Consensus.Species!="presence undetermined",]
nrow(video.cons)
#11894
# write.table(video.cons, "YourPathHere/consensus_per_video_original_CandS_Species_ID_MS.txt", sep="\t", row.names=F, col.names=T)
write.table(video.cons, "YourPathHere/consensus_per_video_original_CandS_Species_ID_MS.txt", sep="\t", row.names=F, col.names=T)
#############################################
# Umbrella duiker designation #
#############################################
# Bring in expert data
expert.data<-read.table("YourPathHere/expert_data_for_analysis_CandS_Species_ID_MS.txt", sep="\t", header=T)
nrow(expert.data)
#11896
######################## Find consensus species per clip
class.data<-read.table("YourPathHere/class_data_for_analysis_CandS_Species_ID_MS.txt", sep="\t", header=T)
nrow(class.data)
#313505
class.data<-class.data[order(class.data$Clip.ID),]
# Create summ.data to house summaries for each clip
summ.data.umbrella.duiker<-data.frame(Clip.ID=sort(unique(class.data$Clip.ID)), Video.ID=NA, Expert.Species=NA, Consensus.Species=NA, Consensus.Prop=NA, Prop.Agreement=NA, Number.Blanks=NA, Number.Nonblanks=NA)
summ.data.umbrella.duiker$Video.ID<-class.data$Video.ID[match(summ.data.umbrella.duiker$Clip.ID, class.data$Clip.ID)]
summ.data.umbrella.duiker$Expert.Species<-expert.data$Umbrella.Duiker.Species[match(summ.data.umbrella.duiker$Video.ID, expert.data$Video.ID)]
nrow(summ.data.umbrella.duiker)
#47584
consensus.threshold<-0.5
# Summarize the consensus per clip and proportion agreement to expert.id
start.time<-Sys.time()
for(i in 1:nrow(summ.data.umbrella.duiker)){
# cat(i, round(i/47584*100, 2), "% \n")
sub.class<-class.data[class.data$Clip.ID==summ.data.umbrella.duiker$Clip.ID[i],]
sub.Expert.Species<-expert.data$Umbrella.Duiker.Species[expert.data$Video.ID==summ.data.umbrella.duiker$Video.ID[i]]
Number.Blanks<-sum(sub.class$Umbrella.Duiker.Species=="blank")
Number.Nonblanks<-sum(sub.class$Umbrella.Duiker.Species!="blank")
summ.data.umbrella.duiker$Number.Blanks[i]<-Number.Blanks
summ.data.umbrella.duiker$Number.Nonblanks[i]<-Number.Nonblanks
# If the clip is only blanks, then species is blank
if(Number.Nonblanks==0){
summ.data.umbrella.duiker$Consensus.Species[i]<-"blank"
summ.data.umbrella.duiker$Consensus.Prop[i]<-1
summ.data.umbrella.duiker$Prop.Agreement[i]<-mean(sub.class$Umbrella.Duiker.Species==sub.Expert.Species)
# If there are enough nonblanks to find a consensus, find a consensus using nonblank classifications only
} else if(Number.Nonblanks>=4){
sub.class<-sub.class[sub.class$Umbrella.Duiker.Species!="blank",]
sp.table<-table(sub.class$Umbrella.Duiker.Species)
max.prop<-max(sp.table)/sum(sp.table)
max.sp<-names(sp.table[sp.table==max(sp.table)])
# If only one species has the maximum proportion of responses, and the prop is at least 0.5, then clip reaches consensus on that species
if(length(max.sp)==1 & max.prop>=consensus.threshold){
summ.data.umbrella.duiker$Consensus.Species[i]<-max.sp
summ.data.umbrella.duiker$Consensus.Prop[i]<-max.prop
summ.data.umbrella.duiker$Prop.Agreement[i]<-mean(sub.class$Umbrella.Duiker.Species==sub.Expert.Species)
# Otherwise doesn't reach consensus
} else {
summ.data.umbrella.duiker$Consensus.Species[i]<-"no consensus"
}
# If there are too few nonblank clips, then it's presence undetermined
} else if(Number.Nonblanks<=3){
summ.data.umbrella.duiker$Consensus.Species[i]<-"presence undetermined"
}
}
end.time<-Sys.time()
end.time - start.time
#21 mins
sum(is.na(summ.data.umbrella.duiker$Consensus.Species))
#0
table(summ.data.umbrella.duiker$Consensus.Species)
# bird blank chimpanzee duiker
# 288 29360 672 11221
# elephant hippopotamus hog hoofed.animal
# 6 75 558 28
# human leopard no consensus other (non-primate)
# 881 89 295 141
# other (primate) pangolin porcupine presence undetermined
# 1994 13 26 1763
# rodent small cat
# 164 10
#
write.table(summ.data.umbrella.duiker, "YourPathHere/consensus_per_clip_umbrella_duiker_CandS_Species_ID_MS.txt", sep="\t", row.names=F, col.names=T)
write.table(summ.data.umbrella.duiker, "YourPathHere/consensus_per_clip_umbrella_duiker_CandS_Species_ID_MS.txt", sep="\t", row.names=F, col.names=T)
######################## Find consensus species per video
clip.cons.data.umbrella.duiker<-read.table("YourPathHere/consensus_per_clip_umbrella_duiker_CandS_Species_ID_MS.txt", sep="\t", header=T, stringsAsFactor=F)
nrow(clip.cons.data.umbrella.duiker)
#47584
length(unique(clip.cons.data.umbrella.duiker$Video.ID))
#11896
clip.cons.data.umbrella.duiker<-clip.cons.data.umbrella.duiker[order(clip.cons.data.umbrella.duiker$Video.ID),]
video.cons.umbrella.duiker<-data.frame(Video.ID=unique(clip.cons.data.umbrella.duiker$Video.ID), Expert.Species=NA, Consensus.Species=NA, Consensus.Prop=NA, Prop.Agreement=NA, Consensus.Type=NA)
video.cons.umbrella.duiker$Expert.Species<-clip.cons.data.umbrella.duiker$Expert.Species[match(video.cons.umbrella.duiker$Video.ID, clip.cons.data.umbrella.duiker$Video.ID)]
nrow(video.cons.umbrella.duiker)
#11896
start.time<-Sys.time()
for(i in 1:nrow(video.cons.umbrella.duiker)){
# cat(i, round(i/11896*100, 2), "% \n")
sub.cons<-clip.cons.data.umbrella.duiker[clip.cons.data.umbrella.duiker$Video.ID==video.cons.umbrella.duiker$Video.ID[i],]
# First remove any clips that are presence undetermined
sub.cons<-sub.cons[sub.cons$Consensus.Species!="presence undetermined",]
# If there are any remaining clips, get consensus
if(nrow(sub.cons)>0){
# If there are only blanks, then video is blank
if(sum(sub.cons$Consensus.Species=="blank")==nrow(sub.cons)){
video.cons.umbrella.duiker$Consensus.Type[i]<-"Consensus blank"
video.cons.umbrella.duiker$Consensus.Species[i]<-"blank"
# If there are only nonblank nonconsensus clips, don't continue, video is non consensus
} else if(sum(sub.cons$Consensus.Species=="no consensus")==sum(sub.cons$Consensus.Species!="blank")){
video.cons.umbrella.duiker$Consensus.Type[i]<-"All nonblank clips are nonconsensus"
video.cons.umbrella.duiker$Consensus.Species[i]<-"no consensus"
} else {
# Remove any nonconsensus species and blanks
sub.cons<-sub.cons[!sub.cons$Consensus.Species %in% c("no consensus","blank"),]
# Keep only rows that have the highest consensus prop
sub.cons<-sub.cons[sub.cons$Consensus.Prop==max(sub.cons$Consensus.Prop),]
# If there are multiple species present, then no consensus
if(length(unique(sub.cons$Consensus.Species))>1){
video.cons.umbrella.duiker$Consensus.Type[i]<-"Conflicting consensus species"
video.cons.umbrella.duiker$Consensus.Species[i]<-"no consensus"
# If there's just one species present, then video reaches consensus on that species, at that max proportion, with the average Prop.Agreement
} else {
video.cons.umbrella.duiker$Consensus.Type[i]<-"Consensus reached"
video.cons.umbrella.duiker$Consensus.Species[i]<-sub.cons$Consensus.Species[1]
video.cons.umbrella.duiker$Consensus.Prop[i]<-sub.cons$Consensus.Prop[1]
video.cons.umbrella.duiker$Prop.Agreement[i]<-mean(sub.cons$Prop.Agreement)
}
}
# Otherwise whole video is presence undetermined
} else {
video.cons.umbrella.duiker$Consensus.Species[i]<-"presence undetermined"
video.cons.umbrella.duiker$Consensus.Type[i]<-"presence undetermined"
}
}
end.time<-Sys.time()
end.time - start.time
#19 seconds
table(video.cons.umbrella.duiker$Consensus.Type, useNA="always")
# All nonblank clips are nonconsensus Conflicting consensus species
# 107 15
# Consensus blank Consensus reached
# 3665 8107
# presence undetermined <NA>
# 2 0
table(video.cons.umbrella.duiker$Consensus.Type, video.cons.umbrella.duiker$Expert.Species=="blank")
# FALSE TRUE
# All nonblank clips are nonconsensus 101 6
# Conflicting consensus species 15 0
# Consensus blank 1106 2559
# Consensus reached 8055 52
# presence undetermined 2 0
######## Remove presence undetermined videos for now
video.cons.umbrella.duiker<-video.cons.umbrella.duiker[video.cons.umbrella.duiker$Consensus.Species!="presence undetermined",]
nrow(video.cons.umbrella.duiker)
#11894
# write.table(video.cons.umbrella.duiker, "YourPathHere/consensus_per_video_umbrella_duiker_CandS_Species_ID_MS.txt", sep="\t", row.names=F, col.names=T)
write.table(video.cons.umbrella.duiker, "YourPathHere/consensus_per_video_umbrella_duiker_CandS_Species_ID_MS.txt", sep="\t", row.names=F, col.names=T)
#############################################
# umbrella #
#############################################
# Bring in expert data
expert.data<-read.table("YourPathHere/expert_data_for_analysis_CandS_Species_ID_MS.txt", sep="\t", header=T)
nrow(expert.data)
#11896
######################## Find consensus species per clip
class.data<-read.table("YourPathHere/class_data_for_analysis_CandS_Species_ID_MS.txt", sep="\t", header=T)
nrow(class.data)
#313505
class.data<-class.data[order(class.data$Clip.ID),]
# Create summ.data to house summaries for each clip
summ.data.umbrella<-data.frame(Clip.ID=sort(unique(class.data$Clip.ID)), Video.ID=NA, Expert.Species=NA, Consensus.Species=NA, Consensus.Prop=NA, Prop.Agreement=NA, Number.Blanks=NA, Number.Nonblanks=NA)
summ.data.umbrella$Video.ID<-class.data$Video.ID[match(summ.data.umbrella$Clip.ID, class.data$Clip.ID)]
summ.data.umbrella$Expert.Species<-expert.data$Umbrella.Species[match(summ.data.umbrella$Video.ID, expert.data$Video.ID)]
nrow(summ.data.umbrella)
#47584
consensus.threshold<-0.5
# Summarize the consensus per clip and proportion agreement to expert.id
start.time<-Sys.time()
for(i in 1:nrow(summ.data.umbrella)){
# cat(i, round(i/47584*100, 2), "% \n")
sub.class<-class.data[class.data$Clip.ID==summ.data.umbrella$Clip.ID[i],]
sub.Expert.Species<-expert.data$Umbrella.Species[expert.data$Video.ID==summ.data.umbrella$Video.ID[i]]
Number.Blanks<-sum(sub.class$Umbrella.Species=="blank")
Number.Nonblanks<-sum(sub.class$Umbrella.Species!="blank")
summ.data.umbrella$Number.Blanks[i]<-Number.Blanks
summ.data.umbrella$Number.Nonblanks[i]<-Number.Nonblanks
# If the clip is only blanks, then species is blank
if(Number.Nonblanks==0){
summ.data.umbrella$Consensus.Species[i]<-"blank"
summ.data.umbrella$Consensus.Prop[i]<-1
summ.data.umbrella$Prop.Agreement[i]<-mean(sub.class$Umbrella.Species==sub.Expert.Species)
# If there are enough nonblanks to find a consensus, find a consensus using nonblank classifications only
} else if(Number.Nonblanks>=4){
sub.class<-sub.class[sub.class$Umbrella.Species!="blank",]
sp.table<-table(sub.class$Umbrella.Species)
max.prop<-max(sp.table)/sum(sp.table)
max.sp<-names(sp.table[sp.table==max(sp.table)])
# If only one species has the maximum proportion of responses, and the prop is at least 0.5, then clip reaches consensus on that species
if(length(max.sp)==1 & max.prop>=consensus.threshold){
summ.data.umbrella$Consensus.Species[i]<-max.sp
summ.data.umbrella$Consensus.Prop[i]<-max.prop
summ.data.umbrella$Prop.Agreement[i]<-mean(sub.class$Umbrella.Species==sub.Expert.Species)
# Otherwise doesn't reach consensus
} else {
summ.data.umbrella$Consensus.Species[i]<-"no consensus"
}
# If there are too few nonblank clips, then it's presence undetermined
} else if(Number.Nonblanks<=3){
summ.data.umbrella$Consensus.Species[i]<-"presence undetermined"
}
}
end.time<-Sys.time()
end.time - start.time
#20 mins
sum(is.na(summ.data.umbrella$Consensus.Species))
#0
table(summ.data.umbrella$Consensus.Species)
# bird blank chimpanzee elephant
# 288 29360 672 6
# hippopotamus hog hoofed.animal human
# 75 555 11318 881
# leopard no consensus other (non-primate) other (primate)
# 89 230 141 1994
# pangolin porcupine presence undetermined rodent
# 13 26 1763 164
# small cat
# 9
# write.table(summ.data.umbrella, "YourPathHere/consensus_per_clip_umbrella_CandS_Species_ID_MS.txt", sep="\t", row.names=F, col.names=T)
write.table(summ.data.umbrella, "YourPathHere/consensus_per_clip_umbrella_CandS_Species_ID_MS.txt", sep="\t", row.names=F, col.names=T)
######################## Find consensus species per video
clip.cons.data.umbrella<-read.table("YourPathHere/consensus_per_clip_umbrella_CandS_Species_ID_MS.txt", sep="\t", header=T, stringsAsFactor=F)
nrow(clip.cons.data.umbrella)
#47584
length(unique(clip.cons.data.umbrella$Video.ID))
#11896
clip.cons.data.umbrella<-clip.cons.data.umbrella[order(clip.cons.data.umbrella$Video.ID),]
video.cons.umbrella<-data.frame(Video.ID=unique(clip.cons.data.umbrella$Video.ID), Expert.Species=NA, Consensus.Species=NA, Consensus.Prop=NA, Prop.Agreement=NA, Consensus.Type=NA)
video.cons.umbrella$Expert.Species<-clip.cons.data.umbrella$Expert.Species[match(video.cons.umbrella$Video.ID, clip.cons.data.umbrella$Video.ID)]
nrow(video.cons.umbrella)
#12876
start.time<-Sys.time()
for(i in 1:nrow(video.cons.umbrella)){
# cat(i, round(i/11896*100, 2), "% \n")
sub.cons<-clip.cons.data.umbrella[clip.cons.data.umbrella$Video.ID==video.cons.umbrella$Video.ID[i],]
# First remove any clips that are presence undetermined
sub.cons<-sub.cons[sub.cons$Consensus.Species!="presence undetermined",]
# If there are any remaining clips, get consensus
if(nrow(sub.cons)>0){
# If there are only blanks, then video is blank
if(sum(sub.cons$Consensus.Species=="blank")==nrow(sub.cons)){
video.cons.umbrella$Consensus.Type[i]<-"Consensus blank"
video.cons.umbrella$Consensus.Species[i]<-"blank"
# If there are only nonblank nonconsensus clips, don't continue, video is non consensus
} else if(sum(sub.cons$Consensus.Species=="no consensus")==sum(sub.cons$Consensus.Species!="blank")){
video.cons.umbrella$Consensus.Type[i]<-"All nonblank clips are nonconsensus"
video.cons.umbrella$Consensus.Species[i]<-"no consensus"
} else {
# Remove any nonconsensus species and blanks
sub.cons<-sub.cons[!sub.cons$Consensus.Species %in% c("no consensus","blank"),]
# Keep only rows that have the highest consensus prop
sub.cons<-sub.cons[sub.cons$Consensus.Prop==max(sub.cons$Consensus.Prop),]
# If there are multiple species present, then no consensus
if(length(unique(sub.cons$Consensus.Species))>1){
video.cons.umbrella$Consensus.Type[i]<-"Conflicting consensus species"
video.cons.umbrella$Consensus.Species[i]<-"no consensus"
# If there's just one species present, then video reaches consensus on that species, at that max proportion, with the average Prop.Agreement
} else {
video.cons.umbrella$Consensus.Type[i]<-"Consensus reached"
video.cons.umbrella$Consensus.Species[i]<-sub.cons$Consensus.Species[1]
video.cons.umbrella$Consensus.Prop[i]<-sub.cons$Consensus.Prop[1]
video.cons.umbrella$Prop.Agreement[i]<-mean(sub.cons$Prop.Agreement)
}
}
# Otherwise whole video is presence undetermined
} else {
video.cons.umbrella$Consensus.Species[i]<-"presence undetermined"
video.cons.umbrella$Consensus.Type[i]<-"presence undetermined"
}
}
end.time<-Sys.time()
end.time - start.time
#20 seconds
table(video.cons.umbrella$Consensus.Type, useNA="always")
# All nonblank clips are nonconsensus Conflicting consensus species
# 93 15
# Consensus blank Consensus reached
# 3665 8121
# presence undetermined <NA>
# 2 0
table(video.cons.umbrella$Consensus.Type, video.cons.umbrella$Expert.Species=="blank")
# FALSE TRUE
# All nonblank clips are nonconsensus 89 4
# Conflicting consensus species 15 0
# Consensus blank 1106 2559
# Consensus reached 8067 54
# presence undetermined 2 0
######## Remove presence undetermined videos for now
video.cons.umbrella<-video.cons.umbrella[video.cons.umbrella$Consensus.Species!="presence undetermined",]
nrow(video.cons.umbrella)
#11894
# write.table(video.cons.umbrella, "YourPathHere/consensus_per_video_umbrella_CandS_Species_ID_MS.txt", sep="\t", row.names=F, col.names=T)
write.table(video.cons.umbrella, "YourPathHere/consensus_per_video_umbrella_CandS_Species_ID_MS.txt", sep="\t", row.names=F, col.names=T)
|
Require Export Base.
Definition is_terminal {C: Category} (o: C) :=
forall x: C, exists f: x ~> o, forall g, f = g.
Definition ex_terminal (C: Category) :=
exists x: C, is_terminal x.
Instance is_terminal_iso (C: Category): Proper (isomorphic C ==> iff) is_terminal.
Proof.
enough (Proper (isomorphic C ==> impl) is_terminal).
now split; apply H.
intros X Y [i] H Z.
specialize (H Z).
destruct H as [f H].
exists (i ∘ f).
intros g.
specialize (H (i⁻¹ ∘ g)).
subst f.
rewrite comp_assoc.
rewrite inv_r.
apply comp_id_l.
Qed.
Lemma terminal_euniqueness (C: Category): euniqueness (@is_terminal C).
Proof.
intros x y Hx Hy.
destruct (Hx y) as [f _].
destruct (Hy x) as [g _].
specialize (Hx x).
specialize (Hy y).
destruct Hx as [x' Hx].
destruct Hy as [y' Hy].
constructor.
exists g, f.
transitivity x'.
symmetry.
1, 2: apply Hx.
transitivity y'.
symmetry.
all: apply Hy.
Qed.
Lemma ex_terminal_eunique (C: Category): ex_terminal C <-> exists!! x: C, is_terminal x.
Proof.
rewrite <- eunique_existence.
split.
+ intros H.
split.
exact (is_terminal_iso C).
split.
exact H.
exact (terminal_euniqueness C).
+ intros [_ [H _]].
exact H.
Qed.
Instance ex_terminal_iso: Proper (isomorphic Cat ==> iff) ex_terminal.
Proof.
enough (Proper (isomorphic Cat ==> impl) ex_terminal).
now split; apply H.
intros C D [I] [o H].
exists (to I o).
intros x'.
destruct (ex_fobj_iso I x') as [x].
subst x'.
specialize (H x).
destruct H as [f H].
exists (fmap (to I) f).
intros g'.
destruct (ex_fmap_iso I g') as [g].
subst g'.
f_equal.
apply H.
Qed.
Module TopCategory.
Structure mixin_of (C: Category) := Mixin {
one: C;
to_one {a: C}: a ~> one;
to_one_unique {a: C} (f: a ~> one): @to_one a = f;
}.
Notation class_of := mixin_of (only parsing).
Section ClassDef.
Structure type := Pack { sort: Category; _: class_of sort }.
Local Coercion sort: type >-> Category.
Variable T: type.
Definition class := match T return class_of T with Pack _ c => c end.
Definition Cat: Cat := T.
End ClassDef.
Lemma mixin_eq {C: Category} (m n: mixin_of C): m = n <-> one C m = one C n.
Proof.
split.
intros H.
now subst n.
destruct m as [a f Hf], n as [b g Hg]; simpl.
intros H.
subst b.
enough (f = g).
subst g.
f_equal; apply proof_irrelevance.
extensionality x.
apply Hf.
Qed.
Module Exports.
Coercion sort: type >-> Category.
Coercion Cat: type >-> Category.obj.
Notation TopCategory := type.
End Exports.
End TopCategory.
Export TopCategory.Exports.
Section Terminal.
Context {C: TopCategory}.
Definition one: C := TopCategory.one C (TopCategory.class C).
Definition to_one: forall {a: C}, a ~> one := @TopCategory.to_one C (TopCategory.class C).
Lemma to_one_unique {a: C} (f: a ~> one): to_one = f.
Proof. apply TopCategory.to_one_unique. Qed.
Lemma to_one_comp {a b: C} (f: a ~> b): to_one ∘ f = to_one.
Proof.
symmetry.
apply to_one_unique.
Qed.
Lemma one_to_one: @to_one one = id one.
Proof. apply to_one_unique. Qed.
Lemma to_one_eq {a: C} (f g: a ~> one): f = g.
Proof.
transitivity (@to_one a).
symmetry.
all: apply to_one_unique.
Qed.
Lemma one_is_terminal: is_terminal one.
Proof.
intros x.
exists to_one.
apply to_one_unique.
Qed.
End Terminal.
Notation "1" := one.
Notation "!" := to_one.
Lemma terminal_correct C: inhabited (TopCategory.mixin_of C) <-> ex_terminal C.
Proof.
split.
+ intros [[o f Hf]].
exists o.
intros a.
exists (f a).
apply Hf.
+ intros [o H].
apply ex_forall in H.
destruct H as [f Hf].
constructor.
now exists o f.
Qed.
|
#include <random>
#include <functional>
#include <vector>
#include <chrono>
#include <boost/format.hpp>
#include <algorithm>
#include "mpi.h"
#include "array3d.h"
using namespace std;
uniform_real_distribution<double> generator { -10, 10 };
default_random_engine re;
int mpi_rank;
int mpi_size;
const double GB = 1024 * 1024 * 1024;
double dt;
double dtdx;
double dtdy;
double dtdz;
double gen() {
return generator(re);
}
struct vector3d {
double x = 0, y = 0, z = 0;
};
struct vector6d {
double ex = 0, ey = 0, ez = 0, bx = 0, by = 0, bz = 0;
};
template <typename T>
void randomize(T & a) {
int n = a.get_n();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++){
a(i, j, k) = gen();
}
}
}
}
template <typename T>
void randomize_vector(T & a) {
int n = a.get_n();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++){
a(i, j, k).x = gen();
a(i, j, k).y = gen();
a(i, j, k).z = gen();
}
}
}
}
template <typename T>
void randomize_vector6d(T & a) {
int n = a.get_n();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++){
a(i, j, k).ex = gen();
a(i, j, k).ey = gen();
a(i, j, k).ez = gen();
a(i, j, k).bx = gen();
a(i, j, k).by = gen();
a(i, j, k).bz = gen();
}
}
}
}
template <typename T>
void advance_b(const T & ex, const T & ey, const T & ez, T & bx, T & by, T & bz) {
const int n = ex.get_n();
for(int i=1;i<n-1;i++) {
for(int j=1;j<n-1;j++) {
for(int k=1;k<n-1;k++) {
bx(i,j,k) += 0.5*(-dtdy*(ez(i,j+1,k)-ez(i,j,k)) + dtdz*(ey(i,j,k+1)-ey(i,j,k)));
by(i,j,k) += 0.5*( dtdx*(ez(i+1,j,k)-ez(i,j,k)) - dtdz*(ex(i,j,k+1)-ex(i,j,k)));
bz(i,j,k) += 0.5*( dtdy*(ex(i,j+1,k)-ex(i,j,k)) - dtdx*(ey(i+1,j,k)-ey(i,j,k)));
}
}
}
{int i=0;
for(int j=1;j<n-1;j++) {
for(int k=1;k<n-1;k++) {
by(i,j,k) += 0.5*( dtdx*(ez(i+1,j,k)-ez(i,j,k)) - dtdz*(ex(i,j,k+1)-ex(i,j,k)));
bz(i,j,k) += 0.5*( dtdy*(ex(i,j+1,k)-ex(i,j,k)) - dtdx*(ey(i+1,j,k)-ey(i,j,k)));
}
}
}
for(int i=1;i<n-1;i++) {
{int j=0;
for(int k=1;k<n-1;k++) {
bx(i,j,k) += 0.5*(-dtdy*(ez(i,j+1,k)-ez(i,j,k)) + dtdz*(ey(i,j,k+1)-ey(i,j,k)));
bz(i,j,k) += 0.5*( dtdy*(ex(i,j+1,k)-ex(i,j,k)) - dtdx*(ey(i+1,j,k)-ey(i,j,k)));
}
}
}
for(int i=1;i<n-1;i++) {
for(int j=1;j<n-1;j++) {
{int k=0;
bx(i,j,k) += 0.5*(-dtdy*(ez(i,j+1,k)-ez(i,j,k)) + dtdz*(ey(i,j,k+1)-ey(i,j,k)));
by(i,j,k) += 0.5*( dtdx*(ez(i+1,j,k)-ez(i,j,k)) - dtdz*(ex(i,j,k+1)-ex(i,j,k)));
}
}
}
}
void advance_b_z(const morton_array<double> & ex, const morton_array<double> & ey, const morton_array<double> & ez,
morton_array<double> & bx, morton_array<double> & by, morton_array<double> & bz) {
const unsigned int n = ex.get_size();
for (unsigned int curr = 0; curr < n; curr++) {
if (ex.is_xmax(curr) || ex.is_ymax(curr) || ex.is_zmax(curr)) {
continue;
}
auto x_next = ex.get_x_next(curr);
auto y_next = ex.get_y_next(curr);
auto z_next = ex.get_z_next(curr);
if (ex.is_xmin(curr)) {
if (ex.is_ymin(curr) || ex.is_zmin(curr)) {
continue;
} else {
by[curr] += 0.5*( dtdx*(ez[x_next]-ez[curr]) - dtdz*(ex[z_next]-ex[curr]));
bz[curr] += 0.5*( dtdy*(ex[y_next]-ex[curr]) - dtdx*(ey[x_next]-ey[curr]));
}
} else if (ex.is_ymin(curr)) {
if (ex.is_zmin(curr)) {
continue;
} else {
bx[curr] += 0.5*(-dtdy*(ez[y_next]-ez[curr]) + dtdz*(ey[z_next]-ey[curr]));
bz[curr] += 0.5*( dtdy*(ex[y_next]-ex[curr]) - dtdx*(ey[x_next]-ey[curr]));
}
} else if (ex.is_zmin(curr)) {
bx[curr] += 0.5*(-dtdy*(ez[y_next]-ez[curr]) + dtdz*(ey[z_next]-ey[curr]));
by[curr] += 0.5*( dtdx*(ez[x_next]-ez[curr]) - dtdz*(ex[z_next]-ex[curr]));
} else {
bx[curr] += 0.5*(-dtdy*(ez[y_next]-ez[curr]) + dtdz*(ey[z_next]-ey[curr]));
by[curr] += 0.5*( dtdx*(ez[x_next]-ez[curr]) - dtdz*(ex[z_next]-ex[curr]));
bz[curr] += 0.5*( dtdy*(ex[y_next]-ex[curr]) - dtdx*(ey[x_next]-ey[curr]));
}
}
}
template <typename T>
void advance_b_vector(const T & e, T & b) {
const int n = e.get_n();
for(int i=1;i<n-1;i++) {
for(int j=1;j<n-1;j++) {
for(int k=1;k<n-1;k++) {
b(i,j,k).x += 0.5*(-dtdy*(e(i,j+1,k).z-e(i,j,k).z) + dtdz*(e(i,j,k+1).y-e(i,j,k).y));
b(i,j,k).y += 0.5*( dtdx*(e(i+1,j,k).z-e(i,j,k).z) - dtdz*(e(i,j,k+1).x-e(i,j,k).x));
b(i,j,k).z += 0.5*( dtdy*(e(i,j+1,k).x-e(i,j,k).x) - dtdx*(e(i+1,j,k).y-e(i,j,k).y));
}
}
}
{int i=0;
for(int j=1;j<n-1;j++) {
for(int k=1;k<n-1;k++) {
b(i,j,k).y += 0.5*( dtdx*(e(i+1,j,k).z-e(i,j,k).z) - dtdz*(e(i,j,k+1).x-e(i,j,k).x));
b(i,j,k).z += 0.5*( dtdy*(e(i,j+1,k).x-e(i,j,k).x) - dtdx*(e(i+1,j,k).y-e(i,j,k).y));
}
}
}
for(int i=1;i<n-1;i++) {
{int j=0;
for(int k=1;k<n-1;k++) {
b(i,j,k).x += 0.5*(-dtdy*(e(i,j+1,k).z-e(i,j,k).z) + dtdz*(e(i,j,k+1).y-e(i,j,k).y));
b(i,j,k).z += 0.5*( dtdy*(e(i,j+1,k).x-e(i,j,k).x) - dtdx*(e(i+1,j,k).y-e(i,j,k).y));
}
}
}
for(int i=1;i<n-1;i++) {
for(int j=1;j<n-1;j++) {
{int k=0;
b(i,j,k).x += 0.5*(-dtdy*(e(i,j+1,k).z-e(i,j,k).z) + dtdz*(e(i,j,k+1).y-e(i,j,k).y));
b(i,j,k).y += 0.5*( dtdx*(e(i+1,j,k).z-e(i,j,k).z) - dtdz*(e(i,j,k+1).x-e(i,j,k).x));
}
}
}
}
void advance_b_vector_z(const morton_array<vector3d> & e, morton_array<vector3d> & b) {
const unsigned int n = e.get_size();
for (unsigned int curr = 0; curr < n; curr++) {
if (e.is_xmax(curr) || e.is_ymax(curr) || e.is_zmax(curr)) {
continue;
}
auto x_next = e.get_x_next(curr);
auto y_next = e.get_y_next(curr);
auto z_next = e.get_z_next(curr);
if (e.is_xmin(curr)) {
if (e.is_ymin(curr) || e.is_zmin(curr)) {
continue;
} else {
b[curr].y += 0.5*( dtdx*(e[x_next].z-e[curr].z) - dtdz*(e[z_next].x-e[curr].x));
b[curr].z += 0.5*( dtdy*(e[y_next].x-e[curr].x) - dtdx*(e[x_next].y-e[curr].y));
}
} else if (e.is_ymin(curr)) {
if (e.is_zmin(curr)) {
continue;
} else {
b[curr].x += 0.5*(-dtdy*(e[y_next].z-e[curr].z) + dtdz*(e[z_next].y-e[curr].y));
b[curr].z += 0.5*( dtdy*(e[y_next].x-e[curr].x) - dtdx*(e[x_next].y-e[curr].y));
}
} else if (e.is_zmin(curr)) {
b[curr].x += 0.5*(-dtdy*(e[y_next].z-e[curr].z) + dtdz*(e[z_next].y-e[curr].y));
b[curr].y += 0.5*( dtdx*(e[x_next].z-e[curr].z) - dtdz*(e[z_next].x-e[curr].x));
} else {
b[curr].x += 0.5*(-dtdy*(e[y_next].z-e[curr].z) + dtdz*(e[z_next].y-e[curr].y));
b[curr].y += 0.5*( dtdx*(e[x_next].z-e[curr].z) - dtdz*(e[z_next].x-e[curr].x));
b[curr].z += 0.5*( dtdy*(e[y_next].x-e[curr].x) - dtdx*(e[x_next].y-e[curr].y));
}
}
}
template <typename T>
void advance_b_vector_periodic(const T & e, T & b) {
const int n = e.get_n();
for(int i=0;i<n-1;i++) {
for(int j=0;j<n-1;j++) {
for(int k=0;k<n-1;k++) {
b(i,j,k).x += 0.5*(-dtdy*(e(i,j+1,k).z-e(i,j,k).z) + dtdz*(e(i,j,k+1).y-e(i,j,k).y));
b(i,j,k).y += 0.5*( dtdx*(e(i+1,j,k).z-e(i,j,k).z) - dtdz*(e(i,j,k+1).x-e(i,j,k).x));
b(i,j,k).z += 0.5*( dtdy*(e(i,j+1,k).x-e(i,j,k).x) - dtdx*(e(i+1,j,k).y-e(i,j,k).y));
}
const int k = n-1;
b(i,j,k).x += 0.5*(-dtdy*(e(i,j+1,k).z-e(i,j,k).z) + dtdz*(e(i,j,0).y-e(i,j,k).y));
b(i,j,k).y += 0.5*( dtdx*(e(i+1,j,k).z-e(i,j,k).z) - dtdz*(e(i,j,0).x-e(i,j,k).x));
b(i,j,k).z += 0.5*( dtdy*(e(i,j+1,k).x-e(i,j,k).x) - dtdx*(e(i+1,j,k).y-e(i,j,k).y));
}
const int j = n-1;
for(int k=0;k<n-1;k++) {
b(i,j,k).x += 0.5*(-dtdy*(e(i,0,k).z-e(i,j,k).z) + dtdz*(e(i,j,k+1).y-e(i,j,k).y));
b(i,j,k).y += 0.5*( dtdx*(e(i+1,j,k).z-e(i,j,k).z) - dtdz*(e(i,j,k+1).x-e(i,j,k).x));
b(i,j,k).z += 0.5*( dtdy*(e(i,0,k).x-e(i,j,k).x) - dtdx*(e(i+1,j,k).y-e(i,j,k).y));
}
const int k = n-1;
b(i,j,k).x += 0.5*(-dtdy*(e(i,0,k).z-e(i,j,k).z) + dtdz*(e(i,j,0).y-e(i,j,k).y));
b(i,j,k).y += 0.5*( dtdx*(e(i+1,j,k).z-e(i,j,k).z) - dtdz*(e(i,j,0).x-e(i,j,k).x));
b(i,j,k).z += 0.5*( dtdy*(e(i,0,k).x-e(i,j,k).x) - dtdx*(e(i+1,j,k).y-e(i,j,k).y));
}
const int i = n-1;
for(int j=0;j<n-1;j++) {
for(int k=0;k<n-1;k++) {
b(i,j,k).x += 0.5*(-dtdy*(e(i,j+1,k).z-e(i,j,k).z) + dtdz*(e(i,j,k+1).y-e(i,j,k).y));
b(i,j,k).y += 0.5*( dtdx*(e(0,j,k).z-e(i,j,k).z) - dtdz*(e(i,j,k+1).x-e(i,j,k).x));
b(i,j,k).z += 0.5*( dtdy*(e(i,j+1,k).x-e(i,j,k).x) - dtdx*(e(0,j,k).y-e(i,j,k).y));
}
const int k = n-1;
b(i,j,k).x += 0.5*(-dtdy*(e(i,j+1,k).z-e(i,j,k).z) + dtdz*(e(i,j,0).y-e(i,j,k).y));
b(i,j,k).y += 0.5*( dtdx*(e(0,j,k).z-e(i,j,k).z) - dtdz*(e(i,j,0).x-e(i,j,k).x));
b(i,j,k).z += 0.5*( dtdy*(e(i,j+1,k).x-e(i,j,k).x) - dtdx*(e(0,j,k).y-e(i,j,k).y));
}
const int j = n-1;
for(int k=0;k<n-1;k++) {
b(i,j,k).x += 0.5*(-dtdy*(e(i,0,k).z-e(i,j,k).z) + dtdz*(e(i,j,k+1).y-e(i,j,k).y));
b(i,j,k).y += 0.5*( dtdx*(e(0,j,k).z-e(i,j,k).z) - dtdz*(e(i,j,k+1).x-e(i,j,k).x));
b(i,j,k).z += 0.5*( dtdy*(e(i,0,k).x-e(i,j,k).x) - dtdx*(e(0,j,k).y-e(i,j,k).y));
}
const int k = n-1;
b(i,j,k).x += 0.5*(-dtdy*(e(i,0,k).z-e(i,j,k).z) + dtdz*(e(i,j,0).y-e(i,j,k).y));
b(i,j,k).y += 0.5*( dtdx*(e(0,j,k).z-e(i,j,k).z) - dtdz*(e(i,j,0).x-e(i,j,k).x));
b(i,j,k).z += 0.5*( dtdy*(e(i,0,k).x-e(i,j,k).x) - dtdx*(e(0,j,k).y-e(i,j,k).y));
}
void advance_b_vector_z_periodic(const morton_array<vector3d> & e, morton_array<vector3d> & b) {
const unsigned int n = e.get_size();
for (unsigned int curr = 0; curr < n; curr++) {
auto x_next = e.get_x_next(curr);
auto y_next = e.get_y_next(curr);
auto z_next = e.get_z_next(curr);
b[curr].x += 0.5*(-dtdy*(e[y_next].z-e[curr].z) + dtdz*(e[z_next].y-e[curr].y));
b[curr].y += 0.5*( dtdx*(e[x_next].z-e[curr].z) - dtdz*(e[z_next].x-e[curr].x));
b[curr].z += 0.5*( dtdy*(e[y_next].x-e[curr].x) - dtdx*(e[x_next].y-e[curr].y));
}
}
template <typename T>
void advance_b_vector6d(const T & v) {
const int n = v.get_n();
for(int i=1;i<n-1;i++) {
for(int j=1;j<n-1;j++) {
for(int k=1;k<n-1;k++) {
v(i,j,k).bx += 0.5*(-dtdy*(v(i,j+1,k).ez-v(i,j,k).ez) + dtdz*(v(i,j,k+1).ey-v(i,j,k).ey));
v(i,j,k).by += 0.5*( dtdx*(v(i+1,j,k).ez-v(i,j,k).ez) - dtdz*(v(i,j,k+1).ex-v(i,j,k).ex));
v(i,j,k).bz += 0.5*( dtdy*(v(i,j+1,k).ex-v(i,j,k).ex) - dtdx*(v(i+1,j,k).ey-v(i,j,k).ey));
}
}
}
{int i=0;
for(int j=1;j<n-1;j++) {
for(int k=1;k<n-1;k++) {
v(i,j,k).by += 0.5*( dtdx*(v(i+1,j,k).ez-v(i,j,k).ez) - dtdz*(v(i,j,k+1).ex-v(i,j,k).ex));
v(i,j,k).bz += 0.5*( dtdy*(v(i,j+1,k).ex-v(i,j,k).ex) - dtdx*(v(i+1,j,k).ey-v(i,j,k).ey));
}
}
}
for(int i=1;i<n-1;i++) {
{int j=0;
for(int k=1;k<n-1;k++) {
v(i,j,k).bx += 0.5*(-dtdy*(v(i,j+1,k).ez-v(i,j,k).ez) + dtdz*(v(i,j,k+1).ey-v(i,j,k).ey));
v(i,j,k).bz += 0.5*( dtdy*(v(i,j+1,k).ex-v(i,j,k).ex) - dtdx*(v(i+1,j,k).ey-v(i,j,k).ey));
}
}
}
for(int i=1;i<n-1;i++) {
for(int j=1;j<n-1;j++) {
{int k=0;
v(i,j,k).bx += 0.5*(-dtdy*(v(i,j+1,k).ez-v(i,j,k).ez) + dtdz*(v(i,j,k+1).ey-v(i,j,k).ey));
v(i,j,k).by += 0.5*( dtdx*(v(i+1,j,k).ez-v(i,j,k).ez) - dtdz*(v(i,j,k+1).ex-v(i,j,k).ex));
}
}
}
}
void advance_b_vector6d_z(const morton_array<vector6d> & v) {
const unsigned int n = v.get_size();
for (unsigned int curr = 0; curr < n; curr++) {
if (v.is_xmax(curr) || v.is_ymax(curr) || v.is_zmax(curr)) {
continue;
}
auto x_next = v.get_x_next(curr);
auto y_next = v.get_y_next(curr);
auto z_next = v.get_z_next(curr);
if (v.is_xmin(curr)) {
if (v.is_ymin(curr) || v.is_zmin(curr)) {
continue;
} else {
v[curr].by += 0.5*( dtdx*(v[x_next].ez-v[curr].ez) - dtdz*(v[z_next].ex-v[curr].ex));
v[curr].bz += 0.5*( dtdy*(v[y_next].ex-v[curr].ex) - dtdx*(v[x_next].ey-v[curr].ey));
}
} else if (v.is_ymin(curr)) {
if (v.is_zmin(curr)) {
continue;
} else {
v[curr].bx += 0.5*(-dtdy*(v[y_next].ez-v[curr].ez) + dtdz*(v[z_next].ey-v[curr].ey));
v[curr].bz += 0.5*( dtdy*(v[y_next].ex-v[curr].ex) - dtdx*(v[x_next].ey-v[curr].ey));
}
} else if (v.is_zmin(curr)) {
v[curr].bx += 0.5*(-dtdy*(v[y_next].ez-v[curr].ez) + dtdz*(v[z_next].ey-v[curr].ey));
v[curr].by += 0.5*( dtdx*(v[x_next].ez-v[curr].ez) - dtdz*(v[z_next].ex-v[curr].ex));
} else {
v[curr].bx += 0.5*(-dtdy*(v[y_next].ez-v[curr].ez) + dtdz*(v[z_next].ey-v[curr].ey));
v[curr].by += 0.5*( dtdx*(v[x_next].ez-v[curr].ez) - dtdz*(v[z_next].ex-v[curr].ex));
v[curr].bz += 0.5*( dtdy*(v[y_next].ex-v[curr].ex) - dtdx*(v[x_next].ey-v[curr].ey));
}
}
}
template <typename T>
void advance_e(T & ex, T & ey, T & ez, const T & bx, const T & by, const T & bz) {
const int n = ex.get_n();
for(int i=1;i<n-1;i++) {
for(int j=1;j<n-1;j++) {
for(int k=1;k<n-1;k++) {
ex(i,j,k) += dtdy*(bz(i,j,k)-bz(i,j-1,k)) - dtdz*(by(i,j,k)-by(i,j,k-1));
ey(i,j,k) += -dtdx*(bz(i,j,k)-bz(i-1,j,k)) + dtdz*(bx(i,j,k)-bx(i,j,k-1));
ez(i,j,k) += dtdx*(by(i,j,k)-by(i-1,j,k)) - dtdy*(bx(i,j,k)-bx(i,j-1,k));
}
}
}
{int i=0;
for(int j=1;j<n-1;j++) {
for(int k=1;k<n-1;k++) {
ex(i,j,k) += dtdy*(bz(i,j,k)-bz(i,j-1,k)) - dtdz*(by(i,j,k)-by(i,j,k-1));
}
}
}
for(int i=1;i<n-1;i++) {
{int j=0;
for(int k=1;k<n-1;k++) {
ey(i,j,k) += -dtdx*(bz(i,j,k)-bz(i-1,j,k)) + dtdz*(bx(i,j,k)-bx(i,j,k-1));
}
}
}
for(int i=1;i<n-1;i++) {
for(int j=1;j<n-1;j++) {
{int k=0;
ez(i,j,k) += dtdx*(by(i,j,k)-by(i-1,j,k)) - dtdy*(bx(i,j,k)-bx(i,j-1,k));
}
}
}
}
void advance_e_z(morton_array<double> & ex, morton_array<double> & ey, morton_array<double> & ez,
const morton_array<double> & bx, const morton_array<double> & by, const morton_array<double> & bz) {
const unsigned int n = ex.get_size();
for (unsigned int curr = 0; curr < n; curr++) {
if (ex.is_xmax(curr) || ex.is_ymax(curr) || ex.is_zmax(curr)) {
continue;
}
auto x_prev = ex.get_x_prev(curr);
auto y_prev = ex.get_y_prev(curr);
auto z_prev = ex.get_z_prev(curr);
if (ex.is_xmin(curr)) {
if (ex.is_ymin(curr) || ex.is_zmin(curr)) {
continue;
} else {
ex[curr] += dtdy*(bz[curr]-bz[y_prev]) - dtdz*(by[curr]-by[z_prev]);
}
} else if (ex.is_ymin(curr)) {
if (ex.is_zmin(curr)) {
continue;
} else {
ey[curr] += -dtdx*(bz[curr]-bz[x_prev]) + dtdz*(bx[curr]-bx[z_prev]);
}
} else if (ex.is_zmin(curr)) {
ez[curr] += dtdx*(by[curr]-by[x_prev]) - dtdy*(bx[curr]-bx[y_prev]);
} else {
ex[curr] += dtdy*(bz[curr]-bz[y_prev]) - dtdz*(by[curr]-by[z_prev]);
ey[curr] += -dtdx*(bz[curr]-bz[x_prev]) + dtdz*(bx[curr]-bx[z_prev]);
ez[curr] += dtdx*(by[curr]-by[x_prev]) - dtdy*(bx[curr]-bx[y_prev]);
}
}
}
template <typename T>
void advance_e_vector(T & e, const T & b) {
const int n = e.get_n();
for(int i=1;i<n-1;i++) {
for(int j=1;j<n-1;j++) {
for(int k=1;k<n-1;k++) {
e(i,j,k).x += dtdy*(b(i,j,k).z-b(i,j-1,k).z) - dtdz*(b(i,j,k).y-b(i,j,k-1).y);
e(i,j,k).y += -dtdx*(b(i,j,k).z-b(i-1,j,k).z) + dtdz*(b(i,j,k).x-b(i,j,k-1).x);
e(i,j,k).z += dtdx*(b(i,j,k).y-b(i-1,j,k).y) - dtdy*(b(i,j,k).x-b(i,j-1,k).x);
}
}
}
{int i=0;
for(int j=1;j<n-1;j++) {
for(int k=1;k<n-1;k++) {
e(i,j,k).x += dtdy*(b(i,j,k).z-b(i,j-1,k).z) - dtdz*(b(i,j,k).y-b(i,j,k-1).y);
}
}
}
for(int i=1;i<n-1;i++) {
{int j=0;
for(int k=1;k<n-1;k++) {
e(i,j,k).y += -dtdx*(b(i,j,k).z-b(i-1,j,k).z) + dtdz*(b(i,j,k).x-b(i,j,k-1).x);
}
}
}
for(int i=1;i<n-1;i++) {
for(int j=1;j<n-1;j++) {
{int k=0;
e(i,j,k).z += dtdx*(b(i,j,k).y-b(i-1,j,k).y) - dtdy*(b(i,j,k).x-b(i,j-1,k).x);
}
}
}
}
void advance_e_vector_z(morton_array<vector3d> & e, const morton_array<vector3d> & b) {
const unsigned int n = e.get_size();
for (unsigned int curr = 0; curr < n; curr++) {
if (e.is_xmax(curr) || e.is_ymax(curr) || e.is_zmax(curr)) {
continue;
}
auto x_prev = e.get_x_prev(curr);
auto y_prev = e.get_y_prev(curr);
auto z_prev = e.get_z_prev(curr);
if (e.is_xmin(curr)) {
if (e.is_ymin(curr) || e.is_zmin(curr)) {
continue;
} else {
e[curr].x += dtdy*(b[curr].z-b[y_prev].z) - dtdz*(b[curr].y-b[z_prev].y);
}
} else if (e.is_ymin(curr)) {
if (e.is_zmin(curr)) {
continue;
} else {
e[curr].y += -dtdx*(b[curr].z-b[x_prev].z) + dtdz*(b[curr].x-b[z_prev].x);
}
} else if (e.is_zmin(curr)) {
e[curr].z += dtdx*(b[curr].y-b[x_prev].y) - dtdy*(b[curr].x-b[y_prev].x);
} else {
e[curr].x += dtdy*(b[curr].z-b[y_prev].z) - dtdz*(b[curr].y-b[z_prev].y);
e[curr].y += -dtdx*(b[curr].z-b[x_prev].z) + dtdz*(b[curr].x-b[z_prev].x);
e[curr].z += dtdx*(b[curr].y-b[x_prev].y) - dtdy*(b[curr].x-b[y_prev].x);
}
}
}
template <typename T>
void advance_e_vector_periodic(T & e, const T & b) {
const int n = e.get_n();
for(int i=1;i<n;i++) {
for(int j=1;j<n;j++) {
for(int k=1;k<n;k++) {
e(i,j,k).x += dtdy*(b(i,j,k).z-b(i,j-1,k).z) - dtdz*(b(i,j,k).y-b(i,j,k-1).y);
e(i,j,k).y += -dtdx*(b(i,j,k).z-b(i-1,j,k).z) + dtdz*(b(i,j,k).x-b(i,j,k-1).x);
e(i,j,k).z += dtdx*(b(i,j,k).y-b(i-1,j,k).y) - dtdy*(b(i,j,k).x-b(i,j-1,k).x);
}
const int k = 0;
e(i,j,k).x += dtdy*(b(i,j,k).z-b(i,j-1,k).z) - dtdz*(b(i,j,k).y-b(i,j,n-1).y);
e(i,j,k).y += -dtdx*(b(i,j,k).z-b(i-1,j,k).z) + dtdz*(b(i,j,k).x-b(i,j,n-1).x);
e(i,j,k).z += dtdx*(b(i,j,k).y-b(i-1,j,k).y) - dtdy*(b(i,j,k).x-b(i,j-1,k).x);
}
const int j = 0;
for(int k=1;k<n;k++) {
e(i,j,k).x += dtdy*(b(i,j,k).z-b(i,n-1,k).z) - dtdz*(b(i,j,k).y-b(i,j,k-1).y);
e(i,j,k).y += -dtdx*(b(i,j,k).z-b(i-1,j,k).z) + dtdz*(b(i,j,k).x-b(i,j,k-1).x);
e(i,j,k).z += dtdx*(b(i,j,k).y-b(i-1,j,k).y) - dtdy*(b(i,j,k).x-b(i,n-1,k).x);
}
const int k = 0;
e(i,j,k).x += dtdy*(b(i,j,k).z-b(i,n-1,k).z) - dtdz*(b(i,j,k).y-b(i,j,n-1).y);
e(i,j,k).y += -dtdx*(b(i,j,k).z-b(i-1,j,k).z) + dtdz*(b(i,j,k).x-b(i,j,n-1).x);
e(i,j,k).z += dtdx*(b(i,j,k).y-b(i-1,j,k).y) - dtdy*(b(i,j,k).x-b(i,n-1,k).x);
}
const int i = 0;
for(int j=1;j<n;j++) {
for(int k=1;k<n;k++) {
e(i,j,k).x += dtdy*(b(i,j,k).z-b(i,j-1,k).z) - dtdz*(b(i,j,k).y-b(i,j,k-1).y);
e(i,j,k).y += -dtdx*(b(i,j,k).z-b(n-1,j,k).z) + dtdz*(b(i,j,k).x-b(i,j,k-1).x);
e(i,j,k).z += dtdx*(b(i,j,k).y-b(n-1,j,k).y) - dtdy*(b(i,j,k).x-b(i,j-1,k).x);
}
const int k = 0;
e(i,j,k).x += dtdy*(b(i,j,k).z-b(i,j-1,k).z) - dtdz*(b(i,j,k).y-b(i,j,n-1).y);
e(i,j,k).y += -dtdx*(b(i,j,k).z-b(n-1,j,k).z) + dtdz*(b(i,j,k).x-b(i,j,n-1).x);
e(i,j,k).z += dtdx*(b(i,j,k).y-b(n-1,j,k).y) - dtdy*(b(i,j,k).x-b(i,j-1,k).x);
}
const int j = 0;
for(int k=1;k<n;k++) {
e(i,j,k).x += dtdy*(b(i,j,k).z-b(i,n-1,k).z) - dtdz*(b(i,j,k).y-b(i,j,k-1).y);
e(i,j,k).y += -dtdx*(b(i,j,k).z-b(n-1,j,k).z) + dtdz*(b(i,j,k).x-b(i,j,k-1).x);
e(i,j,k).z += dtdx*(b(i,j,k).y-b(n-1,j,k).y) - dtdy*(b(i,j,k).x-b(i,n-1,k).x);
}
const int k = 0;
e(i,j,k).x += dtdy*(b(i,j,k).z-b(i,n-1,k).z) - dtdz*(b(i,j,k).y-b(i,j,n-1).y);
e(i,j,k).y += -dtdx*(b(i,j,k).z-b(n-1,j,k).z) + dtdz*(b(i,j,k).x-b(i,j,n-1).x);
e(i,j,k).z += dtdx*(b(i,j,k).y-b(n-1,j,k).y) - dtdy*(b(i,j,k).x-b(i,n-1,k).x);
}
void advance_e_vector_z_periodic(morton_array<vector3d> & e, const morton_array<vector3d> & b) {
const unsigned int n = e.get_size();
for (unsigned int curr = 0; curr < n; curr++) {
auto x_prev = e.get_x_prev(curr);
auto y_prev = e.get_y_prev(curr);
auto z_prev = e.get_z_prev(curr);
e[curr].x += dtdy*(b[curr].z-b[y_prev].z) - dtdz*(b[curr].y-b[z_prev].y);
e[curr].y += -dtdx*(b[curr].z-b[x_prev].z) + dtdz*(b[curr].x-b[z_prev].x);
e[curr].z += dtdx*(b[curr].y-b[x_prev].y) - dtdy*(b[curr].x-b[y_prev].x);
}
}
template <typename T>
void advance_e_vector6d(T & v) {
const int n = v.get_n();
for(int i=1;i<n-1;i++) {
for(int j=1;j<n-1;j++) {
for(int k=1;k<n-1;k++) {
v(i,j,k).ex += dtdy*(v(i,j,k).bz-v(i,j-1,k).bz) - dtdz*(v(i,j,k).by-v(i,j,k-1).by);
v(i,j,k).ey += -dtdx*(v(i,j,k).bz-v(i-1,j,k).bz) + dtdz*(v(i,j,k).bx-v(i,j,k-1).bx);
v(i,j,k).ez += dtdx*(v(i,j,k).by-v(i-1,j,k).by) - dtdy*(v(i,j,k).bx-v(i,j-1,k).bx);
}
}
}
{int i=0;
for(int j=1;j<n-1;j++) {
for(int k=1;k<n-1;k++) {
v(i,j,k).ex += dtdy*(v(i,j,k).bz-v(i,j-1,k).bz) - dtdz*(v(i,j,k).by-v(i,j,k-1).by);
}
}
}
for(int i=1;i<n-1;i++) {
{int j=0;
for(int k=1;k<n-1;k++) {
v(i,j,k).ey += -dtdx*(v(i,j,k).bz-v(i-1,j,k).bz) + dtdz*(v(i,j,k).bx-v(i,j,k-1).bx);
}
}
}
for(int i=1;i<n-1;i++) {
for(int j=1;j<n-1;j++) {
int k=0;
v(i,j,k).ez += dtdx*(v(i,j,k).by-v(i-1,j,k).by) - dtdy*(v(i,j,k).bx-v(i,j-1,k).bx);
}
}
}
void advance_e_vector6d_z(morton_array<vector6d> & v) {
const unsigned int n = v.get_size();
for (unsigned int curr = 0; curr < n; curr++) {
if (v.is_xmax(curr) || v.is_ymax(curr) || v.is_zmax(curr)) {
continue;
}
auto x_prev = v.get_x_prev(curr);
auto y_prev = v.get_y_prev(curr);
auto z_prev = v.get_z_prev(curr);
if (v.is_xmin(curr)) {
if (v.is_ymin(curr) || v.is_zmin(curr)) {
continue;
} else {
v[curr].ex += dtdy*(v[curr].bz-v[y_prev].bz) - dtdz*(v[curr].by-v[z_prev].by);
}
} else if (v.is_ymin(curr)) {
if (v.is_zmin(curr)) {
continue;
} else {
v[curr].ey += -dtdx*(v[curr].bz-v[x_prev].bz) + dtdz*(v[curr].bx-v[z_prev].bx);
}
} else if (v.is_zmin(curr)) {
v[curr].ez += dtdx*(v[curr].by-v[x_prev].by) - dtdy*(v[curr].bx-v[y_prev].bx);
} else {
v[curr].ex += dtdy*(v[curr].bz-v[y_prev].bz) - dtdz*(v[curr].by-v[z_prev].by);
v[curr].ey += -dtdx*(v[curr].bz-v[x_prev].bz) + dtdz*(v[curr].bx-v[z_prev].bx);
v[curr].ez += dtdx*(v[curr].by-v[x_prev].by) - dtdy*(v[curr].bx-v[y_prev].bx);
}
}
}
template <typename T>
void advance(T & ex, T & ey, T & ez, T & bx, T & by, T & bz) {
advance_b(ex, ey, ez, bx, by, bz);
advance_e(ex, ey, ez, bx, by, bz);
advance_b(ex, ey, ez, bx, by, bz);
}
void advance_z(morton_array<double> & ex, morton_array<double> & ey, morton_array<double> & ez,
morton_array<double> & bx, morton_array<double> & by, morton_array<double> & bz) {
advance_b_z(ex, ey, ez, bx, by, bz);
advance_e_z(ex, ey, ez, bx, by, bz);
advance_b_z(ex, ey, ez, bx, by, bz);
}
template <typename T>
void advance_vector(T & e, T & b) {
advance_b_vector(e, b);
advance_e_vector(e, b);
advance_b_vector(e, b);
}
void advance_vector_z(morton_array<vector3d> & e, morton_array<vector3d> & b) {
advance_b_vector_z(e, b);
advance_e_vector_z(e, b);
advance_b_vector_z(e, b);
}
template <typename T>
void advance_vector_periodic(T & e, T & b) {
advance_b_vector_periodic(e, b);
advance_e_vector_periodic(e, b);
advance_b_vector_periodic(e, b);
}
void advance_vector_z_periodic(morton_array<vector3d> & e, morton_array<vector3d> & b) {
advance_b_vector_z_periodic(e, b);
advance_e_vector_z_periodic(e, b);
advance_b_vector_z_periodic(e, b);
}
template <typename T>
void advance_vector6d(T & v) {
advance_b_vector6d(v);
advance_e_vector6d(v);
advance_b_vector6d(v);
}
void advance_vector6d_z(morton_array<vector6d> & v) {
advance_b_vector6d_z(v);
advance_e_vector6d_z(v);
advance_b_vector6d_z(v);
}
template <typename T>
void run_test(std::function<void(T&, T&, T&, T&, T&, T&)> func, const std::string & testname, int size, int iterations=10) {
T ex(size);
T ey(size);
T ez(size);
T bx(size);
T by(size);
T bz(size);
vector<double> times(iterations);
for (int i = 0; i < iterations; i++) {
randomize(ex);
randomize(ey);
randomize(ez);
randomize(bx);
randomize(by);
randomize(bz);
MPI_Barrier(MPI_COMM_WORLD);
chrono::steady_clock::time_point begin = chrono::steady_clock::now();
func(ex, ey, ez, bx, by, bz);
MPI_Barrier(MPI_COMM_WORLD);
chrono::steady_clock::time_point end = chrono::steady_clock::now();
times[i] = chrono::duration_cast<chrono::nanoseconds>(end - begin).count() / 1e6;
}
if (mpi_rank == 0) {
sort(times.begin(), times.end());
times.pop_back();
double avg = accumulate(times.begin(), times.end(), 0.0) / times.size();
double avg_sq = inner_product(times.begin(), times.end(), times.begin(), 0.0) / times.size();
double standard_deviation = sqrt(avg_sq - avg * avg);
double throughput = (6 * static_cast<double>(mpi_size) * size * size * size * sizeof(double)) / GB * 1e3 / avg; // Gb / s
cout << boost::format("%15s ") % testname << boost::format("%5d: ") % size << boost::format("%9.3f ms") % avg
<< boost::format(" (+-%7.3f ms)") % standard_deviation << boost::format(" %5.2f Gb/s") % throughput
<< endl;
}
}
template <typename T>
void run_test_vector(std::function<void(T&, T&)> func, const std::string & testname, int size, int iterations=10) {
T a(size);
T b(size);
vector<double> times(iterations);
for (int i = 0; i < iterations; i++) {
randomize_vector(a);
randomize_vector(b);
MPI_Barrier(MPI_COMM_WORLD);
chrono::steady_clock::time_point begin = chrono::steady_clock::now();
func(a, b);
MPI_Barrier(MPI_COMM_WORLD);
chrono::steady_clock::time_point end = chrono::steady_clock::now();
times[i] = chrono::duration_cast<chrono::nanoseconds>(end - begin).count() / 1e6;
}
if (mpi_rank == 0) {
sort(times.begin(), times.end());
times.pop_back();
double avg = accumulate(times.begin(), times.end(), 0.0) / times.size();
double avg_sq = inner_product(times.begin(), times.end(), times.begin(), 0.0) / times.size();
double standard_deviation = sqrt(avg_sq - avg * avg);
double throughput = (2 * static_cast<double>(mpi_size) * size * size * size * sizeof(vector3d)) / GB * 1e3 / avg; // Gb / s
cout << boost::format("%15s ") % testname << boost::format("%9.3f ms") % avg
<< boost::format(" (+-%7.3f ms)") % standard_deviation << boost::format(" %5.2f Gb/s") % throughput
<< endl;
}
}
template <typename T>
void run_test_vector6d(std::function<void(T&)> func, const std::string & testname, int size, int iterations=10) {
T a(size);
vector<double> times(iterations);
for (int i = 0; i < iterations; i++) {
randomize_vector6d(a);
MPI_Barrier(MPI_COMM_WORLD);
chrono::steady_clock::time_point begin = chrono::steady_clock::now();
func(a);
MPI_Barrier(MPI_COMM_WORLD);
chrono::steady_clock::time_point end = chrono::steady_clock::now();
times[i] = chrono::duration_cast<chrono::nanoseconds>(end - begin).count() / 1e6;
}
if (mpi_rank == 0) {
sort(times.begin(), times.end());
times.pop_back();
double avg = accumulate(times.begin(), times.end(), 0.0) / times.size();
double avg_sq = inner_product(times.begin(), times.end(), times.begin(), 0.0) / times.size();
double standard_deviation = sqrt(avg_sq - avg * avg);
double throughput = (static_cast<double>(mpi_size) * size * size * size * sizeof(vector6d)) / GB * 1e3 / avg; // Gb / s
cout << boost::format("%15s ") % testname << boost::format("%5d: ") % size << boost::format("%9.3f ms") % avg
<< boost::format(" (+-%7.3f ms)") % standard_deviation << boost::format(" %5.2f Gb/s") % throughput
<< endl;
}
}
template <typename T, typename V>
bool is_equal(T & a, V & b) {
int n = a.get_n();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (std::fabs(b(i, j, k) - a(i, j, k)) > 1e-6) return false;
}
}
}
return true;
}
template <typename T, typename V>
bool is_equal_vector(T & a, V & b) {
int n = a.get_n();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (std::fabs(b(i, j, k).x - a(i, j, k).x) > 1e-6) return false;
if (std::fabs(b(i, j, k).y - a(i, j, k).y) > 1e-6) return false;
if (std::fabs(b(i, j, k).z - a(i, j, k).z) > 1e-6) return false;
}
}
}
return true;
}
template <typename T, typename V>
bool is_equal_vector6d(T & a, V & b) {
int n = a.get_n();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (std::fabs(b(i, j, k).ex - a(i, j, k).ex) > 1e-6) return false;
if (std::fabs(b(i, j, k).ey - a(i, j, k).ey) > 1e-6) return false;
if (std::fabs(b(i, j, k).ez - a(i, j, k).ez) > 1e-6) return false;
if (std::fabs(b(i, j, k).bx - a(i, j, k).bx) > 1e-6) return false;
if (std::fabs(b(i, j, k).by - a(i, j, k).by) > 1e-6) return false;
if (std::fabs(b(i, j, k).bz - a(i, j, k).bz) > 1e-6) return false;
}
}
}
return true;
}
void run_checks(int size) {
cout << "Checking size " << size << "..." << endl;
{
// ordinary checks
morton_array<double> ex1(size);
morton_array<double> ey1(size);
morton_array<double> ez1(size);
morton_array<double> bx1(size);
morton_array<double> by1(size);
morton_array<double> bz1(size);
morton_array<double> ex2(size);
morton_array<double> ey2(size);
morton_array<double> ez2(size);
morton_array<double> bx2(size);
morton_array<double> by2(size);
morton_array<double> bz2(size);
randomize(ex1);
randomize(ey1);
randomize(ez1);
ex2 = ex1;
ey2 = ey1;
ez2 = ez1;
randomize(bx1);
randomize(by1);
randomize(bz1);
bx2 = bx1;
by2 = by1;
bz2 = bz1;
advance_b(ex1, ey1, ez1, bx1, by1, bz1);
advance_b_z(ex2, ey2, ez2, bx2, by2, bz2);
if (!is_equal(bx1, bx2) || !is_equal(by1, by2) || !is_equal(bz1, bz2))
cout << "advance_b_z is different" << endl;
randomize(ex1);
randomize(ey1);
randomize(ez1);
ex2 = ex1;
ey2 = ey1;
ez2 = ez1;
randomize(bx1);
randomize(by1);
randomize(bz1);
bx2 = bx1;
by2 = by1;
bz2 = bz1;
advance_e(ex1, ey1, ez1, bx1, by1, bz1);
advance_e_z(ex2, ey2, ez2, bx2, by2, bz2);
if (!is_equal(ex1, ex2) || !is_equal(ey1, ey2) || !is_equal(ez1, ez2))
cout << "advance_e_z is different" << endl;
randomize(ex1);
randomize(ey1);
randomize(ez1);
ex2 = ex1;
ey2 = ey1;
ez2 = ez1;
randomize(bx1);
randomize(by1);
randomize(bz1);
bx2 = bx1;
by2 = by1;
bz2 = bz1;
advance(ex1, ey1, ez1, bx1, by1, bz1);
advance_z(ex2, ey2, ez2, bx2, by2, bz2);
if (!is_equal(ex1, ex2) || !is_equal(ey1, ey2) || !is_equal(ez1, ez2)
|| !is_equal(bx1, bx2) || !is_equal(by1, by2) || !is_equal(bz1, bz2))
cout << "advance_z is different" << endl;
}
{
// vector3d checks
morton_array<vector3d> e1(size);
morton_array<vector3d> e2(size);
morton_array<vector3d> b1(size);
morton_array<vector3d> b2(size);
randomize_vector(e1);
e2 = e1;
randomize_vector(b1);
b2 = b1;
advance_b_vector(e1, b1);
advance_b_vector_z(e2, b2);
if (!is_equal_vector(b1, b2)) cout << "advance_b_vector_z is different" << endl;
randomize_vector(e1);
e2 = e1;
randomize_vector(b1);
b2 = b1;
advance_e_vector(e1, b1);
advance_e_vector_z(e2, b2);
if (!is_equal_vector(e1, e2)) cout << "advance_e_vector_z is different" << endl;
randomize_vector(e1);
e2 = e1;
randomize_vector(b1);
b2 = b1;
advance_vector(e1, b1);
advance_vector_z(e2, b2);
if (!is_equal_vector(e1, e2) || !is_equal_vector(b1, b2)) cout << "advance_vector_z is different" << endl;
randomize_vector(e1);
e2 = e1;
randomize_vector(b1);
b2 = b1;
advance_b_vector_periodic(e1, b1);
advance_b_vector_z_periodic(e2, b2);
if (!is_equal_vector(b1, b2)) cout << "advance_b_vector_z_periodic is different" << endl;
randomize_vector(e1);
e2 = e1;
randomize_vector(b1);
b2 = b1;
advance_e_vector_periodic(e1, b1);
advance_e_vector_z_periodic(e2, b2);
if (!is_equal_vector(e1, e2)) cout << "advance_e_vector_z_periodic is different" << endl;
randomize_vector(e1);
e2 = e1;
randomize_vector(b1);
b2 = b1;
advance_vector_periodic(e1, b1);
advance_vector_z_periodic(e2, b2);
if (!is_equal_vector(e1, e2) || !is_equal_vector(b1, b2)) cout << "advance_vector_z_periodic is different" << endl;
}
{
// vector6d checks
morton_array<vector6d> v1(size);
morton_array<vector6d> v2(size);
randomize_vector6d(v1);
v2 = v1;
advance_b_vector6d(v1);
advance_b_vector6d_z(v2);
if (!is_equal_vector6d(v1, v2)) cout << "advance_b_vector6d_z is different" << endl;
randomize_vector6d(v1);
v2 = v1;
advance_e_vector6d(v1);
advance_e_vector6d_z(v2);
if (!is_equal_vector6d(v1, v2)) cout << "advance_e_vector6d_z is different" << endl;
randomize_vector6d(v1);
v2 = v1;
advance_vector6d(v1);
advance_vector6d_z(v2);
if (!is_equal_vector6d(v1, v2)) cout << "advance_vector6d_z is different" << endl;
}
}
template <typename T>
void print_array_vector(T& a) {
int n = a.get_n();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
cout << boost::format("[%6.2f,%6.2f,%6.2f]") % a(i, j, k).x % a(i, j, k).y % a(i, j, k).z;
}
cout << endl;
}
cout << endl;
}
}
int main(int argc, char **argv) {
dt = 0.01;
double dx = 0.05;
double dy = 0.05;
double dz = 0.05;
dtdx = dt / dx;
dtdy = dt / dy;
dtdz = dt / dz;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
re.seed(chrono::system_clock::now().time_since_epoch().count());
const int iterations = 6;
vector<int> sizes = {32, 64, 128, 256, 512};
if (argc > 1) {
sizes.erase(sizes.begin(), sizes.end());
for (int i = 1; i < argc; i++) {
sizes.push_back(atoi(argv[i]));
}
}
if (mpi_rank == 0) {
cout << "Sizes:";
for (auto size : sizes) {
cout << " " << size;
}
cout << endl;
}
if (mpi_rank == 0) {
for (auto size : sizes) {
run_checks(size);
}
}
for (auto size : sizes) {
if (mpi_rank == 0) {
cout << "Size " << size << endl;
cout << endl;
}
if (mpi_rank == 0) {
cout << "scalar" << endl;
}
run_test<simple_array<double>>(advance_b<simple_array<double>>, "simple(b)", size, iterations);
run_test<cached_array<double>>(advance_b<cached_array<double>>, "cached(b)", size, iterations);
run_test<morton_array<double>>(advance_b<morton_array<double>>, "morton_bad(b)", size, iterations);
run_test<morton_array<double>>(advance_b_z, "morton(b)", size, iterations);
run_test<simple_array<double>>(advance_e<simple_array<double>>, "simple(e)", size, iterations);
run_test<cached_array<double>>(advance_e<cached_array<double>>, "cached(e)", size, iterations);
run_test<morton_array<double>>(advance_e<morton_array<double>>, "morton_bad(e)", size, iterations);
run_test<morton_array<double>>(advance_e_z, "morton(e)", size, iterations);
run_test<simple_array<double>>(advance<simple_array<double>>, "simple", size, iterations);
run_test<cached_array<double>>(advance<cached_array<double>>, "cached", size, iterations);
run_test<morton_array<double>>(advance<morton_array<double>>, "morton_bad", size, iterations);
run_test<morton_array<double>>(advance_z, "morton", size, iterations);
if (mpi_rank == 0) {
cout << "vector 3d" << endl;
}
run_test_vector<simple_array<vector3d>>(advance_b_vector<simple_array<vector3d>>, "simple(b)", size, iterations);
run_test_vector<cached_array<vector3d>>(advance_b_vector<cached_array<vector3d>>, "cached(b)", size, iterations);
run_test_vector<morton_array<vector3d>>(advance_b_vector<morton_array<vector3d>>, "morton_bad(b)", size, iterations);
run_test_vector<morton_array<vector3d>>(advance_b_vector_z, "morton(b)", size, iterations);
run_test_vector<simple_array<vector3d>>(advance_e_vector<simple_array<vector3d>>, "simple(e)", size, iterations);
run_test_vector<cached_array<vector3d>>(advance_e_vector<cached_array<vector3d>>, "cached(e)", size, iterations);
run_test_vector<morton_array<vector3d>>(advance_e_vector<morton_array<vector3d>>, "morton_bad(e)", size, iterations);
run_test_vector<morton_array<vector3d>>(advance_e_vector_z, "morton(e)", size, iterations);
run_test_vector<simple_array<vector3d>>(advance_vector<simple_array<vector3d>>, "simple", size, iterations);
run_test_vector<cached_array<vector3d>>(advance_vector<cached_array<vector3d>>, "cached", size, iterations);
run_test_vector<morton_array<vector3d>>(advance_vector<morton_array<vector3d>>, "morton_bad", size, iterations);
run_test_vector<morton_array<vector3d>>(advance_vector_z, "morton", size, iterations);
run_test_vector<simple_array<vector3d>>(advance_vector_periodic<simple_array<vector3d>>, "simple_p", size, iterations);
run_test_vector<cached_array<vector3d>>(advance_vector_periodic<cached_array<vector3d>>, "cached_p", size, iterations);
run_test_vector<morton_array<vector3d>>(advance_vector_periodic<morton_array<vector3d>>, "morton_bad_p", size, iterations);
run_test_vector<morton_array<vector3d>>(advance_vector_z_periodic, "morton_p", size, iterations);
if (mpi_rank == 0) {
cout << "vector 6d" << endl;
}
run_test_vector6d<simple_array<vector6d>>(advance_b_vector6d<simple_array<vector6d>>, "simple(b)", size, iterations);
run_test_vector6d<cached_array<vector6d>>(advance_b_vector6d<cached_array<vector6d>>, "cached(b)", size, iterations);
run_test_vector6d<morton_array<vector6d>>(advance_b_vector6d<morton_array<vector6d>>, "morton_bad(b)", size, iterations);
run_test_vector6d<morton_array<vector6d>>(advance_b_vector6d_z, "morton(b)", size, iterations);
run_test_vector6d<simple_array<vector6d>>(advance_e_vector6d<simple_array<vector6d>>, "simple(e)", size, iterations);
run_test_vector6d<cached_array<vector6d>>(advance_e_vector6d<cached_array<vector6d>>, "cached(e)", size, iterations);
run_test_vector6d<morton_array<vector6d>>(advance_e_vector6d<morton_array<vector6d>>, "morton_bad(e)", size, iterations);
run_test_vector6d<morton_array<vector6d>>(advance_e_vector6d_z, "morton(e)", size, iterations);
run_test_vector6d<simple_array<vector6d>>(advance_vector6d<simple_array<vector6d>>, "simple", size, iterations);
run_test_vector6d<cached_array<vector6d>>(advance_vector6d<cached_array<vector6d>>, "cached", size, iterations);
run_test_vector6d<morton_array<vector6d>>(advance_vector6d<morton_array<vector6d>>, "morton_bad", size, iterations);
run_test_vector6d<morton_array<vector6d>>(advance_vector6d_z, "morton", size, iterations);
}
MPI_Finalize();
return 0;
}
|
using LinearAlgebraicRepresentation
LAR = LinearAlgebraicRepresentation
using ViewerGL,SparseArrays
GL = ViewerGL
function svgarrangement(filename)
V, EV = LAR.svg2lar(filename)
GL.VIEW([ GL.GLLines(V,EV) ])
model = Lar.Model(V)
Lar.addModelCells!(model, 1, EV)
model = Lar.Arrangement.planar_arrangement(model)
bicon_comps = Lar.Arrangement.biconnected_components(model.T[1])
# visualization of component graphs
EV = LAR.cop2lar(model.T[1])
V, EVs = LAR.biconnectedComponent((model.G, EV::LAR.Cells)) # 2-connected components
VV = [[k] for k = 1 : size(V,2)]
meshes = [ GL.numbering(.1)((V, (VV,EVs[k])), GL.COLORS[k],1) for k=1:length(EVs) ]
GL.VIEW( cat(meshes) );
# final solid visualizations
FE = [SparseArrays.findnz(model.T[2][k,:])[1] for k=1:size(model.T[2],1)]
FV = [collect(Set(cat([EV[e] for e in FE[f]]))) for f=1:length(FE)]
EVs = Lar.FV2EVs(model)
FVs = Lar.triangulate2D(model)
GL.VIEW(GL.GLExplode(model.G, FVs, 1.2, 1.2, 1.2, 99, 1));
GL.VIEW(GL.GLExplode(model.G, FVs, 1, 1, 1, 99, 1));
GL.VIEW(GL.GLExplode(model.G, EVs, 1, 1, 1, 99, 1));
end
|
Formal statement is: lemma cone_hull_eq: "cone hull S = S \<longleftrightarrow> cone S" Informal statement is: The cone hull of a set $S$ is equal to $S$ if and only if $S$ is a cone. |
Someday you may want to change the antifreeze in the Universal M25 diesel, or like me, you HAVE to drain it because you are going to replace the exhaust riser.
BTW - what's that small hose coming out of the manifold under the coolant cap? That's the overflow hose for the manifold. On Reality Check, this hose is routed down the side of the engine and ends up in the bilge under the galley sink. There isn't a coolant recovery tank, never has been, and there has never been antifreeze anywhere it didn't belong (in the manifold).
Hey look! The petcock handle is facing forward, in line with the hole where the antifreeze comes out! Yes, that is the closed position.
I can open and close the petcock by pushing it with my thumb. Some people use pliers.
One cup isn't going to hold all the antifreeze in the manifold!
Fill up cup, close petcock, dump antifreeze in container for disposal, repeat.
What next? What about getting the antifreeze back into the manifold?
Taking off the heat exchanger is pretty common and you have to drain the coolant to do that... the next step after removing and re-installing the the heat exchanger is refilling the manifold with antifreeze and bleeding the cooling system.
Most marinas have a recycling area for disposal of old fuel and oil. Antifreeze, no. Check Earth911.com for recycling centers for antifreeze near you. |
-- The SIP applied to groups
{-# OPTIONS --safe #-}
module Cubical.Algebra.Group.GroupPath where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Equiv.HalfAdjoint
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Transport
open import Cubical.Foundations.Univalence
open import Cubical.Foundations.SIP
open import Cubical.Foundations.Function using (_∘_)
open import Cubical.Foundations.GroupoidLaws hiding (assoc)
open import Cubical.Data.Sigma
open import Cubical.Displayed.Base
open import Cubical.Displayed.Auto
open import Cubical.Displayed.Record
open import Cubical.Displayed.Universe
open import Cubical.Algebra.Semigroup
open import Cubical.Algebra.Monoid
open import Cubical.Algebra.Group.Base
open import Cubical.Algebra.Group.Properties
open import Cubical.Algebra.Group.Morphisms
open import Cubical.Algebra.Group.MorphismProperties
private
variable
ℓ ℓ' ℓ'' : Level
open Iso
open GroupStr
open IsGroupHom
𝒮ᴰ-Group : DUARel (𝒮-Univ ℓ) GroupStr ℓ
𝒮ᴰ-Group =
𝒮ᴰ-Record (𝒮-Univ _) IsGroupEquiv
(fields:
data[ _·_ ∣ autoDUARel _ _ ∣ pres· ]
data[ 1g ∣ autoDUARel _ _ ∣ pres1 ]
data[ inv ∣ autoDUARel _ _ ∣ presinv ]
prop[ isGroup ∣ (λ _ _ → isPropIsGroup _ _ _) ])
where
open GroupStr
open IsGroupHom
GroupPath : (M N : Group ℓ) → GroupEquiv M N ≃ (M ≡ N)
GroupPath = ∫ 𝒮ᴰ-Group .UARel.ua
-- TODO: Induced structure results are temporarily inconvenient while we transition between algebra
-- representations
module _ (G : Group ℓ) {A : Type ℓ} (m : A → A → A)
(e : ⟨ G ⟩ ≃ A)
(p· : ∀ x y → e .fst (G .snd ._·_ x y) ≡ m (e .fst x) (e .fst y))
where
private
module G = GroupStr (G .snd)
FamilyΣ : Σ[ B ∈ Type ℓ ] (B → B → B) → Type ℓ
FamilyΣ (B , n) =
Σ[ e ∈ B ]
Σ[ i ∈ (B → B) ]
IsGroup e n i
inducedΣ : FamilyΣ (A , m)
inducedΣ =
subst FamilyΣ
(UARel.≅→≡ (autoUARel (Σ[ B ∈ Type ℓ ] (B → B → B))) (e , p·))
(G.1g , G.inv , G.isGroup)
InducedGroup : Group ℓ
InducedGroup .fst = A
InducedGroup .snd ._·_ = m
InducedGroup .snd .1g = inducedΣ .fst
InducedGroup .snd .inv = inducedΣ .snd .fst
InducedGroup .snd .isGroup = inducedΣ .snd .snd
InducedGroupEquiv : GroupEquiv G InducedGroup
fst InducedGroupEquiv = e
snd InducedGroupEquiv = makeIsGroupHom p·
InducedGroupPath : G ≡ InducedGroup
InducedGroupPath = GroupPath _ _ .fst InducedGroupEquiv
uaGroup : {G H : Group ℓ} → GroupEquiv G H → G ≡ H
uaGroup {G = G} {H = H} = equivFun (GroupPath G H)
-- Group-ua functoriality
Group≡ : (G H : Group ℓ) → (
Σ[ p ∈ ⟨ G ⟩ ≡ ⟨ H ⟩ ]
Σ[ q ∈ PathP (λ i → p i) (1g (snd G)) (1g (snd H)) ]
Σ[ r ∈ PathP (λ i → p i → p i → p i) (_·_ (snd G)) (_·_ (snd H)) ]
Σ[ s ∈ PathP (λ i → p i → p i) (inv (snd G)) (inv (snd H)) ]
PathP (λ i → IsGroup (q i) (r i) (s i)) (isGroup (snd G)) (isGroup (snd H)))
≃ (G ≡ H)
Group≡ G H = isoToEquiv theIso
where
theIso : Iso _ _
fun theIso (p , q , r , s , t) i = p i , groupstr (q i) (r i) (s i) (t i)
inv theIso x = cong ⟨_⟩ x , cong (1g ∘ snd) x , cong (_·_ ∘ snd) x , cong (inv ∘ snd) x , cong (isGroup ∘ snd) x
rightInv theIso _ = refl
leftInv theIso _ = refl
caracGroup≡ : {G H : Group ℓ} (p q : G ≡ H) → cong ⟨_⟩ p ≡ cong ⟨_⟩ q → p ≡ q
caracGroup≡ {G = G} {H = H} p q P =
sym (transportTransport⁻ (ua (Group≡ G H)) p)
∙∙ cong (transport (ua (Group≡ G H))) helper
∙∙ transportTransport⁻ (ua (Group≡ G H)) q
where
helper : transport (sym (ua (Group≡ G H))) p ≡ transport (sym (ua (Group≡ G H))) q
helper = Σ≡Prop
(λ _ → isPropΣ
(isOfHLevelPathP' 1 (is-set (snd H)) _ _)
λ _ → isPropΣ (isOfHLevelPathP' 1 (isSetΠ2 λ _ _ → is-set (snd H)) _ _)
λ _ → isPropΣ (isOfHLevelPathP' 1 (isSetΠ λ _ → is-set (snd H)) _ _)
λ _ → isOfHLevelPathP 1 (isPropIsGroup _ _ _) _ _)
(transportRefl (cong ⟨_⟩ p) ∙ P ∙ sym (transportRefl (cong ⟨_⟩ q)))
uaGroupId : (G : Group ℓ) → uaGroup (idGroupEquiv {G = G}) ≡ refl
uaGroupId G = caracGroup≡ _ _ uaIdEquiv
uaCompGroupEquiv : {F G H : Group ℓ} (f : GroupEquiv F G) (g : GroupEquiv G H)
→ uaGroup (compGroupEquiv f g) ≡ uaGroup f ∙ uaGroup g
uaCompGroupEquiv f g = caracGroup≡ _ _ (
cong ⟨_⟩ (uaGroup (compGroupEquiv f g))
≡⟨ uaCompEquiv _ _ ⟩
cong ⟨_⟩ (uaGroup f) ∙ cong ⟨_⟩ (uaGroup g)
≡⟨ sym (cong-∙ ⟨_⟩ (uaGroup f) (uaGroup g)) ⟩
cong ⟨_⟩ (uaGroup f ∙ uaGroup g) ∎)
-- J-rule for GroupEquivs
GroupEquivJ : {G : Group ℓ} (P : (H : Group ℓ) → GroupEquiv G H → Type ℓ')
→ P G idGroupEquiv
→ ∀ {H} e → P H e
GroupEquivJ {G = G} P p {H} e =
transport (λ i → P (GroupPath G H .fst e i)
(transp (λ j → GroupEquiv G (GroupPath G H .fst e (i ∨ ~ j))) i e))
(subst (P G) (sym lem) p)
where
lem : transport (λ j → GroupEquiv G (GroupPath G H .fst e (~ j))) e
≡ idGroupEquiv
lem = Σ≡Prop (λ _ → isPropIsGroupHom _ _)
(Σ≡Prop (λ _ → isPropIsEquiv _)
(funExt λ x → (λ i → fst (fst (fst e .snd .equiv-proof
(transportRefl (fst (fst e) (transportRefl x i)) i))))
∙ retEq (fst e) x))
|
{-
The naive, but incorrect, way to define the integers as a HIT.
This file mainly contains a proof that IsoInt ≢ Int, and ends with a
demonstration of how the same proof strategy fails for BiInvInt.
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.Ints.IsoInt.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.Isomorphism
open import Cubical.Data.Int
open import Cubical.Data.Nat
open import Cubical.Data.Empty
open import Cubical.Relation.Nullary
data IsoInt : Type₀ where
zero : IsoInt
suc : IsoInt -> IsoInt
-- suc is an isomorphism:
pred : IsoInt -> IsoInt
suc-pred : ∀ z -> suc (pred z) ≡ z
pred-suc : ∀ z -> pred (suc z) ≡ z
suc-iso : Iso IsoInt IsoInt
suc-iso = record { fun = suc ; inv = pred ; rightInv = suc-pred ; leftInv = pred-suc }
-- this submodule is adapted from Section 5 of
-- http://www.cs.ru.nl/~herman/PUBS/HIT-programming.pdf
module NonTrivial where
-- these two paths are distinct!
p₁ p₂ : Path IsoInt (suc (pred (suc zero))) (suc zero)
p₁ i = suc-pred (suc zero) i
p₂ i = suc (pred-suc zero i)
-- to prove this we map into S¹, sending p₁ to refl and p₂ to loop
open import Cubical.HITs.S1
toS¹ : IsoInt → S¹
toS¹ zero = base
toS¹ (suc x) = toS¹ x
toS¹ (pred x) = toS¹ x
toS¹ (suc-pred x i) = refl {x = toS¹ x} i
toS¹ (pred-suc x i) = rotLoop (toS¹ x) i
p₁≡refl : cong toS¹ p₁ ≡ refl
p₁≡refl = refl
p₂≡loop : cong toS¹ p₂ ≡ loop
p₂≡loop = refl
-- this is enough to show that p₁ and p₂ cannot be equal
p₁≢p₂ : ¬ (p₁ ≡ p₂)
p₁≢p₂ eq = znots 0≡1
where -- using winding numbers, p₁ ≡ p₂ implies 0 ≡ 1
0≡1 : 0 ≡ 1
0≡1 = injPos (cong (winding ∘ cong toS¹) eq)
¬isSet-IsoInt : ¬ (isSet IsoInt)
¬isSet-IsoInt pf = NonTrivial.p₁≢p₂ (pf _ _ NonTrivial.p₁ NonTrivial.p₂)
¬Int≡IsoInt : ¬ (Int ≡ IsoInt)
¬Int≡IsoInt p = ¬isSet-IsoInt (subst isSet p isSetInt)
private
-- Note: this same proof strategy fails for BiInvInt!
open import Cubical.HITs.Ints.BiInvInt hiding (zero; suc; pred; suc-pred; pred-suc)
import Cubical.HITs.Ints.BiInvInt as BiI
p₁ p₂ : Path BiInvInt (BiI.suc (BiI.pred (BiI.suc BiI.zero))) (BiI.suc BiI.zero)
p₁ i = BiI.suc-pred (BiI.suc BiI.zero) i
p₂ i = BiI.suc (BiI.pred-suc BiI.zero i)
open import Cubical.HITs.S1
toS¹ : BiInvInt → S¹
toS¹ BiI.zero = base
toS¹ (BiI.suc x) = toS¹ x
toS¹ (BiI.predr x) = toS¹ x
toS¹ (BiI.predl x) = toS¹ x
toS¹ (BiI.suc-predr x i) = refl {x = toS¹ x} i
toS¹ (BiI.predl-suc x i) = rotLoop (toS¹ x) i
-- still p₂ maps to loop...
p₂≡loop : cong toS¹ p₂ ≡ loop
p₂≡loop = refl
open import Cubical.Foundations.GroupoidLaws
-- ...but now so does p₁!
p₁≡loop : cong toS¹ p₁ ≡ loop
p₁≡loop = sym (decodeEncode base (cong toS¹ p₁)) ∙ sym (lUnit loop)
-- if we use BiI.predr instead of BiI.pred (≡ BiI.predl) in p₁ and p₂,
-- both paths in S¹ are refl
|
State Before: α : Type u_1
β : Type ?u.231684
γ : Type ?u.231687
δ : Type ?u.231690
inst✝ : CancelCommMonoidWithZero α
a b c d : α
⊢ a * b ~ᵤ c * d → b ~ᵤ d → b ≠ 0 → a ~ᵤ c State After: α : Type u_1
β : Type ?u.231684
γ : Type ?u.231687
δ : Type ?u.231690
inst✝ : CancelCommMonoidWithZero α
a b c d : α
⊢ b * a ~ᵤ d * c → b ~ᵤ d → b ≠ 0 → a ~ᵤ c Tactic: rw [mul_comm a, mul_comm c] State Before: α : Type u_1
β : Type ?u.231684
γ : Type ?u.231687
δ : Type ?u.231690
inst✝ : CancelCommMonoidWithZero α
a b c d : α
⊢ b * a ~ᵤ d * c → b ~ᵤ d → b ≠ 0 → a ~ᵤ c State After: no goals Tactic: exact Associated.of_mul_left |
(* This program is free software; you can redistribute it and/or *)
(* modify it under the terms of the GNU Lesser General Public License *)
(* as published by the Free Software Foundation; either version 2.1 *)
(* of the License, or (at your option) any later version. *)
(* *)
(* This program is distributed in the hope that it will be useful, *)
(* but WITHOUT ANY WARRANTY; without even the implied warranty of *)
(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *)
(* GNU General Public License for more details. *)
(* *)
(* You should have received a copy of the GNU Lesser General Public *)
(* License along with this program; if not, write to the Free *)
(* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *)
(* 02110-1301 USA *)
(* Contribution to the Coq Library V6.3 (July 1999) *)
(* Notation management revised in December 2002 *)
(****************************************************************************)
(* *)
(* *)
(* leZ.v *)
(* *)
(* Definition of ``less or equal'' on integers *)
(* *)
(* *)
(* Samuel Boutin *)
(* Coq V5.10 *)
(* June 1995 *)
(* *)
(* *)
(****************************************************************************)
(* leZ.v *)
(****************************************************************************)
Require Import nat.
Require Import quotient.
Require Import integer_defs.
Section LEZ.
Open Scope nat_scope.
Definition leZ_XX (y x : Z_typ) : Prop := x .1 + y .2 <= y .1 + x .2.
Require Import Le.
Lemma le_with_plus1 : forall p n m : nat, n <= m -> p + n <= p + m.
auto with arith.
Qed.
Lemma le_with_plus2 : forall p n m : nat, p + n <= p + m -> n <= m.
exact (fun p n m : nat => plus_le_reg_l n m p).
Qed.
Lemma tech1 :
forall a1 a2 b1 b2 c1 c2 : nat,
a1 + b2 = a2 + b1 -> c1 + a2 <= c2 + a1 -> c1 + b2 <= c2 + b1.
intros.
apply (le_with_plus2 a1).
elim (plus_permute c1).
rewrite H.
repeat elim (plus_comm b1).
repeat elim (plus_permute b1).
apply (le_with_plus1 b1).
elim (plus_comm c2).
auto with arith.
Qed.
Lemma Compat_leZ_XX : forall x : Z_typ, Compat_prop Z_typ Z_rel (leZ_XX x).
simple induction x; intros c2 c1.
red in |- *.
simple induction x0; intros a2 a1.
simple induction y; intros b2 b1.
unfold leZ_XX in |- *; simpl in |- *.
unfold Z_rel in |- *; simpl in |- *.
elim (plus_comm a1).
elim (plus_comm c1).
split.
intro.
elim (plus_comm c1).
apply (tech1 a1 a2 b1 b2 c1 c2).
elim H; auto with arith.
auto with arith.
elim (plus_comm c1).
intro.
apply (tech1 b1 b2 a1 a2 c1 c2).
elim (plus_comm a1).
elim H.
elim (plus_comm a2).
auto with arith.
auto with arith.
Qed.
Definition leZ_X (z : Z) (x : Z_typ) : Prop :=
lift_prop Z_typ Z_rel (leZ_XX x) (Compat_leZ_XX x) z.
Lemma Compat_leZ_X : forall z : Z, Compat_prop Z_typ Z_rel (leZ_X z).
red in |- *.
simple induction x; intros a1 a2.
simple induction y; intros b1 b2.
unfold Z_rel in |- *; simpl in |- *.
apply (Closure_prop Z_typ Z_rel z).
unfold leZ_X in |- *.
simple induction x0; intros c1 c2.
repeat rewrite (Reduce_prop Z_typ Z_rel).
unfold leZ_XX in |- *; simpl in |- *.
intro.
repeat elim (plus_comm c2).
split.
intro.
apply (tech1 a1 a2 b1 b2 c1 c2).
elim (plus_comm b1).
elim H.
auto with arith.
auto with arith.
intro.
apply (tech1 b1 b2 a1 a2 c1 c2).
elim H.
elim (plus_comm b2).
auto with arith.
auto with arith.
Qed.
Definition leZ (z : Z) : Z -> Prop :=
lift_prop Z_typ Z_rel (leZ_X z) (Compat_leZ_X z).
Infix "<=" := leZ (at level 70, no associativity) : INT_scope.
Open Scope INT_scope.
Definition ltZ (z1 z2 : Z) : Prop := z1 <= z2 /\ z1 <> z2.
End LEZ.
(* Export Infix notations *)
Arguments Scope leZ [INT_scope INT_scope].
Arguments Scope ltZ [INT_scope INT_scope].
Infix "<=" := leZ (at level 70, no associativity) : INT_scope.
Infix "<" := ltZ (at level 70, no associativity) : INT_scope.
|
-- VOCABULARY
import tactic.norm_num
import syntax
import setsimp
def vocabOfFormula : formula → finset char
| (⊥) := set.to_finset { }
| ( (· c)) := { c }
| (~ φ) := vocabOfFormula φ
| (φ ⋏ ψ ) := vocabOfFormula φ ∪ vocabOfFormula ψ
| (□ φ) := vocabOfFormula φ
def vocabOfSetFormula : finset formula → finset char
| X := finset.bUnion X vocabOfFormula
class hasVocabulary (α : Type) := (voc : α → finset char)
open hasVocabulary
instance formula_hasVocabulary : hasVocabulary formula := hasVocabulary.mk vocabOfFormula
instance setFormula_hasVocabulary : hasVocabulary (finset formula) := hasVocabulary.mk vocabOfSetFormula
@[simp]
lemma vocOfNeg {ϕ} : vocabOfFormula (~ϕ) = vocabOfFormula ϕ := by split
lemma vocElem_subs_vocSet {ϕ X} : ϕ ∈ X → vocabOfFormula ϕ ⊆ vocabOfSetFormula X :=
begin
apply finset.induction_on X,
-- case ∅:
intro phi_in_X, cases phi_in_X,
-- case insert:
intros ψ S psi_not_in_S IH psi_in_insert,
unfold vocabOfSetFormula at *,
simp,
intros a aIn,
simp at *,
cases psi_in_insert,
{ subst psi_in_insert, left, exact aIn, },
{ tauto, },
end
lemma vocMonotone {X Y : finset formula} (hyp : X ⊆ Y) : voc X ⊆ voc Y :=
begin
unfold voc, unfold vocabOfSetFormula at *,
intros a aIn,
unfold finset.bUnion at *,
simp at *,
tauto,
end
lemma vocErase {X : finset formula} {ϕ : formula} : voc (X \ {ϕ}) ⊆ voc X :=
begin
apply vocMonotone,
rw sdiff_singleton_is_erase,
intros a aIn,
exact finset.mem_of_mem_erase aIn,
end
lemma vocUnion {X Y : finset formula} : voc (X ∪ Y) = voc X ∪ voc Y :=
begin
unfold voc vocabOfSetFormula,
ext1,
simp,
split ; { intro _, finish, },
end
lemma vocPreserved (X : finset formula) (ψ ϕ) :
ψ ∈ X → voc ϕ = voc ψ → voc X = voc (X \ {ψ} ∪ {ϕ}) :=
begin
intros psi_in_X eq_voc,
unfold voc at *,
unfold vocabOfSetFormula,
ext1,
split,
all_goals { intro a_in, norm_num at *, },
{ rcases a_in with ⟨θ,_,a_in_vocTheta⟩,
by_cases h : θ = ψ,
{ left, rw eq_voc, rw ← h, exact a_in_vocTheta, },
{ right, use θ, tauto, },
},
{ cases a_in,
{ use ψ, rw ← eq_voc, tauto, },
{ rcases a_in with ⟨θ,_,a_in_vocTheta⟩, use θ, tauto, }
},
end
lemma vocPreservedTwo {X : finset formula} (ψ ϕ1 ϕ2) :
ψ ∈ X → voc ({ϕ1,ϕ2} : finset formula) = voc ψ → voc X = voc (X \ {ψ} ∪ {ϕ1,ϕ2}) :=
begin
intros psi_in_X eq_voc,
rw vocUnion,
unfold voc at *,
unfold vocabOfSetFormula,
ext1,
split,
all_goals { intro a_in, norm_num at *, },
{ rcases a_in with ⟨θ,theta_in_X,a_in_vocTheta⟩,
by_cases h : θ = ψ,
{ right, subst h, unfold vocabOfSetFormula vocabOfFormula at *, simp at *, rw ← eq_voc at a_in_vocTheta, simp at a_in_vocTheta, tauto, },
{ use θ, itauto, },
},
cases a_in,
{ rcases a_in with ⟨θ,theta_in_X,a_in_vocTheta⟩, use θ, itauto, },
{ use ψ, split, itauto, rw ← eq_voc, unfold vocabOfSetFormula, simp, itauto, },
end
lemma vocPreservedSub {X : finset formula} (ψ ϕ) :
ψ ∈ X → voc ϕ ⊆ voc ψ → voc (X \ {ψ} ∪ {ϕ}) ⊆ voc X :=
begin
intros psi_in_X sub_voc,
unfold voc at *,
unfold vocabOfSetFormula,
intros a a_in, norm_num at *,
cases a_in,
{ use ψ, rw finset.subset_iff at sub_voc, tauto, },
{ rcases a_in with ⟨θ,_,a_in_vocTheta⟩, use θ, tauto, },
end
|
Did you know that reviews are very beneficial? A review is assessment of something in order to institute change if necessary. Reviews are quite a crucial deal in our daily business activities. This article tries to point out the most important aspects of having reviews. Enlisted below are some of the benefits of reviews.
First and foremost is that reviews form ac channel of free advertisement. A review posted by a customer is always an advantage to you because this is a form of advertisement to an individual's business. With these posts your products are placed on the market and your name is put to light with quality products. For more info on Reviews, click here to learn more. More so, with online review you can provide a vast exposure to masses of people that the local channels of marketing could not have accomplished.
Secondly, reviews have a greater influence on peer recommendation. Research has shown that most people would actually prefer peer recommendations. Most people would actually prefer reference and recommendations on several market products from people they have knowledge of. Recommendations will put your products to the market and thus enable growth of your enterprise therefore, making reviews very important.
On to the third benefit is that reviews always attract constructive criticism and reasonable suggestions. Some of the online reviews might raise questions relating to one's enterprise and suggest some possible solutions that may be aimed at improving such doubts. This can be a good practice that is aimed at improving customer needs and preferences. Satisfied customers will actually enhance the growth of your business and thus encourage peer recommendations and references leading to a more established business.
On to the fourth benefit is that reviews bring you closer to your customers. Like other channels example social media reviews will bring you ultimately closer to your customer. To read more about Reviews, visit www.crunchreviews.com/baby-tech/best-video-baby-monitor. As a business owner you are at a position to read and evaluate a range of customer's opinion. With this you can reply to customers with either positive or negative reviews showing that you are much interested with what customers actually suggest. Showing customers that you value their suggestions will bring you closer to them and thus allow you to gain respect among them.
Lastly, reviews will actually improve your search engine results. Search engine results take into account the number of times your business is mentioned in reviews. Therefore, with more mentions you are likely to appear in a higher rank. Learn more about Reviews from https://en.wikipedia.org/wiki/Review. |
The navies of Britain and France in 1794 were at very different stages of development . Although the British fleet was numerically superior , the French ships were larger and stronger , and carried a heavier weight of shot . The largest French ships were three @-@ decker first rates , carrying 110 or 120 guns , against 100 guns on the largest British vessels .
|
Require Export Base.
Module SCoprodCategory.
Structure mixin_of (C: Category) := Mixin {
scoprod {I}: (I -> C) -> C;
smerge {I} {X: C} {F: I -> C}: (forall i, F i ~> X) -> scoprod F ~> X;
sinto {I} {F: I -> C} (i: I): F i ~> scoprod F;
smerge_ump {I} {X: C} {F: I -> C} (f: forall i, F i ~> X) (g: scoprod F ~> X): smerge f = g <-> forall i, g ∘ sinto i = f i;
}.
Notation class_of := mixin_of (only parsing).
Section ClassDef.
Structure type := Pack { sort: Category; _: class_of sort }.
Local Coercion sort: type >-> Category.
Variable T: type.
Definition class := match T return class_of T with Pack _ c => c end.
Definition Cat: Cat := T.
End ClassDef.
Module Exports.
Coercion sort: type >-> Category.
Coercion Cat: type >-> Category.obj.
Notation SCoprodCategory := type.
End Exports.
End SCoprodCategory.
Export SCoprodCategory.Exports.
Section SCoprodCategory_theory.
Context {C: SCoprodCategory}.
Definition scoprod: forall {I}, (I -> C) -> C := @SCoprodCategory.scoprod C (SCoprodCategory.class C).
Definition smerge: forall {I} {X: C} {F: I -> C}, (forall i, F i ~> X) -> scoprod F ~> X := @SCoprodCategory.smerge C (SCoprodCategory.class C).
Definition sinto: forall {I} {F: I -> C} (i: I), F i ~> scoprod F := @SCoprodCategory.sinto C (SCoprodCategory.class C).
Definition smerge_ump: forall {I} {X: C} {F: I -> C} (f: forall i, F i ~> X) (g: scoprod F ~> X), smerge f = g <-> forall i, g ∘ sinto i = f i := @SCoprodCategory.smerge_ump C (SCoprodCategory.class C).
Notation "∑ i .. j , x" := (scoprod (fun i => .. (scoprod (fun j => x)) ..)) (at level 40, i binder).
Notation "∑' i .. j , f" := (smerge (fun i => .. (smerge (fun j => f)) ..)) (at level 40, i binder).
Notation ι := sinto.
Lemma from_scoprod_eq {I} {F: I -> C} {X: C} (f g: scoprod F ~> X): f = g <-> forall i, f ∘ ι i = g ∘ ι i.
Proof.
split.
now intros [].
intros H.
transitivity (∑' i, (g ∘ ι i)).
symmetry.
all: now apply smerge_ump.
Qed.
Definition scpmap {I} {F G: I -> C} (η: forall i, F i ~> G i): scoprod F ~> scoprod G :=
∑' i, (ι i ∘ η i).
Notation "(∑) i .. j , f" := (scpmap (fun i => .. (scpmap (fun j => f)) ..)) (at level 40, i binder).
Lemma smerge_sinto {I} {F: I -> C} {X: C} (η: forall i, F i ~> X) (i: I): smerge η ∘ ι i = η i.
Proof. now apply smerge_ump. Qed.
Lemma scpmap_sinto {I} {F G: I -> C} (η: forall i, F i ~> G i) (i: I): scpmap η ∘ ι i = ι i ∘ η i.
Proof. exact (smerge_sinto (fun i => ι i ∘ η i) i). Qed.
Lemma comp_smerge {I} {F: I -> C} {X Y: C} (f: X ~> Y) (g: forall i, F i ~> X): ∑' i, (f ∘ g i) = f ∘ smerge g.
Proof.
apply from_scoprod_eq.
intros i.
rewrite <- comp_assoc.
now rewrite !smerge_sinto.
Qed.
Lemma smerge_scpmap {I} {F G: I -> C} {X: C} (f: forall i, G i ~> X) (g: forall i, F i ~> G i): smerge f ∘ scpmap g = ∑' i, (f i ∘ g i).
Proof.
apply from_scoprod_eq.
intros i.
rewrite <- comp_assoc.
rewrite scpmap_sinto.
rewrite comp_assoc.
now rewrite !smerge_sinto.
Qed.
Lemma scpmap_id {I} (F: I -> C): (∑) i, id (F i) = id (scoprod F).
Proof.
apply from_scoprod_eq.
intros i.
rewrite scpmap_sinto.
rewrite comp_id_l.
apply comp_id_r.
Qed.
Lemma scpmap_comp {I} {F G H: I -> C} (η: forall i, G i ~> H i) (ϵ: forall i, F i ~> G i): (∑) i, (η i ∘ ϵ i) = scpmap η ∘ scpmap ϵ.
Proof.
apply from_scoprod_eq.
intros i.
rewrite <- comp_assoc.
rewrite !scpmap_sinto.
rewrite !comp_assoc.
f_equal.
symmetry.
apply scpmap_sinto.
Qed.
End SCoprodCategory_theory.
Notation "∑ i .. j , x" := (scoprod (fun i => .. (scoprod (fun j => x)) ..)) (at level 40, i binder).
Notation "∑' i .. j , f" := (smerge (fun i => .. (smerge (fun j => f)) ..)) (at level 40, i binder).
Notation ι := sinto.
Notation "(∑) i .. j , f" := (scpmap (fun i => .. (scpmap (fun j => f)) ..)) (at level 40, i binder).
Instance smerge_pw C I X F: Proper (forall_relation (fun _ => eq) ==> eq) (@smerge C I X F).
Proof.
intros f g H.
f_equal.
now extensionality i.
Qed.
Instance scpmap_pw C I F G: Proper (forall_relation (fun _ => eq) ==> eq) (@scpmap C I F G).
Proof.
intros f g H.
f_equal.
now extensionality i.
Qed.
|
(* Property from Case-Analysis for Rippling and Inductive Proof,
Moa Johansson, Lucas Dixon and Alan Bundy, ITP 2010.
This Isabelle theory is produced using the TIP tool offered at the following website:
https://github.com/tip-org/tools
This file was originally provided as part of TIP benchmark at the following website:
https://github.com/tip-org/benchmarks
Yutaka Nagashima at CIIRC, CTU changed the TIP output theory file slightly
to make it compatible with Isabelle2017.*)
theory TIP_prop_81
imports "../../Test_Base"
begin
datatype 'a list = nil2 | cons2 "'a" "'a list"
datatype Nat = Z | S "Nat"
fun take :: "Nat => 'a list => 'a list" where
"take (Z) y = nil2"
| "take (S z) (nil2) = nil2"
| "take (S z) (cons2 x2 x3) = cons2 x2 (take z x3)"
fun drop :: "Nat => 'a list => 'a list" where
"drop (Z) y = y"
| "drop (S z) (nil2) = nil2"
| "drop (S z) (cons2 x2 x3) = drop z x3"
fun t2 :: "Nat => Nat => Nat" where
"t2 (Z) y = y"
| "t2 (S z) y = S (t2 z y)"
theorem property0 :
"((take n (drop m xs)) = (drop m (take (t2 n m) xs)))"
oops
end
|
################################################
# Some usefull functions
stateToId <- function(state){
# Function stateToId
# Purpose: Convert state to id
state <- as.character(state)
state[state=="B"] <- 1
state[state=="T"] <- 2
state[state=="M"] <- 3
state[state=="R"] <- 4
state[is.na(state)] <- 0
return(as.numeric(state))
}
idToState <- function(id){
# Function idToState
# Purpose: Convert id to state
id <- as.numeric(id)
id[id==1] <- "B"
id[id==2] <- "T"
id[id==3] <- "M"
id[id==4] <- "R"
id[id==0] <- NA
return(id)
}
|
[STATEMENT]
lemma OclAsType\<^sub>O\<^sub>c\<^sub>l\<^sub>A\<^sub>n\<^sub>y_OclAny_strict : "(invalid::OclAny) .oclAsType(OclAny) = invalid"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
1. invalid .oclAsType(OclAny) = invalid
[PROOF STEP]
by(simp) |
State Before: R : Type u_2
B : Type u_1
F : Type u_3
E : B → Type ?u.410614
inst✝⁸ : NontriviallyNormedField R
inst✝⁷ : (x : B) → AddCommMonoid (E x)
inst✝⁶ : (x : B) → Module R (E x)
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace R F
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace (TotalSpace E)
inst✝¹ : (x : B) → TopologicalSpace (E x)
inst✝ : FiberBundle F E
ι : Type u_4
Z : VectorBundleCore R B F ι
b✝ : B
a : F
i j : ι
b : B
hb : b ∈ baseSet Z i
v : F
⊢ Trivialization.symm (localTriv Z i) b v = ↑(coordChange Z i (indexAt Z b) b) v State After: no goals Tactic: apply (Z.localTriv i).symm_apply hb v |
% This file was converted to LaTeX by Writer2LaTeX ver. 1.4
% see http://writer2latex.sourceforge.net for more info
\documentclass{article}
\usepackage{hyperref}
\makeatletter
\newcommand\arraybslash{\let\\\@arraycr}
\makeatother
\setlength\tabcolsep{1mm}
\renewcommand\arraystretch{1.3}
\title{QSB/ES 244 - Phylogenetics}
\begin{document}
\maketitle
Instructor: Emily Jane McTavish
Office: SE1 284, Email: [email protected]
Course website: \url{https://mctavishlab.github.io/GradPhylo}
and catcourses site
\section*{Introduction and Course Goals:}
This is a graduate course on phylogenetic methods covering theory, statistics and practice.
We will study the evolutionary models used to construct phylogenies (evolutionary trees),
how these phylogenetic estimates may be used to understand evolutionary processes.
We will focus on Maximum Likelihood and Bayesian approaches to inferring phylogenetic trees.
We will develop our computational skills to allow us to use High Performance Computing (HPC) resources to
perform phylogenetic analyses.
The course provides hands-on experience with several important phylogenetic software packages (PAUP*, GARLI, RAxML, RevBayes, BEAST2).
By the end of the course students should be able to understand much of the primary literature on modern phylogenetic methods and
know how to apply these methods to their own problems.
\section*{Textbook}
Paul Lewis, Phylogenetics (Sinuaer) Forthcoming
\section*{Learning outcomes}
By the end of this course you will:
\begin{itemize}
\item Understand the theory and statistics underpinning phylogenetic analysis.
\item Apply this theory to computational phylogenetic analyses and learn to use remote computing resources (MERCED cluster)
\item Assess and discuss primary research papers with a phylogenetic focus
\end{itemize}
\section*{Assessment}
\begin{itemize}
\item[25\%] Attendance and participation
\item[15\%] Paper discussion or research presentation
\item[30\%] Lab assignments and homeworks
\item[30\%] Final paper
\end{itemize}
\subsection*{Attendance and participation}
Come to class and discussion prepared, with assigned readings completed.
Attend at least 10 out of 15 Friday discussion sections.
Participate in paper and research discussions
\subsection*{Paper Discussion or Research Presentation}
Friday meetings can be a great opportunity to get feedback on your ongoing work and practice presentation skills.
You must either sign up to present your ongoing work (can be very informal!), or jointly sign up to present a paper (2 people).
When choosing a paper, select one that is:
\begin{itemize}
\item RECENT - ask permission for papers more than 5 years old (may be totally fine, but need a bit of a reason).
\item DATA or METHODS - Not review papers. They don't provide much to discuss. If the value of a paper is taxon specific, then it won't be broadly interesting. (or the taxon has to be REALLY COOL:)
\end{itemize}
If you are having trouble selecting a paper, browse through recent issues of Systematic Biology, Molecular Ecology, or Evolution.\\
Applications papers in other disciplines incorporating phylogeny are welcome!\\
\subsubsection*{Paper presentations}
\begin{itemize}
\item Send out the paper to the Phylogenetics discussion listserve at latest \textbf{before class on Tuesday}.
\item Presentations should be 10-20 minutes.
\item Focus on the methods and figures.
\item Set up questions for discussion.
\end{itemize}
\subsubsection*{Research presentations}
\begin{itemize}
\item Send out the title to the Phylogenetics discussion listserve at latest \textbf{before class on Tuesday}.
\item Presentations should be 20-30 minutes.
\item Specify questions or topics you would like advice/comments on.
\end{itemize}
\subsection*{Lab assignments and Homeworks}
Labs and or homeworks will be assigned most weeks, and will be turned in via the catcourses class site.
Pacing of the semester will be determined as we go,
so a full assignment schedule will not be available in advance.
The homework assignments should be worked on your own.
\subsection*{Paper}
A final paper will be due at the the time of the scheduled exam, Dec 11, 2017 at 6:30 pm.
The term paper will make up 40\% of your grade. The project can consist of a new
phylogenetic analysis (of your own data or published data) or a paper reviewing a research topic
in phylogenetic analysis. Please talk to me about your planned project before spending too much
time so that we can agree that the scope is appropriate.
\subsection*{QSB Program Learning Outcomes}
\begin{itemize}
\item ``Background definitions and motivation of fundamental statistical and modeling concepts in the context of quantitative and statistical challenges that exist for certain topics or approaches.''
\item ``Assessments of student understanding of fundamental statistical and modeling concepts and the ability to conceive, plan, execute and/or interpret the applications of these approaches to research questions.''
\item ``In-class discussion of primary research papers with major conclusions that depend on quantitative, statistical, or model-dependent approaches.''
\end{itemize}
\subsection*{ES Program Learning outcomes}
\begin{itemize}
\item Learning outcomes 1, 2 and 3, fulfill the ES Core Knowledge program learning outcome ``Graduates will be knowledgeable, skillful and self-directed in the observation and analysis of environmental systems in terms of their capacity to independently identify important research questions, develop experimental plans, analyze data, and formulate conclusions in the context of a doctoral dissertation''
\item Learning outcomes 1 and 2 develop applied statistical and computation skills which fulfill the the ES Career Placement and Advancement program learning outcome ``Graduates will find suitable career placement and achieve advancement in government agencies, non-government organizations, private industry, and/or academic teaching and research institutions''
\item Learning outcome 3 fulfills the ES ``Communication Skills'' program learning outcome. ``Graduates will be conversant in at least two areas of environmental systems, and be adept at oral, written and visual communication of research results to peers and non-technical decision makers''
\end{itemize}
\section*{Course Policies}
\begin{itemize}
\item[1.] Classroom interaction. I encourage personal views and critical inquiry based on the material and topics at hand. Equally, I expect that the viewpoints of others will be respected. Consider this course to be valuable practice to engage with your peers through professional communication and scholarly discourse.
\item[2.] Special accommodations. Students who need special accommodations are required to submit the form to me in person, preferably outside of class (e.g. office hours) within the first two weeks of the quarter. If you will be requesting academic accommodations, you must first contact the Disability Services (http://disabilityservices.ucmerced.edu/) to make arrangements.
\item[3.] Academic integrity. The University has established codes concerning proper academic conduct and the consequences resulting from improper behavior.
Please be aware of these policies. The official UC Conduct Standards can be found at: http://studentlife.ucmerced.edu/content/uc-conduct-standards
\item[4.] Life as a UC-Merced Student. Your course facilitators are aware of the many pressures we all face. There are many campus services specifically suited to help you throughout your university career, please take advantage of your resources, including: University academic advising (http://advising.ucmerced.edu/), Health Services (http://health.ucmerced.edu/), and University Counseling and Psychological Services (http://counseling.ucmerced.edu/).
\end{itemize}
\section*{Topics}
It is very likely that we will run out of time, and not be able to cover all of these topics; so
please, speak up and give me some feedback about what topics are most important to you!\\
\begin{itemize}
\item Intro, Statistical inference, tree terminology
\item Compatibility/Parsimony
\item Distance-based tree estimation
\item Distance methods/Searching
\item Models and Model selection
\item Maximum likelihood
\item Rate heterogeneity
\item Consistency
\item Topology testing
\item Branch Support
\item Bayesian Phylogenetics
\item Ancestral character state reconstruction
\item Comparative methods
\item Divergence time estimation
\item Multiple Sequence Alignment
\item Coalescent
\item Gene tree/species tree analyses
\item Ancestral state reconstruction
\item Stochastic character mapping
\end{itemize}
\subsection*{Additional Resources:}
Bininda-Emonds, Olaf R.P. (Ed.) 2004. Phylogenetic supertrees - Combining information to reveal the Tree of Life Series: Computational Biology , Vol. 4. Springer.ISBN: 978-1-4020-2329-3 - QH367.5 .P475 2004\\
Felsenstein, J. (2004) Inferring Phylogenies. Sinauer, Sunderland. Product Code: 0-87893-177-5 - QH83 .F45 2004\\
Hall, B.J. (2004) Phylogenetic trees made easy: a how-to manual 2nd ed. Sinauer, Sunderland. Product Code: 0-87893-312-3 - QH367.5 .H27 2004\\
Hennig, W. et al. (1999) Phylogenetic Systematics. University of Illinois Press.ISBN 0-252-06814-9. \ {}- QL351 .H413 1979\\\
Hillis DM, Moritz C, Mable BK, Graur D. Molecular systematics. Sinauer Associates Sunderland, MA; 1996 ]{Hillis DM, Moritz C, Mable BK, Graur D. Molecular systematics. Sinauer Associates Sunderland, MA; 1996\\
Page, R.D.M., editor (2002)Tangled Trees: Phylogeny, Cospeciation, and Coevolution.University of Chicago Press.ISBN: 978-0-226-64467-7 (ISBN-10: 0-226-64467-7) - QH367.5 .T36 2003\\
Scotland, R. \&R.T. Pennington (2000) Homology and Systematics: Coding Characters for Phylogenetic Analysis. Systematics Association Special Volumes Volume: 58. ISBN: 9780748409204 - QH367.5 .H65 2000\\
Semple, C. Steele, M.A. PhylogeneticsOxford ; New York : Oxford University Press, 2003.\\
Steel M. Phylogeny: Discrete and random processes in evolution . SIAM; 2016 \\
\end{document}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.